NS-N prerequisite 1: the typed source-rewrite op and the owned Step-0 producer

[gunbai-bot]

SCORING: THIS IS CAPABILITY WORK WITH ZERO PREREQUISITE CREDIT. THE CANARY DOES NOT MOVE.

Stated at the top so nobody later cites this PR as Step 0 movement. Scored by the lane manager
(wise-badger-902) on exactly that basis: a PR that moves nothing may not DELAY Step 0, and the
stop rule does not say such a PR may not land. It lands as the two capabilities, not as an advance.

The frozen command was run on this branch and the receipt is byte-for-byte the ZERO, not the
successor:

prefix=[CanaryContractFrozen,SourceTreePinned,CompilerExecutablePinned,InputSubjectManifestPinned]
blocker=ApplyTypedImportStrip
entry=Step0SubjectNotEntered
observation=NoStep0Observation

PASS current_main_step0_canary_receipt_is_admitted here means the zero still holds. Receipt zero
is untouched: the three literals in test.claim.namespace_step0_canary_witness are unchanged from
#10117 (commit 20caf4e, tree a6a6e0a531, digest a89dfc88a9), and the contract, the classifier
and the subject-entry rule are unedited. Run locally on aarch64; BuildBuddy cannot execute the
canary (HostBudgetUnreadable), and nothing here reads a remote result as a canary result.

WHY IT CANNOT MOVE YET, WHICH IS PREREQUISITE 2

The producer observes the (path, content) vector it is HANDED, and nothing collects that vector
from the pinned tree: there is no directory walk, glob or corpus enumeration anywhere in the
builtin registry, filesystem_read takes one named path, and tools.multi_module_compile_fixture
is in-memory only. So the manifest subject -- every parsed import statement in dag, src/v2 and
src/v1 at tree a6a6e0a531 -- has no producer.

A receipt naming that manifest over a hand-supplied two-file vector would be a lie the classifier
could not catch: admit_namespace_step0_canary_receipt checks the tree PIN, not that the vector
IS the tree. That receipt is writable today and would have scored. It is not written here.

THE MEASURED FINDING THAT CHANGES WHAT STEP 0 IS

With every import removed, a kernel-typed two-module subject STILL COMPILES -- Bool needs no
import and the cross-module callee is recovered by bare-name resolution across the supplied pool.
This is reproduced under an ISOLATED fixture with no corpus pool, which is stronger than the
v2.lens.module_graph observation from #7908 because it removes the ambient-pool explanation.

"Strip the imports and see whether the compile exits 0" is the canonical shape named in
gunbc.recurring_failure_mode proxy_observation_mistaken_for_action_semantics (landed at
5e9f65a). This fixture is that class's discriminating instance, produced independently.
So the honest expectation for corpus-scale Step 0 is not a containment-compile refusal at all,
and the census the lane has been treating as the subject may be measuring the checker's absorbing
arm. That row's evidence list is still empty; this fixture is available to it if the lane wants
the receipt attached, which is a separate change to a ledger this PR does not touch.

---

gunbc.namespace_step0_canary reports the Step 0 strip-entry canary blocked at
ApplyTypedImportStrip for two named missing capabilities: "a typed parse-level source
rewrite that removes one complete import statement" and "an owned Step-0 producer that
applies the rewrite and folds the resulting compile observation". This lands both, green
by execution.

THE REWRITE (std.import). One authority: a fold that consumes an ascending set of
parser-delimited spans once and rebuilds the source from the gaps between them, because
removing several statements is not removing one several times -- every removal shifts the
offsets of the ones after it. The singular case is that fold on a one-element list, not a
second implementation. It accepts only spans a parse produced and refuses, typed and
located, when the source at a span is not an import statement of the module the parse
named, when a span belongs to another file, when spans descend, and when a span leaves the
source. The parse observation deliberately does NOT carry the statement text: if the span
and the text were slices of one another, agreeing would be a tautology.

THE EXTENTS (v1.compiler.parse). An import node's span is the import keyword and its
ident_span is the module path, so where a statement STOPS is known only while its tokens
are being consumed. parse_import_statement_extents reuses the seed's own parse_import and
decides only where that production started and stopped, from the token stream's own
position before and after it -- there is no second grammar, and a rule corrected in
parse_import is reflected with no edit here. The trailing newlines parse_import consumes
are excluded: removing a statement must not also remove the blank line after it. The
opening ParseContext is now built by one extracted parse_context_for_tokens so this reading
enters the grammar under the same context the full reading does.

THE PRODUCER (gunbc.namespace_step0_strip_producer). It strips a supplied subject, compiles
the rewritten sources through tools.multi_module_compile_fixture, and folds what came back.
Every stage refuses rather than widens, and the arm that matters most is the one that looks
like success: a stripped subject that COMPILES has no blocking transition, and the canary's
receipt has no spelling for one, so the producer reports Step0ContainmentCompileCompleted
instead of fabricating a blocker. That arm is not hypothetical -- the witness measures it on
a kernel-typed pair whose imports bare-name resolution recovers anyway.

The receipt constructor is sealed to this producer's fold and takes the executed rewrite and
the compile's own cause as arguments; it is declared in the canary module because the
receipt is sole_constructor, and ownership is expressed by the caller seal. The fixture
constructors and this one are reachable from disjoint doors.

WHAT THIS DOES NOT CLAIM. Step 0 has not moved. The frozen contract, the classifier, the
subject-entry rule and the controls in test.claim.namespace_step0_canary_witness are
untouched, and no receipt is minted over the repository tree. The producer observes the
sources it is HANDED; that the handed vector is the whole of the tree the receipt names is
the caller's obligation, bound only by the canary's commit and tree pins. The next-rung
trigger is a capability that COLLECTS the subject from the pinned tree, so the vector and
the tree have one producer instead of two. Rebinding the baseline to a corpus-scale run
lands separately, as the freeze note requires.

The dag-to-v1 crossing is declared seed growth (+1 hand item, the interpreter encoder) at
gunbc.parsed_import_statement_bridge_seed_growth, with the same reachability reason and
dissolution trigger shape as the structural-observation bridge beside it.

---

🤖 Generated with Claude Code