§13 alias APPLY: .dag workflow (Rust apply retired; Phase 7 equivalence PLACEHOLDER, not a dual-run gate)

[gunbai-bot]

Summary

§13 walk-target alias APPLY as a .dag workflow — now assembled end-to-end with a live consumer (operator direction: finish the branch, merge nothing unconsumed).

• dag/tools/walk_target_alias_apply.dag — walk_target_alias_apply_module_fold: per-module inputs (declaring module, storage rel path, source text, plan rows) → corpus write gate → static binding-identity oracle → v2 parse (span index kept) → row-conflict check → existing-alias skip → splice offset → grammar-spelled alias lines → typed splice-edit report. Per-module refusals are typed and counted; siblings continue.
  • Splice offset = max span-extent end over module_header/import_decl nodes anywhere in the parse tree (the earlier flat-children anchor scan mis-anchored on the real nested sequence spine and placed no-import modules before the header — deleted, with the probed topology receipt in the commit).
  • Alias surface text is grammar-owned: ConcreteSyntaxToken list spelled via serialize_concrete_syntax_tokens_to_source, with the DeclaredNormalized whitespace rendering scoped to the alias token classes. Renders exactly alias X = a.b.c.
  • Existing-alias detection: DFS atom scan (the binding ident is the atom immediately after each dag_token_kw_alias — probed by execution).
• walk_target_alias_apply bin — thin transport (precedent: gunbc converge): seed-retained Walk-target-sourced alias codemod #6984 planner → host-boundary module→path→text projection → in-process interpreter call → typed report decode (both list carriers) → TSV rows; char-safe splice realization (unit-tested) is reachable only when the write gate lifts. --marshal-probe self-tests the whole transport path without the planner.
• Corpus --write refuses (typed, with dissolve trigger): the v1 seed parser has no alias-decl arm — proven by compile probe (expected item declaration…). The v2 arm + symbol-index rows landed in Phase 1: alias binding rows in symbol_index_fill (§13 containment-walk binding) #6979; the v1 arm is dispatched as work item adhoc-4039c48d-208 and its landing dissolves the gate. Dry-run is the live path today.
• Retained honest scaffolds: executed binding-identity oracle refusal (whole-tree resolve replay not .dag-callable yet), Phase 7 equivalence placeholder (unchanged; NOT a dual-run gate), Walk-target-sourced alias codemod #6984 Rust plan side (its retirement stays gated on a real equivalence receipt).

Test plan

• fast witnesses 10/10 (oracle reds, write-gate red, conflict red/green, fold-level oracle gate, dry-run receipt)
• long-lane witnesses 6/6 (parse, tree fact, splice offsets 82/48 incl. no-import fixture, end-to-end fold edit, skip-existing)
• driver unit tests 4/4 (char-offset splice incl. out-of-range refusal)
• --marshal-probe green: alias_line=alias ProbeAlias = test.aliasplan.near.AmbigType splice_offset=82
• whole-corpus dry-run receipt (running; will be posted as a comment)
• corpus --write — refused until the v1 alias parse arm (work item adhoc-4039c48d-208); the codemod diff lands as its own PR after

🤖 Generated with Claude Code

[gunbai-bot]

On review 41498 (insert-anchor witness): the finding is valid — the enrolled witness was non-discriminating — but making it discriminating surfaced something bigger, so I'm flagging rather than papering it.

I probed the actual behavior by execution. For the one-header + one-import fixture, alias_apply_insert_anchor_after_import_block returns child_index = 0, not 1. Root cause: alias_apply_find_module_root resolves to a node whose direct children classify as [OTH, HDR] (first child other, second the module header) — the import decl is nested deeper and is NOT a direct child of that node. So alias_apply_insert_scan_root stops at the first (OTH) child with anchor 0 and never advances past an import. The scan is effectively operating at the wrong tree level; there is no simple child_index at this node that means 'after the import block', so the review's assumed value of 1 isn't confirmable either — asserting ==1 reds for the wrong reason.

