Skip to content

Close six construct classes of the lift, carry certified roots under one key, and install the Prism factory - #10

Merged
afflom merged 61 commits into
mainfrom
claude/project-thread-hboh76
Nov 16, 2026
Merged

afflom merged 61 commits into
mainfrom
claude/project-thread-hboh76

Conversation

@afflom

@afflom afflom commented Nov 16, 2026 •

Copy link
Copy Markdown
Owner

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 main at 97f0c9c.

The lift and the register (unchanged since the first pushes)

  1. Long list literals and guarded rows. An array or vec! literal, a byte string and the pieces of a format string go through embed::term_list (balanced prim append halves), so nesting stays under the linker's bound (LLP2001). A guarded match row hides its let names from the rows compiled after it.
  2. Functions refused by their signature or misread by where they stand (ingest.rs, project.rs, lift.rs). A file a mod declaration 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.
  3. Types (lift.rs). A type row names the chain down to the leaf that is outside the lift. Rc<T> and Arc<T> read as T, i128 and isize as Int. Tuple structs, structs without fields, owners with a lifetime parameter, VecDeque, Range and standard types written by their full path are read.
  4. Names (names.rs). Admission resolves a call and an imported type by the language's own name resolution before it refuses them.
  5. The register as the work queue (register.rs, project.rs). uorust/register/1 carries a [lift] table and one [[construct]] row per cause, ranked by the functions it stops.
  6. certify for any workspace (certify.rs, certify/profile.rs, certify/cases.rs). Export, take in, ratchet and agree run under a profile read from the workspace.
  7. One name per function, whichever lifts first.
  8. The SDK. prismpm.lock, .devcontainer/devcontainer.json and template.lock name 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

  1. One carry of certified roots, merged with main's (certify.rs, main.rs). main gained 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 (tag uorust/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 row closure, 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.
  2. The export of this tree. crates/certified holds 167 roots (151 on main). 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.
  3. Nine more translator functions lift from the tool's own source (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" (main had 515 at c731485).
  4. The Prism factory with the tool's graph (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.
  5. Tests that no earlier push had run to the end (the conformance ratchet stopped cargo test before them). Compiler states 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 of just vv with cargo test --workspace --locked --no-fail-fast:

  • Writers before the export: every recipe exit 0.
  • Export: certified-project 180 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-sync exit 0 (214 s), which includes clippy on the certified crate and the certif lib tests.
  • just ratchet origin/main with main at 97f0c9c: "508 translator functions uncertified, none more than in the base".
  • just vv: fmt-check, model, template-check, self-model-check, lint, deny and uorust (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.
  • The gate ran on 87c8d82 with the writers' output in the work tree; that output is the head commit 6967ebe (frontier.toml and crates/certified/manifest.toml).
  • Each new rule has a test that fails with its defect planted: the transitive import (the walk stopped at the first step), the lift's call reading (candidates read without admission's resolution), UE-03 (admission no longer refuses an open outcome), the keyed tests (a stand-in compiler that exists nowhere, so an unexpected build cannot start).

Known and left open

  • The first export on the forge after this merge builds every root once. certified.yml takes the prior manifest from the newest artifact, which has main's shape (no edition row, main's tag), so nothing is carried until this tree's manifest is the artifact. The committed manifest already has the new shape.

  • certify plan counts 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 main too, 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 lift inner::run of the crate below as go of 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.

    pub mod a; pub mod b;            // each declares `pub fn go`
    pub fn go() -> u8 { 3 }
    pub mod inner {
        use crate::a::*;
        pub fn go() -> u8 { 4 }
        pub fn run() -> u8 { go() }
    }

🤖 Generated with Claude Code

https://claude.ai/code/session_013Asa3NRQ6yQRkAQhU1G3XJ

@afflom afflom self-assigned this Nov 16, 2026
…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
@afflom
afflom force-pushed the claude/project-thread-hboh76 branch from 4c22c9e to 617d85d Compare November 16, 2026 00:24

afflom commented Nov 16, 2026

Copy link
Copy Markdown
Owner Author

acceptance / ubuntu-24.04 fails on one test, self_model_sm_01 (crates/conformance/tests/self_model.rs:100: "the route table has 28 routes", left 29, right 28).

This is not from this pull request. The same assertion fails on the base: bootstrap run 43779526416 on main at 9d1f379 is red on both runners with the same message. model/routes.toml has 29 routes on main (the library route) and the test still expects 28; this branch changes neither file (git diff origin/main HEAD -- model/routes.toml crates/conformance/tests/self_model.rs is empty).

I will merge main into this branch once main carries the correction, and the check runs again then.


Generated by Claude Code

…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
@afflom afflom changed the title Write long literals as balanced halves, keep a guarded row's binders unshadowed, and pin the SDK that reads them Close six construct classes of the lift, write the register as the work queue, and pin the SDK that reads balanced lists Nov 16, 2026
…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

afflom commented Nov 16, 2026 •

Copy link
Copy Markdown
Owner Author

The gate on this branch now passes fmt-check, model, template-check, self-model-check and lint, and stops in test on the translator ratchet. That failure is this pull request's own, and it should not merge while it stands.

What fails. the_hand_written_translator_only_shrinks_ue_18, against main at 54d8a6a: 529 uncertified translator functions on this branch, 515 on main. The run names 20 functions of uorust::lift that are uncertified here and were not on main:

  • lifted by the self projection and not exported yet: Ty::render, Ty::tag, Types::declares, Types::resolve, Types::unnamed, barred, is_lifetime, name_taken, unread_shape, variant_field;
  • residue of the MIR path (a loop nested in a loop, closures, iterator adaptors, format!, split_once): Types::chains, Types::fields_read, Types::named, Types::variants_read, ctor, field_name, method_integer_checked, std_path, tuple_struct, tuple_struct_value.

What blocks the fix. The manifest is written only by the export (just certified), which certified.yml runs for main and lands on main; a branch cannot use it. So the ten lifted functions have to be exported from this branch's own self projection, and at least four of the ten residue functions rewritten in the fragment the MIR path lifts, before the count is at or below main's. That work is under way on this branch; the surface rules still to come are being held to the same ratchet before they are merged here.

Fixed in the same run. a_grown_translator_is_refused_ue_18 failed because the register now states its totals and Register::parse held them to the rows, so the planted register (the committed text plus one row) was refused as malformed before the ratchet saw it. 3154978 separates the two: parse reads rows, Register::read holds stated totals to them, and the conformance test passes unchanged. Earlier in this series: 5e4d9b9 (two lines the limits rule refused) and 9b548a6 (the self-model regenerated for moved source lines).

Update, 16 November 06:00 UTC, head cad281e. The gate now stops one part earlier, in self-model-check: app/src/Quality.lex.tex states the certified share the manifest gives, 151 on this branch (main's manifest as merged at 04dea80) and 150 on the merge with main's head c44107f, whose two later exports rewrote the manifest. That is the branch standing two of main's regenerations behind, not a change of this pull request. It is rewritten by just self-model-write when main is next merged here, and that merge waits for the ratchet work above, so that the branch is pushed once and not after each of main's regenerations.

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
…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
@afflom afflom changed the title Close six construct classes of the lift, write the register as the work queue, and pin the SDK that reads balanced lists Close six construct classes of the lift, carry certified roots under one key, and install the Prism factory Nov 16, 2026
@afflom
afflom merged commit 0ffd0aa into main Nov 16, 2026
4 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants