Re-cut the partial v2 std-ingestion frontier; propagate lowering refusals and wire DAG annotations

[gunbai-bot]

What this is (partial receipt — 10 of 15 measured)

Commit one of the re-cut v2 self-host frontier program: a partial exact-head re-observation (10 of 15 members) of the
std-ingestion frontier, plus the durable classification witness, plus the roadmap re-cut that
follows from it.

The measurement landed first, because the scheduling premise the repair was going to be built on
turned out to be stale. Two repairs then landed against the measured rows — both inside this lane's
file ownership, both green by execution — and the resolve-ready normalized-tree construction boundary deliberately did not.

Why the previous sequence was retired

The row scheduled five bounded normalize repairs, then three syntax gaps, from a receipt measured
on the stopped CI2-0 branch tree at e588031201. Re-executed at c03be069687, two premises fail:

• dag/std/algebra.dag is a LEX member, not a normalize contract violation. The retention
  population is 4, not 5.
• The entry module now rejects at PARSE, where the historical receipt had it accepting.

Neither half is a bounded repair

The normalize half is not a well_formed exemption. #6520 deliberately made body lowering
locally total while keeping recursive well_formed as the sole structural wall, so scoping that
wall around surface wrappers would reverse the safety decision rather than repair it. Verified on
current main, the real defect is that the "typed frontier" is only a diagnostic convention:

• body_lower_finish_for_normalize converts every Rejected into retention, discarding its
  diagnostics (Rejected { diagnostics: _ });
• BodyLoweringFrontierDisposition has no rejected arm, so a genuine rejection classifies as
  Lowered;
• retention is recognised from the diagnostic head, which rejected_with_pending systematically
  makes wrong;
• NormalizedTree is a bare = Node alias and resolve consumes it, so nothing structurally stops
  a retained mixed tree reaching resolve.

The syntax half is a missing capability. dag/std/algebra.dag's lex wall is the unwired §4c
annotation channel: dag_lex_rules() registers no AnnotationRule for //, so a comment
tokenises as two slash tokens plus whatever its payload happens to lex as, failing at the first
character with no semantic rule.

comment payload	lexes
// a b	accepted (/ / ident ident)
// a - b	accepted (- is a token)
// a — b	rejected
// a `s` b	rejected
// a @ b	rejected
em-dash inside a string literal	accepted

So ASCII comment specimens are false controls, and adding an em-dash case would entrench the
missing channel. Three inherited attributions are refuted by execution (each one construct in a minimal module,
with a control):

explanation	verdict
types.dag needs fixed-width \xNN escapes	REFUTED — the escape lexes; member still fails LEX after the annotation channel
node.dag needs qualified record construction	REFUTED — a.b.C { id: 1 } already parses and reaches ACCEPTED
content_hash needs the where-refinement form	CONFIRMED — PARSE refusal vs a passing plain-alias control

Two of the refuted ones had concrete repairs proposed against them; either would have been written,
passed its own tests, and left the member exactly as broken. types.dag and node.dag are now
unattributed and no repair may be scheduled for them from a description.

The witness asserts nothing that depends on the defects

A required witness whose success depends on the current defects persisting would go RED on the
repair and GREEN on a regression. So the durable assertions validate the stage classifier
and the containment-read discipline on synthetic specimens; the live per-member population is a
revision-scoped observation in the doc, reproducible from the m_* fns, which are deliberately not
test declarations.

New sequence

honest body-lowering frontier
  → resolve-ready normalized-tree construction boundary
  → current retained-body population reaches zero
  → frontend syntax population

The two repairs

Genuine body-lowering rejections now propagate. The fix is a deletion.
body_lower_production_emitted's final arm already produced retention explicitly for an emitted
identity with no registered producer — that IS the declared frontier, produced where
not-applicable is known. body_lower_finish_for_normalize additionally caught every Rejected
from the strategy functions and relabelled it as retention, discarding the diagnostics. Retention
therefore had two sources, one produced and one inferred from failure. The outer catch is gone;
retention has exactly one producer. well_formed is unchanged — #6520's structural wall stands.

Discriminating, not blanket: logic.dag moved NORM_RETAINED → NORM_OTHER (its real refusal now
surfaces as itself); optional.dag and diagnostic.dag stayed NORM_RETAINED, their retention
being genuine.

The // annotation channel is wired, over the generic lexer's existing LineCommentTextChar
machinery, placed after the string-literal rule so string content keeps winning. Controls execute at
LexArtifact grain, never on Accepted, because an Accepted-only control cannot tell a
recognised comment from an accidentally-lexable one:

• plain, em-dash, and backtick+@ payloads each capture exactly one annotation
• no dag_token_slash reaches the semantic stream (plain and em-dash cases)
• a URL inside a string literal captures zero annotations

A latent Class B dependency this diff exposes

Three test files construct std.cache_interface's ArtifactIdentity<T> with no import,
resolving it only by pool-membership coincidence — DESIGN's documented Class B hazard. They compile
on main because its compile-clean scope happens to supply the module. This diff touches the DAG
lexer, so its affected-set closure is much wider and does not, and they fail unresolved type 'ArtifactIdentity'. The defect is pre-existing; the widened closure is what exposes it, and this PR
cannot establish a compile-clean result without repairing it.

The three files are hermetic_fixture_realization_test, realize_kernel_test, and
reconcile_in_process_cache_test; each gets the one load-bearing import. It is not redundant —
its absence is the compile failure — so it works with the import-deletion lane rather than
against it.