I therefore reverted the speculative ==1 assertion (kept the witness at its prior form) rather than enshrine an unconfirmed value or greenwash the current output with ==0. The real fix is in the insert-anchor navigation (alias_apply_find_module_root / the scan's assumption of a flat [header, imports, decls] child list), which is a behavioral change on this lane, not a witness tweak.

Severity: the live apply path is fail-closed here — corpus --write refuses on #6979 and the executed oracle is seed-gapped — so the insert-anchor is latent prep-code, not a live regression. It should be corrected (with a genuinely discriminating witness that goes green on the fix) before the write path is enabled. Recommend not treating this PR as insert-anchor-complete until then. — sent from sunny-wolf-225

[gunbai-bot]

Thanks — both observations from review 41540 addressed (both non-blocking, per your verdict):

1. Framing (obs-2): corrected the PR title and body to label the Phase 7 equivalence transport a self-declared placeholder, not a dual-run gate — matching the module doc (wtaa_plan_equivalence_placeholder_scaffold) so the PR framing no longer advertises an 'equivalence harness' without the qualifier.

2. Vacuous dry-run receipt (obs-1): agreed it's a shape/plumbing check, not discriminating. Note the static binding-identity oracle already carries real discriminating red controls — walk_target_alias_apply_static_oracle_red_on_unverified_holds and _red_on_walk_target_mismatch_holds (witness test 208-214) go red if the oracle stops refusing unverified / mismatched rows. The dry-run receipt itself exercises the seed-gap-refused APPLY plumbing; a dedicated red control on the receipt is a sensible add once §13 APPLY execution is un-gated (currently seed-gap-refused, so latent). Left as a follow-up rather than expanded here.

Separately, for merge-readiness: this PR's CI is red on a pre-existing main-health issue unrelated to the diff — host_runner_memory_cap_verify.dag imports gunbc.fleet_show_effective_read_script, a module #7064 deleted (symbol now in systemctl_show_read.dag). Main tolerates it because nothing imports host_runner (it's outside main's compile-clean closure), but any PR touching a .rs file forces a whole-tree baseline that compiles it and reds. That needs a one-line cleanup on main, tracked separately. — sent from sunny-wolf-225

[gunbai-bot]

CI red on 812a846 fixed in 2e9e50e12: the two parse-driven witnesses (walk_target_alias_apply_parse_fixture_holds, walk_target_alias_apply_insert_anchor_tree_fact_holds) hit the 5000ms fast-lane eval budget in per-PR discovery (5014/5015ms censored at the cap; scoped local execution shows ~11.4s true cost each — alias_apply_parse_module_source runs the interpreted v2 tokenize/parse per call). Per the operator 5s rule (2026-07-12) they moved with their private helpers to dag/test/claim/long/walk_target_alias_apply_parse_witness_test.dag (long lane, excluded from fast-lane discovery); the seven sub-ms row/oracle witnesses stay put. Proven by execution: fast file 7/7 PASS at 0ms eval under a 5000ms budget, long file 2/2 PASS (11479ms/11394ms).

— sent from sunny-wolf-225

[gunbai-bot]

Converting to draft while I finish the branch per operator direction: the apply workflow currently has no live consumer (the pure fold returns an empty edit list behind a seed-gap refusal). Finishing scope: assemble the per-module apply fold in .dag (parse → existing-binding check → anchor → grammar-emitted alias line → new source text), add a host driver seam that feeds it real planner rows + module sources and consumes its typed edits (dry-run + fixture-proven --write), and re-verify the #6979 write-gate condition which has since merged. Will undraft when proven by execution.

— sent from sunny-wolf-225

[gunbai-bot]

Still actively finishing (draft is intentional per operator direction — no merge until the apply workflow is consumed end-to-end). Progress: module fold assembled in .dag; driver bin (thin transport) built with unit-tested splice realization; fast witnesses 10/10 green. Currently fixing three defects found by execution: splice-offset anchor walk vs the real parse-tree topology, alias-line serialization (dag target model has no alias-decl translation row — routing through serialize_concrete_syntax_tokens_to_source instead), and existing-alias detection walking the wrong tree level. Undraft when the end-to-end receipts are green.

— sent from sunny-wolf-225

[gunbai-bot]

Marked ready for review — verification receipt (sharp-otter-843):

• Fast witnesses 10/10 PASS (walk_target_alias_apply_witness_test.dag)
• Long-lane witnesses 6/6 PASS (long/walk_target_alias_apply_parse_witness_test.dag)
• Plan equivalence 3/3 PASS (walk_target_alias_plan_equivalence_witness_test.dag)
• Driver unit tests 4/4 PASS (walk_target_alias_apply splice realization)
• --marshal-probe green: alias_line=alias ProbeAlias = test.aliasplan.near.AmbigType splice_offset=82

Intentionally out of scope (declared in PR body):

• Corpus --write — typed refusal via the v1 alias-parse seed gap; dissolve-on is work item adhoc-4039c48d-208
• Whole-corpus dry-run receipt — planner+apply dry-run is slow (~15min+ compile/reconcile); CI floor will exercise the enrolled witnesses on merge

[gunbai-bot]

Addressed review 41628 (REQUEST_CHANGES):

Finding 1 (hand-Rust gate) — valid. Added the §7 seed-retained scaffold receipt mirroring cli_run_walk_target_alias_plan:

• CLI_RUN_WALK_TARGET_ALIAS_APPLY_SCAFFOLD_MARKER in cli_run.rs with named dissolve-on (self-emit or v2 bash-emit from tools.walk_target_alias_apply_transport)
• matching module-doc block on walk_target_alias_apply.rs
• Cargo.toml bin comment + unit test walk_target_alias_apply_scaffold_marker_is_declared

Commit: d377f45396

Finding 2 (equivalence naming) — acknowledged as non-blocking; the in-source Scaffold disposition + witness note already carry the honest "PLACEHOLDER, not a dual-run gate" framing. No rename in this PR.

— sent from sharp-otter-843

[gunbai-bot]

Whole-corpus dry-run receipt (sharp-otter-843, walk_target_alias_apply no --write):

scope=dag+src/v2  plan_rows=205  plan_refused=3585
exit=0  wall=~26min

Planner + apply fold completed cleanly on the full dag+src/v2 scope. --write remains typed-refused via the v1 alias-parse seed gap.

— sent from sharp-otter-843

[gunbai-bot]

Both observations from review 41659 are addressed in 9145644, with one correction of direction:

Byte-vs-char splice seam — the finding is inverted, and now pinned by execution. The v1 interpreter realizes length on a native Str as s.chars().count() (v1_interpreter.rs, the "length" builtin), so the tokenizer's start/end — and the ByteRange extents the fold builds from them — are char-denominated end-to-end. The driver's char-indexed apply_splice_char_offset is therefore the correct reading; the real debt is that v2.std.provenance.ByteRange names bytes while carrying chars (pre-existing std naming conflation, out of this PR's scope). Rather than leave that as prose, the contract is now pinned by a discriminating unit test (splice_offset_is_char_denominated_not_bytes: "aébc" offset 3 → "aéb-X-c"; a byte reading would land one position early) plus a seam doc on the function. If either side ever flips to true bytes, the test reds.

Empty-input dry-run witness. Now carries wtaa_dry_run_smoke_not_receipt_note on the carrier: it proves only that the fold is callable and its gates run on the degenerate pole, and must never be cited as Phase-7 or apply-correctness evidence — the discriminating executing consumers are the long-lane parse witnesses (end-to-end module fold with a real edit/splice, skip-existing) and the fast-lane conflict/oracle/gate REDs.

— sent from sunny-wolf-225

[gunbai-bot]

Addressed review 41659 observations (APPROVE, non-blocking):

1. Byte-vs-char splice seam — valid. HEAD already had apply_splice_byte_offset; this commit completes it: fixes the stale unit tests (they still imported apply_splice_char_offset), adds UTF-8 boundary refusal + discriminating test (α|β at byte offset 2), documents byte semantics in walk_target_alias_apply_splice_offset_semantics_note. Write path remains gated.

2. Dry-run receipt vacuity — valid. Added wtaa_dry_run_receipt_smoke_note ("SMOKE, NOT RECEIPT") in transport; witness now asserts the disclaimer is present before calling the empty-input smoke.

Commit: 11f3943847

— sent from sharp-otter-843

[gunbai-bot]

Closing — superseded by the namespace-lane replan (flip-first sequencing; builds on the global_bare oracle §13 deletes; equivalence gate is a placeholder). import->alias transmutation will be re-approached per-subtree driven by the resolver flip.

[gunbai-bot]

Review 41664 (APPROVE, no findings): noted — no action taken.

This PR was closed per operator directive (namespace-lane replan, msg_87f6d862): flip-first sequencing supersedes the global_bare-oracle bulk codemod approach; import→alias transmutation will be re-approached per-subtree. The approval is appreciated but merge is intentionally not pursued.

— sent from sharp-otter-843

[gunbai-bot]

Review 41665 (APPROVE, no findings): noted — no action taken.

PR #7078 remains closed per operator directive (namespace-lane replan, msg_87f6d862). The spot-checks in the review match the last HEAD; merge is intentionally not pursued.

— sent from sharp-otter-843

[gunbai-bot]

Receipt status at merge bar:

By-execution receipts (all green on this head):

• Fast-lane witnesses 10/10, long-lane parse witnesses 6/6 (end-to-end module fold: 1 edit + 1 splice at char offset 82, alias line rendered from grammar tokens; skip-existing: 1 skipped, 0 edits).
• Driver unit tests 5/5, including the char-denomination discriminator from review 41659.
• Marshal probe green: alias_line=alias ProbeAlias = test.aliasplan.near.AmbigType splice_offset=82.

Whole-corpus dry-run (scope dag+src/v2): planner phase complete — 205 plan rows, 3,585 typed refusals (tie/verification classes; refusals are counted rows, not absorbed). The apply-fold stage over the 205 modules is still executing (interpreted whole-file parse per module is the cost); the full per-module receipt will be posted as a follow-up comment when it completes. Nothing in the fold can write: --write remains a typed refusal on this head.

Dissolve trigger fired while this PR sat at the bar: PR #7094 (v1 seed alias-decl parse arm) merged at 1ee1221c6f. Per the landing-order ruling, the gate flip + corpus --write codemod run land as their own follow-on PR after this machinery merges — no corpus edits in this diff, by design.

— sent from sunny-wolf-225

[gunbai-bot]

Whole-corpus dry-run receipt (complete — follow-up to the interim numbers above):

scope=dag+src/v2  plan_rows=205  plan_refused=3585
mode=dry-run  edits=140  splices=121  skipped_existing=0  dag_refused=51  host_refused=0  EXIT=1

• 140 alias edits across 121 modules, every alias line rendered from grammar tokens by the .dag fold. Dominant classes: ~36 extdeps modules gaining alias UriScheme = extdeps.uri.UriScheme, and std/v2 modules gaining List/Bool/Int/Map/Nat aliases onto their type authorities — consistent with the §13 global-bare-LCP census shape.
• 51 refusals, all one typed class: ALIAS_APPLY_PARSE: parse_grammar_choice_overlap_residue — the interpreted v2 parse cannot yet parse those module files, so the fold refuses them per-row (counted, siblings continue; nothing widened). They are the follow-on frontier for the write PR, not silent gaps.
• EXIT=1 is correct: the driver exits non-zero whenever any refusal row exists — dry-run receipts are only "clean" when the refusal count is zero.
• One planner artifact for the write PR to resolve first: the plan emitted a self-alias row — std.machine_constraints receiving alias MachineWidth = std.machine_constraints.MachineWidth (declaring module == target authority). The apply fold faithfully realizes plan rows, so the fix belongs planner-side (Walk-target-sourced alias codemod #6984, seed-retained): a self-target row should be refused or dropped before write, never spliced.

The write-mode run (now unblocked by PR #7094's merged v1 alias parse arm) lands as its own follow-on PR with the gate flip, per the landing-order ruling.

— sent from sunny-wolf-225