Repository navigation
Close six construct classes of the lift, carry certified roots under one key, and install the Prism factory - #10
Conversation
…rs unshadowed Three places wrote a list one `cons` per element, so a literal as long as its author liked nested past the depth the LexLean linker reads a term to: an array or `vec!` literal, a byte-string literal, and the pieces of a format string (LLP2001). The names a feature, a journey and a threat mapping list were written the same way and met the linker's 128-level semantic JSON bound (LLT4001) on a module with many accepting tests. All of them are now `embed::term_list`, the balanced `append` of halves the threat-model evidence already used. A guarded match row's binders wrap the whole conditional, so the rows after it are written inside them. A later row that bound the same Rust name to another part of the scrutinee (an or-pattern whose alternatives bind one name, then a guard) reused the binder and the linker refused the shadowed `let` (LLT4001). The later rows now see those names as taken. The thermostat fixture is regenerated: its lists are the same lists in the balanced form. `prismpm check` reads a feature's lists in that form from UOR-Foundation/prismpm#688 on. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
The projection now writes every list literal as balanced halves, and the pinned SDK's prismpm refused that form in a feature's calls and acceptance and a journey's steps (PP2018). The SDK image is rebuilt by sdk-patch.yml at PrismPM 0694e632, which is the pinned 4834b5c5 plus UOR-Foundation/prismpm#688, and prismpm.lock, the devcontainer and template.lock name it. upstream.toml records the fix as a patch row and the rows already there name the image they are now carried in. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
4c22c9e to
617d85d
Compare
|
This is not from this pull request. The same assertion fails on the base: bootstrap run 43779526416 on I will merge Generated by Claude Code |
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…ofile The certified translator's steps were bound to the tool's own workspace by constants. A profile now says what an export is of (scope, entry, package prefix, effects, target, and whether its roots are the functions or the cases); the constants are its default, so the translator's own gate reads as before, and its committed manifest and crate are written byte for byte. A workspace states its profile with --workspace (every function of its register in scope, packages named after its directory), the [workspace.metadata.uorust.certify] table of its Cargo manifest, and the command's options. The export records the profile beside what it keeps; sync takes the packages into the directory the caller names under it, writes the crate's Cargo manifest when the directory has none, and states the profile in the manifest; the ratchet measures the scope the head's manifest states and refuses a head that measures less than its base. certify roots decides without a build which roots the compiler admits (lexlean check on the marked project), ranked by the class of their cause. The agreement of any workspace is its cases: each closed assertion of a test the projection already proves is a production root with no parameter (--cases); certify agree --cases runs every certified case with rustc and the test that states it with cargo, and refuses each case that parts. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
… into Quality The workspace lift register carried its honesty report only as comment lines and no ranked queue, so a project had to rank its own. It now states, as data beside its rows, the totals ([lift]: functions, lifted, residue, foreign, effect) and one [[construct]] row per cause and detail with the functions it blocks, the most blocked first: the order and the row shape of the queue the core register carries. Register::parse holds a stated total or queue to the rows, and reads a register written before either existed by its rows alone; admission is unchanged and gains no count ceiling. A projection's frontier.toml carries the same [lift] table and queue, and [admission] with one ranked [[reason]] row per refusal reason. The Quality facet states the lift as measures of the model, built as the other measures are: the functions of product code, those that lifted and the open refusals, read from the register parsed from the function rows the same run writes. Quality is built after Behavior and Library, which add to both. Every module of a projection is compared with the max_file_bytes read back from the lexlean.toml the same run writes; a module beyond it ends the run in the typed ModuleTooLarge, naming the module and both sizes. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…r it A type residue row named the nearest struct or enum the lift does not name, and not why: `Mid` for a struct whose field's field is an `f64`. The row now carries the chain down to the leaf, `Mid.leaf: Leaf.x: f64`: from the type, the first field in declaration order that is outside and under which a leaf lies without passing through a type already on the chain. An enum's field is written `Enum::Variant.0` or `Enum::Variant.name`. A recursion Lean nests no inductive under, a name LexLean writes for a type of its own, and a struct with a type or const parameter are leaves that say so. The head of a type is read before its arguments, so `RefCell<T>` is the leaf whatever `T` is. The owner of an inherent method is named the same way. Forms the type side now reads, each lowered to LexLean that verifies: - `Rc<T>` and `Arc<T>` as `T`, as `Box<T>` is: through either a function reaches only `&T`, so a pure function of the pointer is a function of its content, and nothing the lift reads tells two owners of equal content apart. `Rc::new`, `Arc::new` and `Rc::clone(&x)` are the content. `RefCell`, `Cell` and `Mutex` stay outside, each the leaf. - `i128` and `isize` as the mathematical `Int`, as `u128` and `usize` are `Nat`: literals, order, equality (neither value below the other), widening casts, and for `i128` the checked operations within -2^127..2^127-1. A checked operation on `isize` is width residue, as on `usize`. - A struct of no fields as the inductive of one constructor, a tuple struct with its fields named by position (`value.0`, `S(a)`, `Self(a)`), and a struct with a lifetime parameter as the owner of its methods (`impl<'a> Reader<'a>`). - `VecDeque<T>` as the list of its items and `Range<T>` as the pair of its bounds; a type of the standard library by its full path (`std::collections::BTreeMap<K, V>`); a workspace type named as LexLean names one of its own under its crate's name. Every struct is registered by the reader, so that one the lift does not read is named with its shape. Two functions that share a path (the `fmt` of `Display` and of `Debug` on one type) keep one row: where one of them did not lift, the row says so, where the register failed to parse before. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
… package a case names A case's definition is long enough that its package name passed a crate name's 64 characters, which the compiler refuses (LLC0201): a longer name keeps its start and ends with digits of its own SHA-256, and two roots that come to one package are refused by name. An adapter calls the profile's own certified crate and is named by the function's path in its own crate, so a workspace that runs its certified packages in place of its functions gets its adapters' module from the same sync. The ratchet says what it counts in the profile's words and names the whole register when that is the prefix left out. The agreement's harness prints what each case returns and the tool reads the answer, so no generated source names an error the model does not sanction; every package whose name fits a case has its tests run, and the test function's own key decides which states the case. The certify commands on a workspace that is not the translator's have tests of their own. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
A struct or enum declared twice in one module (one per build configuration) and a name several types of a crate share, written in a file that neither declares nor imports one of them, were dropped from the types the lift reads, so a row they stopped named the type and not why. Each is now registered with its reason as its shape, so the row reads `Handle: a type declared twice in one module` or `Shape: one of several types of this name in its crate, which the file does not tell apart`. Tests on a synthetic workspace cover both reasons, the files that tell a shared name apart, the chain to the leaf from a method's owner, a type named as LexLean names its own, and two functions of one path. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…s stand apart Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
… as test code A file a mod declaration names under a test cfg, and named by no declaration outside test code, is test code, as an inline test module is. The cfg rule is a predicate over the parsed cfg instead of a substring test. A method of a trait implementation whose type the lift names lifts as a function of that type with self first, named by type, trait and method so the name stays unique; a call is read as it only where the trait is in scope. A default method lifts where its body uses nothing of an implementing type, and otherwise stays signature residue naming what it uses. A method of a type outside the lift names the type and why. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
The lift writes a list literal as the append of its halves down to runs of its length's bit length, so a three-item list is one item appended to two. The fixture test still looked for the one run. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…fore admission refuses them A new names module reads each module's use bindings, globs and inline modules and each body's calls with the types the code writes, and resolves a call as Rust does: Self and self to the impl's type, a path through the use bindings and the nearest enclosing module, a method by the written type of its receiver. Only a call the written code leaves open is refused as ambiguous; a call the rules cannot follow falls back to the name rules. A bare type name a use binds to a registry crate is that crate's type, so its function is a foreign row. Items of one path under cfg predicates no build holds together are one fact: the projection states the variant the default features compile and records each other as a cfg-variant claim. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Both lanes state why a type is outside the lift. A type the workspace registers is named by the chain down to its leaf, for a method's type as for a parameter's; the cause read from the crate's source remains for a type the registration does not hold. A tuple struct and a struct without fields are read as structs, so they are no longer unread shapes, and two traits' methods of one name on one type are two register paths. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
The register refused the merge for four functions of this workspace that were lifted and no longer were: - is_lifetime indexed a string by a range, a form outside the lift, and Types::resolve, which calls it, stopped with it, and its callers with it. It strips the quote as a prefix now. - The name resolver's private type shared its name with a type of the syntax tree, so a function over the latter, written through a module alias, read as no one type. The resolver's type has its own name. - A function alone of its name took the name a module had given another (mir_memory_axioms beside axioms of mir::memory), and whichever the projection reached first kept it, also when it then failed in its body. It takes its module's name too, as functions of one name do. - A type's own method reached first kept a name a free function also lifts to. The free function keeps it, as it does against a trait's method. Two tests state the last two rules; both fail with the rules planted out. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Written by the register recipe's steps (uorust mir, then uorust project with the register and the committed verdicts): no function it recorded as lifted is decided otherwise. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…unsanctioned error The model gate's rule on limits reads every line of shipped code: a `Result` names one of the sanctioned error types or the line is refused. Two lines of the merged lanes did not: the reader of a source file took the parser's `Result` as a parameter, and the register's check of its stated totals and queue returned `Result<(), String>`. The reader now takes a parsed file, and a file `syn` does not parse gets its facts from `unparsed`, which records where and why. The register's check returns how the stated totals or queue differ from the rows, if they do, and its one caller turns that into the engine's own error. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
`just self-model-write` in the locked SDK: the Features and Security facets cite source lines of `main.rs`, `lib.rs` and `ingest.rs` that the merged lanes moved. `just self-model-check` and `just template-check` pass on the result. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
`Register::parse` reads the function rows, as it did before a register carried its totals and its queue. `Register::read` is the reader of a register its generator wrote: the rows, and the stated totals and queue held to them. Admission against an incumbent register and the commands that read a register file use `read`. The translator ratchet's own planted defect (the committed register with one more row, parsed and then refused by the ratchet) appends a row to a text that states its totals; with the check inside `parse` the planted register was refused as malformed before the ratchet saw it. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
|
The gate on this branch now passes What fails.
What blocks the fix. The manifest is written only by the export ( Fixed in the same run. Update, 16 November 06:00 UTC, head cad281e. The gate now stops one part earlier, in Two things changed on the branch since the first note. 00e2795 merged main (the certified translator had landed there). The regeneration of a pull request's branch that 7ac726d added ran once (e86170d) and was then taken off the push in cad281e, and the export it had dispatched on this branch (run 43809385162) was cancelled: neither run is keyed on what changed, and the export builds again every root already certified at the same content. The ten lifted functions will be exported once an export carries what the manifest already certifies and builds only the rest. Generated by Claude Code |
A pull request that adds or edits translator functions could not be green: only main's runs write frontier.toml and the certified manifest, and the ratchet (UE-18) compares the head with main. generate.yml now also runs for a pull request from a branch of this repository (and for a dispatch on such a branch): every writer runs on the branch merged onto main (scripts/ci/merge-main.sh), and the result is pushed to the branch as that merge, first parent main, so the gate dispatched on it reads generated files of the very tree it gates and compares the ratchet with main, as the pull request's own gate does (scripts/ci/push-branch.sh, a fast-forward, never forced, never to main). When the merged tree's translator has more uncertified functions than main's, certified.yml is dispatched on the branch with land_branch: it exports there, lands on the branch the same way, and dispatches generate.yml again, which gates what landed. Each branch has its own queue in both workflows; a fork's pull request runs nothing; certified's gate jobs stay main's; certified-prior.sh reads the manifest of its own branch, else main's. Main's own path is unchanged. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…ves a refuted obligation A compiling obligation reads .cargo/config.toml, so it joins the manifests set; the graph is compiled into the plan root, so the certified core is verified and exported again (result 35d353b2...). factory.sh run and start exit 1 when the plan holds a refuted obligation, since a second run of a refuted tree runs nothing. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
A root's export identity now also binds the packages the project links (the workspace file and each source package's tree, transitively) and the relative order of the declarations its closure holds. A root is carried only into a project that verifies: the prior export verified a project of the same identity, which the manifest now records, or the production project verifies once before anything is carried; otherwise every root is built. Each carried package keeps the edition its Cargo manifest declared, so a sync of carried packages alone writes it. The plan and the export decide carrying and refusals in one place, so both count the marking's refusals. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
… an interrupted command from refuting The refuter of the factory confirmed eight counterexamples. This commit fixes each one. - `test` read files it did not declare: prism-factory/, the brand's foundation stylesheet, scripts/hooks/passes.py and the R2 documents. It now declares them. `graph.py reads` refuses, before the plan, a test target that names a tracked file its obligation does not declare, or a compiled source that embeds one. - UE-18 read the parent from history. The host now runs each closure as its own repository, taking upstream forge.rs's base and closure commit. The parent holds exactly the `@base:` entries the obligation declares, and `test` declares the register and the manifest. Under CI or in a factory closure, a missing base fails UE-18 instead of skipping it. - Cargo read configuration from above the closure. The host refuses a work directory with a cargo or rustup configuration in any ancestor. In the SDK, sdk.sh gives the command its own cargo home, without configuration or credentials. `factory-model` declares rust-toolchain.toml. - A command stopped by a signal was recorded as a failure. It now leaves no receipt, and the run exits 75. - `run` and `start` take a flock on the store, and the detached run holds it, so a second start is refused. - The status line reads `interrupted SIGNAL` when the run did not end by itself, and `factory.sh status` reports a `running` line whose process is gone as stale. - The README copies upstream's identity text verbatim. Its Limits name the workflows that still run the gate and the writers whole. The graph changed, so the certified core is re-exported. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
The self model's feature list is taken as the factory branch wrote it; the writer regenerates it on the merged tree next. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…ders ctor, std_path, field_name and tuple_struct are rewritten inside the fragment the tool lifts from itself, with their behaviour pinned by tests that pass on the old bodies and fail with each planted defect: - ctor compares a one-element variant list by its length and its item, not by Iterator::eq; - std_path tests a segment's arguments by pattern, not by == on the enum; - field_name reads a position as u32, a width fixed on every target, since rustc numbers a struct's fields by a 32-bit index; - tuple_struct writes the position by format!, not usize::to_string. Their callees follow: camel and pascal (the digit prefix is a returned value, not an insert; the first character lowered by position), local_name and struct_value (a collect into String says so) now lift. fields_read and variants_read keep their behaviour without ? in a closure or Vec::new; each now stops only at Types::ty. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
The first keyed export: every root built once (158, in two batches), so that the manifest records the identity each package was built under and a later export carries every root whose identity is unchanged. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
The export built all 167 roots; the 158 already certified came out byte for byte as the last export left them, and camel, pascal, ctor, field_name, local_name, std_path, struct_cells, struct_value and tuple_struct are new. The ratchet against main: 508 translator functions uncertified against 515. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…echanism Main (6d6b4e6) and this branch each carried certified roots, by two keys. One is left: the branch's key, which also covers a linked package's tree, the relative order of a closure and the project's configuration, under main's names (the manifest's `closure` row, closure_kappas, CLOSURE, closures.toml). The reader also takes the first keyed export's `identity` rows; main's `closure` rows of its own tag never match and are built once. `--carry` stays a list of source directories, of which main's single crate is one. The project a carried root goes into is no longer verified with every root marked, which outgrows the compiler's total budget on the translator's own project: a build of the export that published has verified it (every build verifies the whole selection), and when none did, one verification with a single carried root marked does. When it refuses, the carried roots are built as a fresh export builds them; an export that stops first publishes none. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Main's closure-keyed carry and the branch's keyed export are one mechanism now: one key in the manifest (closure), carried roots published only into a project that a build or one verification of the export has verified. The nine roots certified since take the same key. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…herever it runs Two tests of the keyed export expected a build to fail for want of a compiler, so they passed where no lexlean is installed and failed in the SDK container, where the real compiler ran on their synthetic project. The compiler of an export now states its program, every build and replay runs that program and never whichever lexlean the path holds, and the tests use a stand-in program that exists nowhere. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
The export of this tree under the one carry: 140 of the 167 certified roots are carried from the prior export, 27 are built in two builds, and 16 are refused (15 by the compiler, 1 by the marking). The gate's own count against main: 508 translator functions uncertified, none more than in the base. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…anifest as this tree's export wrote it Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…ll the resolution leaves open Since names resolves calls as the language does, the UE-03 crate's go() is a::go through the glob import and holds no ambiguous call. The test now adds a valid call the resolution cannot decide, Wide::from of a field whose type it does not read, with two From impls, and demands each of the four reasons from an open refusal row, the ambiguous call with its span and both candidates. The lift read a name two modules share through the file's own module and its direct use bindings only, so a call admission resolved through a glob was "not lifted". resolve now keeps, for each function, the one function the resolver names for each call it writes, and the lift's candidates read a shared name as that function before the file's reading. A new test lifts the old crate's run as a call of a::go. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
The frontier now opens with the work queue, one [[reason]] row per refusal reason with its count, so a substring count of a reason text counts the queue row as well: UE-12 found five unanswered-advisory texts for four refusals. The engine tests now parse the frontier: UE-12 counts the [[refusal]] rows of that reason and holds the queue row's count to them, the advisories-unconsulted check reads one refusal row and its queue row, and UE-04 reads the residue rows of a function by its name instead of splitting the text. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
UE-16 compared the frontier's rows with every package its walker found below the root, by a list of directory names to skip. The installed Prism factory brings three packages that are not members of this workspace (its host, which declares its own workspace, and two crates a LexLean production generated), so the walker counted their functions although the projection, which reads cargo's workspace, rightly gives them no row. The walker now reads the root manifest's members globs and exclude list itself and walks exactly those packages, so a member with no row still fails the test whatever its directory is called and a package that is not a member is not counted. It also leaves out the files of an out-of-line #[cfg(test)] module, which the projection no longer reads as product code. A planted workspace pins the walker's rule; the doc comment names what the rule leaves outside today. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
certify plan prints what an export will carry, build and refuse beside its shards and the roots to diagnose. The test held the old two-key line; it now holds the whole new one. The workflow's plan job reads shards and diagnose with jq, and cli.rs parses the JSON, so neither depends on the line having only those keys. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
The test of the manifest's text form had lost the closure of its one root when the two carries became one, so it no longer showed that a closure survives writing and reading. The value is back. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
…the first step A root's identity hashed, whole, each module that Behavior's or Prelude's frame imports, but not a module that one of those imports in turn. A body two imports away was therefore in no root's identity: after it changed, an export carried the package built from the old body and published it as certified for the new projection. The walk now follows imports to the end (a cycle of imports ends it), and each module it reaches is bound whole. The tool's own projection writes Behavior and Prelude alone, so its roots keep their identities. The test builds the case (Behavior imports Helpers, Helpers imports Deep, Deep's body changes) and fails when the walk stops at the first step. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
The register after the repairs and the identity fix, and the manifest of the export of this tree: 166 of the 167 certified roots carried, 1 built (391 s), 16 refused (15 by the compiler, 1 by the marking). The gate's own count against main: 508 translator functions uncertified, none more than in the base. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ
Requested by Alex · project thread
What
Projecting a large Cargo workspace stopped at whole classes of construct, and every certified export built every root again. Each item below closes one of those as a general rule of the tool, with tests on synthetic crates. The branch is merged with
mainat 97f0c9c.The lift and the register (unchanged since the first pushes)
vec!literal, a byte string and the pieces of a format string go throughembed::term_list(balancedprim appendhalves), so nesting stays under the linker's bound (LLP2001). A guarded match row hides itsletnames from the rows compiled after it.ingest.rs,project.rs,lift.rs). A file amoddeclaration names only under a test cfg is test code. A trait implementation's method lifts as a function of its type and is a call target only where the trait is in scope. A default method lifts when its body uses nothing of an implementing type.lift.rs). A type row names the chain down to the leaf that is outside the lift.Rc<T>andArc<T>read asT,i128andisizeasInt. Tuple structs, structs without fields, owners with a lifetime parameter,VecDeque,Rangeand standard types written by their full path are read.names.rs). Admission resolves a call and an imported type by the language's own name resolution before it refuses them.register.rs,project.rs).uorust/register/1carries a[lift]table and one[[construct]]row per cause, ranked by the functions it stops.certifyfor any workspace (certify.rs,certify/profile.rs,certify/cases.rs). Export, take in, ratchet and agree run under a profile read from the workspace.prismpm.lock,.devcontainer/devcontainer.jsonandtemplate.lockname the SDK image that reads a feature's and a journey's lists in the balanced form (fix(features): a feature's and a journey's lists are read as balanced appends UOR-Foundation/prismpm#688).New in this push
certify.rs,main.rs).maingained a carry keyed by a closure κ in 6d6b4e6 while this branch built one keyed by an export identity. They are now one mechanism: this branch's identity text (taguorust/certified-root/1: the compiler's own version lines, the target descriptor, the admitted effects, the project's files, the linked packages' trees, the frames of Behavior and Prelude, every module their imports reach, the root's closure by declaration and its relative order) under main's names (the manifest rowclosure,closure_kappas,--carry). A row of main's tag is read and built once. A carried root is published only when the prior export verified a project of the same identity, or a build of this export published, or one verification of the project with a single carried root marked passes. An independent refuter attacked both keys on synthetic projections; main's key carried a stale package for reordered declarations and for a false theorem in a module no root reaches, and this branch's did for a module reached through another module's import. Each case is now a test that fails with its defect planted.crates/certifiedholds 167 roots (151 onmain). On this tree an export carries 166 of them and builds 1 (391 s); the first keyed export built all of them in two builds of about 30 minutes each on two workers.lift.rs,lex.rs,mir/: the unit-value, library-path and field-name readers), rewritten inside the fragment the tool lifts, behaviour pinned by tests first. UE-18 on this tree: "508 translator functions uncertified, none more than in the base" (mainhad 515 at c731485).prism-factory/): each long step of the gate and of the writers is an obligation keyed on what it reads, so a step whose inputs did not change is not run again. An interrupted command does not refute its obligation, and a run that leaves a refuted obligation fails.cargo testbefore them).Compilerstates the program an export builds with, so the keyed tests agree on every machine. UE-03's crate holds a call the resolution really leaves open, and the lift now reads a shared free-function name as admission resolved it (a glob import was read as no function). UE-12 reads the frontier's refusal rows, not reason texts. UE-16 counts the product code of the workspace's members as cargo lists them, so the factory's own host package is not counted. The plan test holds the whole line the plan prints.Checked
One script ran, in the SDK container, the writers (
fmt,self-model-write,fixtures,prove-fixture,prove), the certified export (certified-project,certified-plan,certified-export,certified-sync),just ratchet origin/main, the writers the export feeds, and then every recipe ofjust vvwithcargo test --workspace --locked --no-fail-fast:certified-project180 s;certified-export: "166 roots carried from the prior export, 1 to build in 1 batches on 2 workers, 16 roots refused before any build", then "1 roots published in 391s";certified-syncexit 0 (214 s), which includes clippy on the certified crate and thecertiflib tests.just ratchet origin/mainwithmainat 97f0c9c: "508 translator functions uncertified, none more than in the base".just vv:fmt-check,model,template-check,self-model-check,lint,denyanduorust(621 s) exit 0.cargo test --workspace --locked --no-fail-fast: 19 test binaries, 318 passed, 0 failed.app: exit 0 in 380 s ("verified attestation: 073ea78a70bb…") on a second run alone. Its first run in the same pass ended with "No space left on device" while the dependency build cache was on that machine's disk; nothing of the tree changed between the two runs.frontier.tomlandcrates/certified/manifest.toml).Known and left open
The first export on the forge after this merge builds every root once.
certified.ymltakes the prior manifest from the newest artifact, which has main's shape (noeditionrow, main's tag), so nothing is carried until this tree's manifest is the artifact. The committed manifest already has the new shape.certify plancounts carry candidates. When the project does not verify, the export builds the candidates the plan counted as carried, so the plan's shard count is low for that one run. Nothing is published wrongly.A wrong reading that is on
maintoo, not fixed here. A call inside an inline module to a function that shares its name with one of the file's own module is read as the file's function (the site key names the file's module, not the inline module). Main's tool at c731485 and this branch both liftinner::runof the crate below asgoof the root (3) where Rust returns 4. A test that states the value makes the kernel refuse the projection; without one the lifted body is wrong. The repair is in progress on a separate branch and will follow as its own pull request.🤖 Generated with Claude Code
https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