A first attempt at this census was wrong and is worth recording. A grep for ArtifactIdentity
returned six files, and all six were "fixed". Three of those were false: two self-host witnesses use
a different declaration with the same short name (v2.compiler.self_host.generation, a coproduct)
which they already import, so the added import created two authorities for one name; and one Spark
witness matched only on the suffixes RuntimeArtifactIdentity / ModelArtifactIdentity. Those three
imports are removed.

That error is the same failure class as the defect it was chasing: a name-level observation
standing where bound declaration identity is required. The permanent census owed to the
import-deletion lane must therefore operate on provider file and bound declaration, never on a
grep roster, with the structural condition: every accepted cross-file reference binding projects
its provider file into the compilation dependency closure, independently of unrelated pool
membership.

Not claimed

• No well_formed change and no resolve-ready construction boundary. NormalizedTree is still = Node and
  resolve still consumes that alias, so retained cannot reach resolve holds only by propagation,
  not by construction. That is the next increment and it is not in this PR.
• dag/std/algebra.dag is not re-confirmed after the lexer repair — the probe again exceeded
  its budget, now doing strictly more work because it no longer stops at lex. The lex wall is
  claimed closed on the minimal pairs, not on that member.
• src/v2/std/node.dag is NOT RE-OBSERVED — the interpreted probe exceeded its 900s budget. A
  budget interruption is not a verdict, and it is not discharged by copying the historical value.
• src/v2/std/algebra.dag remains uncaptured and stays visibly on the board.
• The historical receipt's measurement body is unchanged; this PR does edit that file, to add a
  supersession pointer to the new one.
• A construct-level minimal pair refutes an explanation; it is not a re-observation of the member.
  types.dag remains at LEX with its cause unattributed, and node.dag's member stage is
  unmeasured — neither may carry a scheduled repair.

[gunbai-bot]

Real-closure downstream confirmation of the annotation channel (SH-D)

Independent A/B on a real compiler import closure, offered because this PR's description notes its direct dag/std/algebra.dag confirmation did not finish. This is a different subject from a direct member probe — a 15-file import closure driven through the v2 direct Rust door and the frontier probe — so it corroborates rather than substitutes.

Subject A — current main, unmodified.
Subject B — same tree plus only the src/v2/extdeps/languages/dag.dag production hunk from fa2576a9 (the dag_line_comment_annotation_rule() registration). Nothing else applied. Tree hash verified identical before and after each run.

Module: src/v2/compiler/use_site_verdict.dag, closure 15 reads, content_hash=fnv1a64:11b29cac94c4acdb.

	A	B
door observation	AssemblyRejected	AssemblyRejected
located_reason	tokenize_lex_e1_unrecognized_char	parse_grammar_choice_overlap_residue
assemble cause	OtherAssembleRefusal (catch-all, no clusterable evidence)	MaskedAssembleRefusal (overlap rows + remaining chain)
refusing file at A	dag/std/algebra.dag	—

What this establishes

The repair works. At A the closure refuses at lexing; at B that refusal is gone. At fixture grain the minimal REDs agree: a backtick or an em-dash inside a // payload rejects with tokenize_lex_e1_unrecognized_char before the hunk and stops rejecting after it, with an ASCII-payload control accepting throughout.

The wall it removes was masking an older one. B's reason is exactly what this module's frontier.dag row already records. So the comment-payload wall sat in front of a previously-recorded grammar-overlap residue. Anything measured on current main reports the mask, not the recorded blocker.

Consequence for roster work, not for this PR: a cause-separation sweep run before this lands would mis-cluster every module whose real blocker sits behind the comment wall. I have not edited frontier.dag and am not proposing a row change from a pre-repair measurement — it would replace a correct reason with a transient one.

Two notes that may save you time

No rebuild is needed to test this hunk. The v2 lexer is interpreted .dag — dag_lex_rules() is read at runtime — so applying the hunk changes behavior with an unchanged claim_batch/gunbc binary.

Cost rises sharply once the channel is wired. The same probe arm goes from ~70s to ~1,173,508ms (~15x), consistent with the pipeline doing much more work before refusing. Budget accordingly if you plan closure-grain confirmations.

Not claimed

C (this PR's exact head, including the separate body-lowering repair) has not been run, so nothing here speaks to that half or to whether it changes these closures. materialization_carriers (48-read closure) is queued. Three of my five rows — 03_resolve 71, 04_infer 75, 03_name_resolve 143 — exceed the 64-row inline manifest cap and are held at a typed coverage refusal rather than measured through an elided subject.

[gunbai-bot]

Closing as subsumed rather than resolving the conflict, because there is nothing left to merge.

#8179 was stacked on this branch, so merging it carried these commits into main. Verified file by file: all thirteen paths this PR touches are now byte-identical to main, including both production changes — src/v2/compiler/body_lowering_fold.dag (the deleted rejection catch; body_lower_finish_wrapper_retained is gone from main) and src/v2/extdeps/languages/dag.dag (the // AnnotationRule, present in main).

The three files GitHub reports as conflicting are normalize_retention_contract_probe_test.dag, frontier_ingestion_probe.dag and the exact-head receipt. They conflict because main holds the NEWER census versions from #8179 while this branch still holds the pre-census ones — 15 hand-written m_* fns, no reconcile_census, no FrontierRosterVerdict. Resolving would mean taking main's side on all three, leaving an empty diff.

The squash-merge is why the commits are not ancestors of main despite the content being there; git merge-base --is-ancestor says no while every file compares equal.

Both increments are on main. Nothing from this PR is lost by closing it.

— sent from crisp-lynx-832