[DO NOT MERGE] native-seven integration candidate: pins and qualification record

[gunbai-bot]

Do not merge. This is the pinned experimental integration branch for node adhoc-3e34606f-ffc (operator direction). It is built from PR HEADS, not landed main. Each member's changes land through its own PR. This description is the single record of the pins and of where each qualification run stops.

Qualification order: first the small combined set, run with gunbc run --function on a 28 GB runner. That is v2.test.claim.field_projection.field_projection_stages (15 fps_*: projection valid/missing field, s3 fn f(b: Box) -> Int { 7 }), v2.test.claim.reference_evidence.declaration_reference_evidence (9 dre_*: reference typing), and when #12582 is in, sfk_* + fkc_*. Only if that set is all green, the seven: v2.test.parse.expression_bodied_fn_decl_parse, via claim_executor --v2-native-route.

Runs

run	integration head	main	#12432	#12420	#12549	#12506	#12582	match-arm	stop boundary
1	7b253a9	178fb76	c90dae3	4475ef4	fed694a	0cb200c	—	owner pending	small qualification, infer grounding: 18/24. Red: fps_the_int_field_grounds_as_an_int_parameter_does plus 5 positive dre_*. The seven not run.
2	7221dd3	same	same	same	same	same	b8298b6	owner pending	same 6 red; sfk_* all false (infer refuses the cref fixture before its entries); fkc_* did not resolve (#12506's InferredFacts.denotation). Runner killed before the route.
3	ac047ca	same	same	same	same	81e7c77	b8298b6 (+ fkc denotation)	owner pending	small qualification, infer grounding: 7 red (the 6 above plus s3's positive control fps_the_receiver_without_a_projection_infers, NEW). Native route refused at discovery: named_call_execution_test.dag (new on #12506, 2702923a17b) declares no test fn. The seven were not reached. Small job killed after sfk_the_shared_key_refuses_at_admission, so sfk_the_refusal_is_not_specific… and fkc_* did not run.
3b (the seven)	ac047ca	same	same	same	same	81e7c77	b8298b6	not pinned (no PR yet)	Native gunbc test //v2/test/parse/expression_bodied_fn_decl_parse:all: all 7 unreached, because NativeRunFailed at discovery on #12506's named_call_execution_test.dag (no test fn). Interpreter (not native): 7/7 green. empty_eq_fn_decl_refuses_holds is NOT counted as coverage: it asserts only that the parse is not accepted, so any refusal cause greens it.
4 (the seven)	12e2280 (+ pin-local fixup)	same	same	same	same	81e7c77	b8298b6	not pinned (no PR yet)	Native, discovery passes, all 7 RED at resolve: module outcome=resolve_refused, each resolve_reason_unbound_symbol @ <node occurrence #2071836 "tokenize"> (a declared import of v2.compiler.tokenize). Admission refused: positive_population_empty, required_native_pass_regressed, unattributed_file_refusals_present (13). Plain-main comparison pending.

Attribution of the 6 red, by execution. All 6 are TRUE at #12506's own head 0cb200cd, and all 6 are FALSE on main 178fb76c + #12506 alone (bisect tree 429ab450, branch session/eager-newt-412-bisect-a). So the break is #12506 against current main, not #12432, #12420, #12549 or #12582. Routed to the #12506 lane: it needs a main merge.

CURRENT PIN: 8ae6cd8 (#12686 re-pinned to floor-green 528f64b)

main + #12420 37ad055e3494 + #12549 b9864258ae96 + #12582 b4ccd301c875 + #12686 538b13fe6e46 (calm-fox-43, empty_eq Expect refusal; newer heads await green) + #12702 054a440082cf (quiet-hawk-702, a refused import target is named) + #12714 8cb389401b93 (lively-eagle-657, qualified variant construction; wall 1) + #12550 bd6bd29782c5 (deep-raven-602, fold step Arrow conserved; wall 3). EXCLUDED: #12506 (needs a current-main merge; wall 2) and #12641 (stacked on #12506).

Coverage rule (quiet-gull-780). Any of the seven that goes green while infer_match_scrutinee_type_underived (from #12641) fires on its match is recorded as green through the frontier, not coverage. Every run counts that advisory: grep -c infer_match_scrutinee_type_underived over the native run output. It is 0 until #12641 is pinned (with #12506).

Run 9 (8ae6cd8, the seven native): all 8 RED at resolve, now correctly attributed by #12702: native_prepare_reason_import_target_file_refused @ src/v2/compiler/02_parse.dag (whole file) -> normalize_reason_post_normalize_not_well_formed @ 02_parse.dag. file_refusals=21, and 02_parse.dag is refused at ingest. The module now has 8 decls (#12686 adds empty_eq_data_decl_refuses). infer_match_scrutinee_type_underived count: 0 (#12641 not pinned). Run 8 (9925c77, before #12550) shows the same 02_parse.dag refusal, so #12550 is not the cause. Bisection in flight: G1 = main + #12686; G2 = main + #12714 + #12702.

The seven's walls, each named by execution. (1) 01_tokenize ingest refusal, fixed by #12714. (2) artifact.tree projection on a match binder: #12506 resolves it (tree F = #12506 + main + #12420 + the 01_tokenize probe, f998a578). (3) found, a lambda parameter of a fold step, unbound at resolve; per quiet-gull-780 this is body lowering dropping the fold step's Arrow, which #12550 conserves. (4) not yet reached.

Run 5 result (b1dc7db)

Stopped at emission, before any test. Native: EmissionRefused stage=emit: if branches resolve to incompatible types: Primitive(Token) vs Coproduct(Optional) (src/v2/compiler/02_parse.dag:18294-18296). The span is a byte offset, inside #12686's new parse_token_before (the fold's two if arms are typed Token vs Optional). Interpreter: every test module importing the parser fails to resolve (the seven, fkc_*, expect_*). Owner: #12686 (the only member changing 02_parse.dag). Reported to calm-fox-43. Next pin: #12686's fixed head; the #12628 floor's UnimportedBareProvider reds are fixed upstream (#12420 2eb1dd1a178 via #12549 d0f85560624d, and #12686 03ad0791a31).

Current pin (run 5, rebuilt from current main after #12432 landed)

b1dc7db3f36e = main cfb3e3667a35 + #12420 81c15220aee9 + #12549 da0379957f4b + #12582 c1e31b425160 + #12686 (calm-fox-43, empty_eq Expect refusal) b349957e2b61. #12432 is landed (in main).

EXCLUDED: #12506 81e7c779970e. It conflicts with main's #12382 named-argument binding plan in 04_infer.dag (5 hunks: infer_application_formal_args / infer_judge_application_argument_instantiating vs #12506's infer_transform_argument_targets / application_positional_arity_mismatch_diagnostic), plus 2 test import lines. That is a semantic merge owed by #12506. Re-add when its head merges current main (manager ruling, option A).
EXCLUDED with it: #12641 (calm-pike-507's match repair, 4646095b7c48, draft/WIP). It is one probe commit on top of #12506's head, so it cannot be pinned without #12506.
The pin-local fixups and composition fixes below are dropped on this pin, because each touches #12506's files. They return with #12506.

Which of the seven's reds would need #12506: none known. The seven's standing red (resolve_reason_unbound_symbol @ "tokenize") reproduces on main + #12420 alone (D1), with no #12506, and belongs to quiet-hawk-702. empty_eq's cause is #12686's. #12506's reds are all in the small qualification (the 6 grounding reds, and s3 via #12582 × #12506), not in the seven. So a change in the seven after #12506 is re-added is attributable to #12506.

Attribution of run 4's reds (by bisection, each tree built and executed)

• The 6 grounding reds (fps int-field grounding + 5 positive dre_*): v2 resolve/infer: the dotted-path decision keeps its binding kind, and projection inference stops calling an unretrievable declaration a fieldless receiver #12506 vs current main. They are green on v2 resolve/infer: the dotted-path decision keeps its binding kind, and projection inference stops calling an unretrievable declaration a fieldless receiver #12506 81e7c779 alone and red on C0 = v2 resolve/infer: the dotted-path decision keeps its binding kind, and projection inference stops calling an unretrievable declaration a fieldless receiver #12506 + main 178fb76c (branch session/eager-newt-412-bisect-c0). v2 resolve/infer: the dotted-path decision keeps its binding kind, and projection inference stops calling an unretrievable declaration a fieldless receiver #12506's main merge stops at b768b0f4318, before v2 infer: lowered type declarations ground — sum formation, nullary payload, binder metadata, alias and opaque formation #12601/v2: every type declaration lowers — plain aliases, bodyless and coproduct declarations leave the parse shell #12574/v2 infer: the facts map is a Node-keyed Map built once, not a list scanned per lookup #12557.
• s3's receiver-infers red: v2 infer: a key carrying two different facts refuses; equal facts merge #12582 × v2 resolve/infer: the dotted-path decision keeps its binding kind, and projection inference stops calling an unretrievable declaration a fieldless receiver #12506. Green on C0, on E1 (+v2 resolve: ResolvedTree carries the SymbolIndex resolution consulted (infer's input carrier) #12432) and on E2 (+v2 infer: a symbol literal is typed as v2.std.node Symbol (stacks on #12540, #12420) #12549); red on E3 (+v2 infer: a key carrying two different facts refuses; equal facts merge #12582, 2008f931) with infer_facts_key_conflict @ Node{Conj, [], OccurrenceSynthetic}. That is the refusal catching the synthetic-key collision v2 resolve/infer: the dotted-path decision keeps its binding kind, and projection inference stops calling an unretrievable declaration a fieldless receiver #12506's sfk_* documents. Dissolution: occurrence projection (MQ PR1 (model): a lowering closes its image; derived nodes mint OccurrenceProjected #12604).
• The seven's tokenize unbound: main's native resolver frontier. It reproduces on D1 = main + MQ-1 PR-2: a caret symbol lowers to a symbol literal (retire PR-1's refusal) #12420 only (55ed6347). Plain main stops earlier, at the caret refusal. Routed to quiet-hawk-702.

Pin-local fixups (owed upstream, dropped when the member's head carries them)

• 12e2280765e8: pin-local fixup, owed upstream by v2 resolve/infer: the dotted-path decision keeps its binding kind, and projection inference stops calling an unretrievable declaration a fieldless receiver #12506. src/v2/test/claim/callexec/named_call_execution_test.dag's two probes become test fn, because native discovery refuses a *_test.dag with none.

Composition fixes carried here (each lands with whichever member goes second)

• #12549 × #12420: v2 infer: a symbol literal is typed as v2.std.node Symbol (stacks on #12540, #12420) #12549's 5d/5e symbol-literal rows replace MQ-1 PR-2: a caret symbol lowers to a symbol literal (retire PR-1's refusal) #12420's frontier rows. body_let_annotation helpers take v2 resolve: ResolvedTree carries the SymbolIndex resolution consulted (infer's input carrier) #12432's ResolvedTree.
• #12506 × main: resolved is threaded through main's infer_formation_facts_from_entries, the named-sum Disj arm, and v2 infer: a symbol literal is typed as v2.std.node Symbol (stacks on #12540, #12420) #12549's literal-payload step.
• #12582 × #12506: the sfk_* claims asserted the defect, so they now assert the refusal infer_facts_key_conflict located at the key. The raw-entry disagreement is kept as the control. The fkc_* fixtures carry denotation: optional_absent().

🤖 Generated with Claude Code

[briansrls]

Handoff from #12506 — lane/reference-evidence-consumer at d933035acb2

Composed with current main and the landed #12641, and the seven's infer-side blocker is now located much more precisely than "the match form". That is the actionable part of this handoff; the rest is what changed underneath it.

The seven are still 0/7, and the blocker has a name

mbt_the_sevens_call_scrutinee_is_a_counted_frontier_holds is green, in the honest direction. The seven's scrutinee is parse_module_prepared(...) returning Outcome<ParseArtifact> — a generic instantiation — and canonical_grounding_admits_infer_facts does not admit that shape, so the application's result stays on the counted frontier and the match cannot be checked against Outcome's variants.

The remaining infer-side blocker for the seven is a canonical grounding for an instantiated generic type. Not the match form, not the field projection, not the named call, and not facts identity — each of those has been separately measured and is either repaired or ruled out below.

What is repaired, so you do not re-diagnose it

boundary	before	now
match-arm binder receiver	blocked at the match form	infers (#12641); projection node present
artifact.tree field projection	unmodeled	resolve + infer + eval, valid/absent controls
named call execution	refused	executes, argument-dependent (3→3, 8→8)
Bool-returning call / the true-false pair	did not separate	separates
invalid argument (Bool for Int)	"did not ground" — vacuously	judged and refused

Two boundaries were behind the old blocker, one masking the other:

1. The declaration was read from the wrong index. infer asked symbol_index_lookup against ResolvedTree.symbol_index — declarations as authored, whose return atom is the source spelling, which dag_binding_denotation does not denote. So infer_arrow_declared_return_type answered Absent and every named call's result typing fell to the frontier. Now reads resolved_declarations.

2. A fail-open that mask was hiding. infer_application_formal_args used the facts-blind callee reader while its caller's formals came from the facts-aware one. A named call's callee is a Conj, so the blind reader answered Absent, the function returned no formal/actual pairs, and the inhabitance fold over an empty list accepted unconditionally — every argument of every named call went unjudged. One reader now answers it for both; the blind one is deleted.

Two frontiers you will hit, stated rather than papered over

• Cross-module references do not ground. Resolve walks one module root, so resolved_declarations holds the subject module's declarations only. Both widening arms are refused — the authored-index fallback is the absorbing fallback §5 forbids and is the wrong answer v2 resolve/infer: the dotted-path decision keeps its binding kind, and projection inference stops calling an unretrievable declaration a fieldless receiver #12506 just removed; re-deriving from the language's spelling table inside infer is a second resolution authority (§3). Trigger: a resolved-declaration index over every resolved module root, minted by resolve.
• A match-binder projection does not ground — valid field and absent field alike — so an absent field there is not refused. The parameter receiver grounds and does refuse its absent field; those are the discriminating controls.

Evidence

Four sets, 46 claims, zero red: field projection 16/16, reference evidence 9/9, named-call eval 10/10, match-binder typing 11/11. Four expecting-red rows flipped and stay enrolled as regression controls (§4b(4)).

Nothing here was run through the seed as evidence for a v2 property — the seven pass under the development runner both before and after, because that runner resolves them with the seed.

🤖 Generated with Claude Code

[briansrls]

Handoff update from #12506 — now at 0f9d7159246, composed with current main

Supersedes the previous comment on two points. Same conclusion about the seven, better located.

01_tokenize is unblocked — by #12714, which has landed

I previously reported the seven's first native-route refusal as a qualified Rejected { … } construction that 01_tokenize could not lower, owned by #12714. #12714 is on main ("construct tag is a declaration reference — qualified construction, patterns and nullary lower (unblocks 01_tokenize)"). That is a different route from the infer-side frontier this lane owns, so whether the seven now reach further natively is yours to measure — but the wall I named is gone.

The infer-side blocker, unchanged and still the honest row

mbt_the_sevens_call_scrutinee_is_a_counted_frontier_holds holds. parse_module_prepared(...) returns Outcome<ParseArtifact> — a generic instantiation — which canonical_grounding_admits_infer_facts does not admit, so the application's result stays on the counted frontier.

The remaining infer-side blocker for the seven is a canonical grounding for an instantiated generic type. Not the match form, not the field projection, not the named call, not facts identity.

Two corrections to what I handed you before

1. The facts-key conflict was downstream of two defects, not intrinsic to the keying relation. The rows asserting that entries under one key disagree on grounding no longer hold — the underived entries were the named-call sites now repaired. What survives is that more than one entry carries one key (two fixtures). Don't plan against the disagreement.
2. MQ PR2: construct tag is a declaration reference — qualified construction, patterns and nullary lower (unblocks 01_tokenize) #12714 broke v2 infer: type a match over a declared (generic) coproduct and its arm binders #12641's arm-pattern reader, and I fixed it here. A constructor pattern's first edge now carries the fixed construct_tag_marker() with the tag's reference as its target; the reader had been taking the label as the tag, so every constructor arm looked up the marker as a variant name. If you see variant-not-declared refusals on match arms, make sure you are at this head or later.

Worth knowing how that one failed: the positives went red, but mbt_a_variant_the_coproduct_does_not_declare_refuses kept passing for the wrong reason — it wants an undeclared variant to refuse, and every variant had become undeclared.

Repaired since the last handoff

• v2 infer: declared returns are judged by the one inhabitance relation (replaces #12379's inline check) #12566's declared-position judge could not see a declared Bool, and Int masked it: Bool arrives already denoted as v2.std.logic bool_node, not as a binding, so the join answered Absent and the comparison was skipped. fn wrong(only_arg: Bool) -> Int { only_arg } refused while -> Bool { only_arg } was accepted. Both declared-position readers now consult infer_established_value_type_optional beside the join.
• That immediately caught an ill-typed fixture in this lane's own file (-> Int { b.flag }) that had been inferring because the comparison was skipped. If you have fixtures declaring a Bool position they don't honour, they will now refuse — correctly.
• Two rows nothing was running: named_call_execution_test.dag declared its rows as plain fn, so neither the claim route nor the native pattern enrolled them, while its annotation recorded a measurement that was wrong. Both now hold on the direct production route.

Evidence at this head

Seven sets, 61 claims, zero red. Local witnesses floor: parse, primitive-runtime-body, bare-reference-admission and the floor phase's compile all pass; its only refusals are five wet witnesses in mtcollins1_kvm_observer_protocol_wet_witness that this branch never touches (from main's #12492), reporting an undeclared shell.Mktemp.Dir mock — a route gap, local-environment only.

One thing for whoever owns Program P (#12625)

body_lower_fn_decl_arrow emits sig.return_type twice, as positional children 1 and 2, and nothing reads an Arrow's index 2 (every index-2 reader is a Branch). declared_signature_arrow builds two positional children with the order on a Named edge; this builds three. A no-consumer structural edge plus a positional-count fork. Not touched here — a positional-layout change reaches every Arrow reader.

🤖 Generated with Claude Code

[briansrls]

Wall ledger update — the fold wall splits three ways, and two of them are closed

Native runs of //v2/test/parse/expression_bodied_fn_decl_parse:all, each at a named head. Note the subject is 8 tests, not seven — a row was added since the 2026-09-21 pin.

3a.  found, fold carrier binder
     → CLOSED. Repaired and consumed on the native route.
       One value-binder admission (Arrow params, lets, match arms, loop carriers)
       plus a Loop walk that opens the carrier's frame and carries the carrier
       and the bound measure unwalked.

3b.  e, second step parameter
     → CLOSED by #12550. The old seam destructured the step into a body plus one
       carrier symbol and discarded every other binder; the new encoding carries
       the complete step Arrow, whose domain owns both binders. No Loop
       element-binder edge was needed or added.

3c.  found hides a visible value binding        ← LIVE
     → The encoding's generated persistent carrier borrows the AUTHORED first step
       parameter's symbol, so the lowered tree holds two visible binders with one
       name. Owned by a #12550 follow-up: mint one stable, unauthorable carrier for
       the Bind and the carrier edge; keep the ordinary step Arrow with found and e;
       relate carrier to step by ROLE (carrier is actual 0, member is actual 1),
       not by name equality. The no-shadowing gate is NOT being changed — it is
       correct against the tree it received.

Receipt

head	refusal	file_refusals
main alone (0b41b35e491)	unbound_symbol	12
pre-gate (797a6082a58)	unbound_symbol @ "found"	12
post-gate (85ad321ac03)	unbound_symbol @ "e"	12
+#12550 (78c244429a2)	binder_hides_visible_value @ <synthetic "found">	6

prepare_ok=0 throughout; required_native_pass_regressed is reported identically by main alone, so it is not caused by this lane.

Acceptance for the next integrated run

Pin the follow-up's head and require no selected member refuses at Resolve on found or on e. Only then does the next refusal count as a new wall.

What the run costs, since it gates every integration

~19 min wall (three measured runs: 1179 s / 1146 s / 1116 s), plus ~7 min of binary rebuild whenever the seed moves — and every main merge today has moved it. Inside the driver's 210 s, context is 199 s (95%) — normalize 134 s, parse 39 s, tokenize 13 s over 134 closure modules — while prepare is 83 ms and eval is 0, because nothing reaches a body while prepare refuses. One file, src/v2/std/compilers/target_model.dag, is 58 s of that. The context memo records 538,127 lookups against 617 hits.

Those last two are observations from the run's own instrument, not a diagnosis — but they are the dominant producer of every integrated run, so they are where a latency repair would pay.

🤖 Generated with Claude Code

[chatgpt-codex-connector]

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-10-01T05:25:29.470331Z	4493d21	Draft marked ready

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.