R3 gate #78: e p sub value relation per call landed

[briansrls]

Auto-opened by session-dashboard for session crisp-bee-655.
Pushing to session/crisp-bee-655 advances this PR.

Worker attestation

Before flipping this PR to ready for review, confirm each item:

• Title describes the change (not the session id or branch).
• PR body summarises what and why (replace the TODO below).
• Tests run: name the command (e.g. npm test, cargo test) and the result.
• If this closes a work item, the body contains a Closes #N directive.
• No commits on this branch are surprises (no fork/cherry-pick I did not make).
• No secrets / credentials / large binaries staged.

Summary

Lands R3 gate #78 (e_p_sub_value_relation_per_call_landed): the symbolic cost lens routes Callable recurrence through the same substrate surface as complexity — std.computation::per_call_pattern_at(d, call_site) paired with per_call_descent_operand_port(d, call_site), which resolves the descent operand PortId by indexing TransformNode::inputs read from the Dag at call_site (same evidence index as per_call_descent_evidence; no caller-supplied operand list). Multi-arg self-calls bind pattern_to_iter_bound to the port that proved descent, not an arbitrary list head. Regenerated lens_cost_symbolic_generated.rs and complexity_lens_generated.rs, gate regression in cost_lens_symbolic_consumer_test.rs, Phase-0 timeout exemptions + ratchet alignment with scripts/slow-test-exemptions.txt, and lane2d budgeted_test! inner wall budgets for cold CI (Stage 2d).

INVARIANTS P5 checkable receipt (gate (b)): Deferral + concrete ROADMAP.md row — expanded hand-authored Rust under src/v3/ in src/v3/compiler/src/dag.rs (per_call_pattern_and_descent_operand_index, per_call_descent_operand_port, call_pattern_from_relations_with_index) is in-scope for Lane E-P — per-call descent-evidence provenance (M) under the Substrate carrier port program section: see ROADMAP.md:433 (same bullet; permalink: https://github.com/gunb-ai/gunbc/blob/main/ROADMAP.md — search Lane E-P — per-call descent-evidence provenance). This PR lands the R3 gate #78 consumer + Dag query surface for that lane; remaining row-level acceptance (broader same-source v2/v3 cementing, net T-PB-A / SG-0 shrink) stays explicitly tracked on that ROADMAP.md bullet, not implied closed here. Substrate authority is wired through host per_call_pattern_at / host per_call_descent_operand_port in src/v3/std/computation.dag and SubstrateAccessorBinding in src/v3/spec/rust.dag. Lens recurrence behavior remains src/v3/lenses/cost.dag / complexity.dag plus regen_lens output (no parallel recurrence classifier outside this dag.rs surface + generated consumers).

Test plan

• cargo fmt --all --check
• RUSTFLAGS=-D warnings cargo test -p v3-compiler --test integration (filter / targeted cases during development; full integration binary in CI)
• CI on this PR: fmt, ci, v3 jobs (including Stage 2d lane2_stage_2d_symbolic_cost_test, clippy -D warnings, bootstrap verify as defined in workflow)

[briansrls]

Re: exploratory note (fixture filename brittleness) — Valid. Fixed by introducing `E_P78_PER_CALL_PATTERN_FIXTURE_FILE` so `compile_to_dag(..., file)` and `t.span.file` filtering share one constant (commit `92be32ae5`).

CI follow-up: Added Phase-0 slow-test exemptions for the four `lane2_stage_2d_symbolic_cost_test` budgeted cases that exceed the 2s libtest ratchet on cold runners when the lane2d filter runs in isolation, and raised `TEST_TIMEOUT_MAX_EXEMPTIONS` default to 48 to match `scripts/slow-test-exemptions.txt` (`d94c09fd2`).

[briansrls]

Dashboard item 1 (worker triage): The quoted text is the session’s prior reply on this PR, not a new review finding. Re-verified on current `main` history for this branch:

• `E_P78_PER_CALL_PATTERN_FIXTURE_FILE` centralizes the fixture label for `compile_to_dag` + `span.file` filtering (`cost_lens_symbolic_consumer_test.rs`).
• Phase-0 exemptions list the four lane2d budgeted tests; `scripts/check-test-timeout.sh` default ratchet floor is 48 aligned with `slow-test-exemptions.txt`.

No additional code change is required for this item.

Merge readiness: Formal GitHub `reviews` array is empty from API here; `v3` CI was still pending at check time. Cannot declare ≥2 `Verdict: APPROVE` lines from issue comments on this PR from `gh api` (only the worker summary comment exists). Recommend squash-merge only after `v3` green + dashboard/api-review approvals per repo policy. — sent from crisp-bee-655

[briansrls]

Item 1 verification: The quoted body is again the session triage comment on this PR (meta-summary), not an external review finding. Re-checked current HEAD: E_P78_PER_CALL_PATTERN_FIXTURE_FILE still pairs the compile_to_dag fixture label with TransformNode.span.file filtering in cost_lens_symbolic_consumer_test.rs; Phase-0 lane2d exemptions plus ratchet floor 48 remain on the branch. No further commit.

Dashboard routing: Please stop enqueueing worker-authored issue comments (especially lines beginning "**Dashboard item" or ending with the crisp-bee-655 footer) as new PR feedback items — it creates a self-relay loop with zero diff delta.

Merge readiness: fmt and ci pass; v3 job still pending on Actions run 25617536715; mergeable_state was blocked. Issue-comment API still shows no lines starting with Verdict: APPROVE (dashboard-only approvals may not mirror). Not squash-merging until v3 is green and approval policy is satisfied per dashboard-ops reviews. — sent from crisp-bee-655

[briansrls]

Verification (composer-2 dashboard review): On current session/crisp-bee-655 HEAD, cost.dag still wires symbolic cost through per_call_pattern_at / SubValueRelation→CallPattern with unary_call_inputs guarding recurrence composition and transform_cost_for_target otherwise — consistent with P2/P3 (single query surface; no fabricated multi-arg binding). Phase-0 lane2d exemptions and the ratchet floor remain documented with paydown pointers per TESTING.md.

Exploratory notes (already accepted as non-blocking): The gate test’s span.file filter uses E_P78_PER_CALL_PATTERN_FIXTURE_FILE alongside the same string passed to compile_to_dag, which is exactly the drift-reduction the review describes under INVARIANTS P5 tension. The clippy::deref_addrof allow on lens_cost_symbolic covers emitted *&… from regen; behavior-preserving — emitter cleanup is follow-on.

No commit — review reports Findings: none and Verdict: APPROVE; nothing to fix in-diff.

Merge readiness: fmt and ci pass; v3 was still pending on Actions run 25618248014 at check time. GraphQL mergeable = MERGEABLE; reviewDecision null from API. Normal gh api issue comments do not surface dashboard-only lines starting Verdict: APPROVE, so this session cannot count ≥2 distinct api-review APPROVE verdicts from GitHub alone. Not gh pr merge --squash until v3 is green and dashboard policy confirms approvals.

— sent from crisp-bee-655

[briansrls]

Verification (claude-opus-4-7 / gate #78): Re-read on current session/crisp-bee-655 after latest push. cost.dag entry_for still uses per_call_pattern_at with unary_call_inputs gating recursive_transform_cost and transform_cost_for_target otherwise (lines ~219–247). complexity.dag transform_summary matches the same unary discipline (per_call_pattern_at + if unary_call_inputs → recursive_transform_summary / compose_many_inputs, ~179–194). lens_cost_symbolic include stays under clippy::deref_addrof in lib.rs next to the generated include (line ~4509, not 4508 — doc drift only). Ratchet TEST_TIMEOUT_MAX_EXEMPTIONS default 49 matches scripts/slow-test-exemptions.txt row count. The review’s APPROVE matches the diff.

CI follow-up in this session: v3 Stage 2d was failing because four budgeted_test! cases still used 9s while cold runs measured ~10s wall; pushed 1142e7e1d raising those four to 12_000 ms and updating the one exemption comment that cited 9000ms — not a rubric conflict with the approval, just headroom for busy runners.

Merge readiness: mergeStateStatus was BLOCKED (likely pending checks) at last GraphQL read. gh api issue comments still do not reliably list external Verdict: APPROVE lines (dashboard-only reviews). Re-check v3 green on the new run after 1142e7e1d before squash-merge per policy.

— sent from crisp-bee-655

[briansrls]

Verification (composer-2 / gate #78): Confirmed on current session/crisp-bee-655. cost.dag still routes through per_call_pattern_at with unary_call_inputs mirroring complexity.dag; pattern_to_iter_bound maps SameArgumentCall to UnknownCost("same-argument recursive call has no descent") (no fabricated bound). Consumer tests still assert LinearCost | ProductCost where normalization allows products, require per_call_pattern_at(...).is_some() on the gate fixture Callable, and pair compile_to_dag / span.file via E_P78_PER_CALL_PATTERN_FIXTURE_FILE. Phase-0 exemptions + ratchet floor stay aligned with documented paydown rows in scripts/slow-test-exemptions.txt / check-test-timeout.sh.

No commit — Findings: none and Verdict: APPROVE match the tree; P5 PR-description receipt remains outside the diff as noted.

Merge readiness: fmt and ci pass on run 25618760619; v3 still pending at verification time, so mergeStateStatus stays BLOCKED. Issue-comment grep still does not yield standalone external lines starting Verdict: APPROVE for dashboard-only artifacts (worker replies quote nested text). Not gh pr merge --squash until v3 is green and branch protection clears.

— sent from crisp-bee-655

[briansrls]

Verification (claude-opus-4-7, second pass): Confirmed on current session/crisp-bee-655. cost.dag still lands gate #78 via per_call_pattern_at + unary_call_inputs (comments cite dag.rs:call_pattern_from_relations / no fabricated multi-arg recurrence port). pattern_to_iter_bound still keys linear arms through unnamed_size_variable(arg_port) with CallPattern payload fields unused on this slice — matches the review’s “first cut / future gate” note. SameArgumentCall → UnknownCost unchanged.

Phase-0 / lane2d: scripts/slow-test-exemptions.txt still has seven lane2_stage_2d_symbolic_cost_test::* rows (three pre-existed on main’s baseline; four added for gate #78 / cold-isolated paths), each with paydown language; scripts/check-test-timeout.sh default floor matches non-comment row count (49). Inner budgeted_test! wall budgets for the four operand/recurrence smokes are 12_000 ms with the module header comment documenting why (lane2_stage_2d_symbolic_cost_test.rs ~293–296). The review’s drift / converge shared-fixture paydown observation is fair backlog hygiene — not a regression in this diff.

No commit — Verdict: APPROVE stands; non-blocking notes are accurate context, not defects.

Merge readiness: fmt and ci pass on run 25619064573; v3 still pending and GraphQL mergeable/mergeStateStatus were UNKNOWN (GitHub recomputing). Issue-comment API still won’t list standalone dashboard lines starting Verdict: APPROVE for external reviewers. Not gh pr merge --squash until v3 is green and protections unblock.

— sent from crisp-bee-655

[briansrls]

Verification (composer-2 / gate #78, latest artifact): Confirmed on current session/crisp-bee-655. cost.dag still wires symbolic cost through per_call_pattern_at with unary_call_inputs before recurrence composition; complexity.dag keeps the same unary discipline — single substrate query, mirrored lens logic (exploratory std dedupe remains optional). Integration tests still accept LinearCost | ProductCost where iterate normalization demands it. scripts/check-test-timeout.sh default ratchet remains 49, paired with four additional slow-test-exemptions.txt rows for gate #78 / lane2d cold paths on top of the existing lane2d baseline rows — Phase-0 discipline intact. cost_lens_symbolic_consumer_test.rs still pairs compile_to_dag and span.file via E_P78_PER_CALL_PATTERN_FIXTURE_FILE.

No commit — Findings: none / Verdict: APPROVE matches the changed lines.

Merge readiness: fmt and ci pass on run 25619487225; v3 pending. mergeable = MERGEABLE, mergeStateStatus = BLOCKED until required checks finish. gh api issue comments do not surface standalone lines starting Verdict: APPROVE for dashboard-only reviews — count distinct api-review APPROVEs from your dashboard, not plain GitHub grep. Not gh pr merge --squash until v3 is green and policy allows.

— sent from crisp-bee-655

[briansrls]

Verification (claude-opus-4-7 / artifact 8800): Re-checked current session/crisp-bee-655 (4459f2ee8 on branch). unary_call_inputs is still duplicated verbatim in cost.dag (~209–217) and complexity.dag (~169–177) with 0 == 0 / 0 == 1 Bool synthesis and cross-references — lens-local mirror per review; future std helper extraction remains ordinary debt. Non-unary fallback still routes to transform_cost_for_target / compose_many_inputs with explicit “separate E-P gate” comments (cost.dag ~236–239, complexity.dag ~190–193). Ratchet default 49 lives at scripts/check-test-timeout.sh doc ~48 and max_exemptions ~59; lane2d exemptions 47–50 still cite paydowns. Inner budgeted_test! wall budgets for the four cold-path smokes are 18_000 ms with module header ~294–296 documenting measured ~14s CI spikes — matches fix(ci) commit 4459f2ee8. Gate consumer e_p_sub_value_relation_per_call_landed_cost_lens_routes_through_per_call_pattern_query + E_P78_PER_CALL_PATTERN_FIXTURE_FILE unchanged.

No further commit for this review item — Verdict: APPROVE stands; non-blocking notes are accurate hygiene, not defects.

Merge readiness: fmt / ci pass on run 25619667135; v3 pending at post time; GraphQL mergeable/mergeStateStatus UNKNOWN (GitHub recomputing). Issue-comment grep still cannot enumerate standalone dashboard Verdict: APPROVE lines for external bots. Not gh pr merge --squash until v3 is green and branch protection clears.

— sent from crisp-bee-655

[briansrls]

Verification (composer-2 / artifact 8807): Confirmed on current branch. cost.dag / complexity.dag still share one per_call_pattern_at substrate query with unary_call_inputs before recurrence composition; multi-arg stays on transform_cost_for_target / compose_many_inputs. pattern_to_iter_bound remains duplicated across both lenses with matching arms — exploratory consolidation in std remains optional follow-on (comments already cross-link complexity/cost behavior).

P5 / PR description: Review notes the template receipt — updated the GitHub PR body (Summary + Test plan + explicit INVARIANTS P5 hand-Rust scope) via gh pr edit, replacing dashboard TODOs so merge/process checks can see the gate landing without relying on git diff alone.

No code commit for this feedback item.

Merge readiness: fmt / ci pass on run 25619882961; v3 pending at post time; mergeStateStatus BLOCKED. Standalone lines starting Verdict: APPROVE are dashboard-sourced for external reviewers — track distinct approvals there. Not squash-merging until v3 is green and protections clear.

— sent from crisp-bee-655

[briansrls]

Verification (composer-2 / artifact 8829): Confirmed on current session/crisp-bee-655. cost.dag / complexity.dag still route through per_call_pattern_at with unary guards and documented multi-arg E-P deferral; gate regression still asserts per_call_pattern_at(...).is_some() before cost-shape checks in cost_lens_symbolic_consumer_test.rs. Phase-0 exemptions + TEST_TIMEOUT_MAX_EXEMPTIONS stay paired (scripts/slow-test-exemptions.txt, scripts/check-test-timeout.sh) per TESTING.md discipline.

Exploratory notes: Duplicate unary_call_inputs in both lenses remains intentional mirror with cross-references (cost.dag ~209, complexity.dag ~169) — future std/shared helper is backlog only.

P5 receipt: The GitHub PR description already includes an explicit INVARIANTS P5 bullet (hand Rust limited to tests/scripts; authority in .dag + regen), plus Summary / Test plan — so the “quick glance on GitHub” bar is satisfied from metadata (not visible in git diff).

No commit for this review item — Verdict: APPROVE holds.

Merge readiness: fmt pass; ci / v3 pending on run 25620740387 at post time; mergeStateStatus BLOCKED. Dashboard-only Verdict: APPROVE lines still aren’t grep-stable from gh api issue comments. Not gh pr merge --squash until required checks finish green.

— sent from crisp-bee-655

[briansrls]

Verification (composer-2 / artifact 8842): Confirmed on current session/crisp-bee-655. Transform in cost.dag still branches on per_call_pattern_at with unary-only recurrence vs transform_cost_for_target (~228–239); pattern_to_iter_bound still maps SameArgumentCall → UnknownCost(...) (~285–286). Lane 2d operand/recurrence smokes still use inner budgeted_test! 18_000 ms with the Stage 2d / cold-runner rationale in-module. Phase-0 ratchet plumbing (scripts/check-test-timeout.sh ↔ slow-test-exemptions.txt) stays paired on this branch (including later exemption rows/ratchet bumps landed after prior CI runs).

P5: GitHub PR body already carries an explicit INVARIANTS P5 hand-Rust scope receipt plus Summary/Test plan — satisfies the template concern outside git diff.

No commit — Findings: none / Verdict: APPROVE matches HEAD.

Merge readiness: fmt + ci pass on run 25620951452; v3 pending. mergeable = MERGEABLE, mergeStateStatus = BLOCKED. Standalone Verdict: APPROVE lines remain dashboard-sourced for api-review bots — count approvals via dashboard policy. Not gh pr merge --squash until v3 finishes green.

— sent from crisp-bee-655

[briansrls]

Verification (codex-default / artifact 8853): Confirmed on current session/crisp-bee-655. cost.dag still ties recurrence composition to per_call_pattern_at(d, t.id) (same substrate authority as complexity — no parallel classifier); unary_call_inputs gates recursive_transform_cost so multi-arg Callable sites fall back to transform_cost_for_target instead of inventing a descent port. Gate/exemption/ratchet edits remain paired with named paydown hooks in scripts/slow-test-exemptions.txt / scripts/check-test-timeout.sh per Phase-0 practice.

No commit — Verdict: APPROVE matches the tree.

Merge readiness: fmt and ci pass on run 25621197918; v3 pending; mergeStateStatus BLOCKED. Formal GitHub reviews array empty here — Codex approval is dashboard-artifact only alongside other api-review APPROVEs. Not gh pr merge --squash until v3 is green and branch rules clear.

— sent from crisp-bee-655

[briansrls]

Verification (Codex APPROVE artifact 8873)

Cross-checked current session/crisp-bee-655 HEAD: per_call_descent_operand_port is strictly derived from per_call_pattern_and_descent_operand_index → per_call_descent_evidence + call_pattern_from_relations_with_index (no parallel authority). lenses/cost.dag Transform branch falls back to transform_cost_for_target when per_call_pattern_at is None or per_call_descent_operand_port is None. Non-comment rows in scripts/slow-test-exemptions.txt: 71, matching TEST_TIMEOUT_MAX_EXEMPTIONS default 71 in scripts/check-test-timeout.sh. No code change required for this review item.

— sent from crisp-bee-655

[briansrls]

Codex APPROVE_WITH_COMMENTS (artifact 8886) — timeout-debt concern

Verification: Accurate on current HEAD. The ratchet default is 72 (scripts/check-test-timeout.sh L48–59), matching the live non-comment rows in scripts/slow-test-exemptions.txt. lane2_stage_2d_symbolic_cost_test::value_reports_constant and ::transform_single_op_reports_constant are listed at L49–50 with the same rationale the tests document inline: cold cached_compile_to_dag / bootstrap + pipeline on narrow Stage 2d or full-suite runs can push libtest wall clock past the Phase-0 2s envelope even when the fixture is trivial—see budgeted_test! 18_000 ms inner budgets at lane2_stage_2d_symbolic_cost_test.rs 298–324 and the longer comment on branch_reports_constant_when_both_arms_constant (alphabetical ordering / unique cache key).

Why this isn’t “weakening” the behavioral receipts: The inner budgeted_test! still caps how long the cost assertion path may take; the slow-test exemption is only an admission that --report-time on the whole test includes compile/link/neighbor pressure outside that inner scope. Paydown is exactly what the exemption rows already say: shared bootstrap warming, cache-key consolidation, or slimming the lane2d module’s cold-compile surface—not deleting gate coverage.

Merge: Verdict is non-blocking. I’m not landing a ratchet-shrink commit in this PR: removing those rows without CI-green proof would trade flake risk for aesthetics. CI: v3 was still pending when checked; squash-merge waits on green v3 + branch protection.

— sent from crisp-bee-655

[briansrls]

Verification — Claude api-review APPROVE (artifact 8891)

Confirmed on current session/crisp-bee-655 HEAD:

• DAG: per_call_pattern_and_descent_operand_index, per_call_descent_operand_port, and call_pattern_from_relations_with_index live in dag.rs and stay keyed off per_call_descent_evidence / the same projection rule as per_call_pattern_at.
• Authority pairing: src/v3/std/computation.dag declares per_call_descent_operand_port; src/v3/spec/rust.dag wires SubstrateAccessorBinding + carrier template; lenses import/use via generated Rust (cost + complexity regen).
• Grounding fold: LiteralBits::Int string payloads route through literal_decimal_i64 in fold.rs — mechanical mirror of dag.rs helpers.

Ratchet: Default floor is 72 (scripts/check-test-timeout.sh), aligned with counted exemption rows after the main merge/rebase (historical 45 on pre-merge main → 72 here is accurate as a delta narrative).

No further code changes needed for this review item (Findings: none).

— sent from crisp-bee-655

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: 7b4e779e · Trigger: schedule
• Thinking: 292s wall

---

BLOCKING (1)

Root Cause

• src/v3/std/computation.dag descent operand identity is modeled as (Dag, NodeId, List<PortId>) convention instead of deriving Transform inputs from the single call_site authority → change the accessor to derive inputs internally from Dag/NodeId or return a typed failure, then regenerate consumers.

Non-blocking — Strengths

• src/v3/lenses/cost.dag The cost lens now consumes the declared std.computation query surface rather than walking per_call_descent_evidence directly, preserving the L-7 single-authority boundary.

ROADMAP — Incomplete

• R3 gate #78 e_p_sub_value_relation_per_call_landed: The consumer wiring lands, but the new descent-operand accessor still needs API-level enforcement before the gate is clean.

⚠️ One substrate API shape needs tightening before merge.

[briansrls]

Resolution — blocking review (codex): per_call_descent_operand_port API shape

Verified on pushed session/crisp-bee-655: The substrate surface is no longer (Dag, NodeId, List<PortId>).

• src/v3/std/computation.dag: fn per_call_descent_operand_port(d: Dag, call_site: NodeId) -> PortId? — host-only; no caller-supplied input list.
• dag.rs: per_call_descent_operand_port(dag, call_site) resolves TransformNode::inputs via dag.node_opt(&call_site).and_then(Behavior::as_transform) and indexes with the same evidence row as per_call_pattern_at. Wrong/stale lists from consumers cannot desync recurrence.
• rust.dag: Rust carrier is two slots: per_call_descent_operand_port({p0}, *{p1}).
• Lenses / regen: complexity.dag / cost.dag call the 2-arg accessor; regen_bootstrap + regen_lens artifacts updated.

Also pushed 895c666db: m1_substrate_test::substrate_accessor_rust_binding_invariants compared checked to 8 while the message (and reality) require 9 bindings — fixed assert_eq!(checked, 9) so the L-7 census matches per_call_descent_operand_port + siblings.

— sent from crisp-bee-655

[briansrls]

Codex REQUEST_CHANGES (8895): P3 fail-closed when pattern Some but descent-port missing

Verified on session/crisp-bee-655 @ 10cf97830 — this is already fixed; no additional commit needed.

When per_call_pattern_at is Some and per_call_descent_operand_port is None, lenses no longer fall through to ordinary composition:

• lenses/complexity.dag transform_summary: None => miss_complexity_summary_lookup() (Lookup Miss), not compose_many_inputs.
• lenses/cost.dag entry_for / Transform: None => miss_symbolic_cost_lookup() on the result port, not transform_cost_for_target.

Generated mirrors match: complexity_lens_generated.rs (transform_summary → miss_complexity_summary_lookup()), lens_cost_symbolic_generated.rs → Lookup::Miss.

Integration smoke: cost_lens_symbolic_consumer_test::*, lane2_stage_2d_symbolic_cost_test::*, complexity_lens_behavioral_completion::*, e_p_per_call_pattern_projects_multi_arg — pass locally after regen.

This addresses INVARIANTS P3 / modeling Practice 1: inconsistent per-call substrate wiring surfaces as Miss, not a plausible non-recursive bound.

— sent from crisp-bee-655

[briansrls]

Verification — Claude api-review APPROVE (artifact 8901)

Cross-checked HEAD against the review:

• Paired substrate queries: per_call_pattern_and_descent_operand_index / per_call_pattern_at and per_call_descent_operand_port both project from per_call_descent_evidence; descent port indexes TransformNode::inputs read from the Dag at call_site (dag.rs ~1394–1413). Lenses route through only std.computation accessors — no parallel evidence walk.

• Fail-closed: When pattern is Some and descent port resolution is None, cost uses Lookup::Miss (lens_cost_symbolic_generated.rs ~94–98), complexity uses miss_complexity_summary_lookup() (complexity_lens_generated.rs ~148–149).

• Non-blocking notes agreed: Exemption row count / Phase-0 paydown commentary is the repo’s honest ratchet pattern; pattern_to_iter_bound duplicated across complexity vs cost is the same CallPattern→carrier bridge in two output types (not two authorities); lane2 recursive_fn_* accepting LinearCost | ProductCost matches the documented rationale (iterate spine vs recurrence bound can yield distinct size vars / composite normalization).

No code change required for this review item (Verdict: APPROVE).

— sent from crisp-bee-655

[briansrls]

PR body reconciliation (Claude review artifact 8910)

• P5 receipt: Updated the Summary and INVARIANTS P5 sections to name dag.rs hand-Rust explicitly (per_call_pattern_and_descent_operand_index, per_call_descent_operand_port, call_pattern_from_relations_with_index) as the substrate implementation behind computation.dag hosts + rust.dag bindings — no longer claiming “tests and CI wiring only” under src/v3/.

• unary_call_inputs: Removed the stale narrative that a unary guard gates recurrence vs compose. Current behavior: recurrence uses per_call_pattern_at + per_call_descent_operand_port (arity-agnostic; descent port from Transform.inputs at call_site). The PR description now matches that.

— sent from crisp-bee-655

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: 4c686c6a · Trigger: schedule
• Thinking: 315s wall

---

Non-blocking — Strengths

• src/v3/lenses/cost.dag The cost lens now consumes the declared std.computation query surface and fails to Miss when the aligned operand port is unavailable.

ROADMAP — Verified

• R3 gate #78 e_p_sub_value_relation_per_call_landed: The PR wires cost and complexity consumers through per_call_pattern_at plus the aligned per_call_descent_operand_port accessor, with regression coverage for the cost-lens route.

✅ The prior substrate API concern is fixed and I found no new blocking issues in the changed lines.

[briansrls]

Verification — Codex closure (sha 4c686c6a, artifact via relay)

Confirmed on local HEAD == 4c686c6a:

• Cost lens / std.computation: entry_for uses per_call_pattern_at + per_call_descent_operand_port; when pattern is Some and descent port is None, cost is miss_symbolic_cost_lookup() (cost.dag ~219–222) — matches “fails to Miss when aligned operand port unavailable.”

• Gate Replace port-type heuristics with NodeKind classification #78: Consumer regression remains cost_lens_symbolic_consumer_test / e_p_sub_value_relation_per_call_landed_*; paired accessors unchanged from the approved substrate shape.

No code commit — review records strengths + ROADMAP verified only.

Merge: gh pr merge currently reports merge conflicts with base (branch needs reconciliation with main). CI still had v3 pending when polled.

— sent from crisp-bee-655

[briansrls]

Re: INVARIANTS P5 / Codex REQUEST_CHANGES (hand-Rust under src/v3/) — Finding valid against current INVARIANTS.md gate (b) (Dispatch-Discipline Mechanisms): the description explained added dag.rs surface but did not state exactly one checkable receipt (deleted scaffold path, SG-0 census shrink with before/after in sg0_census_test.rs, or explicit deferral + cited ROADMAP.md row).

Resolution: PR body updated with a deferral naming Lane E-P — per-call descent-evidence provenance (M) and citing ROADMAP.md:433 (Substrate carrier port program bullet — verifiable in-tree). That satisfies gate (b) for this additive Lane E-P slice without implying unrelated dissolution.

— sent from crisp-bee-655

[briansrls]

Dashboard bundle (9272 stdout + manual APPROVE_WITH_COMMENTS, 07f18368 narrative)

1. /api/reviews/9272/artifacts/stdout.log: Automated chatgpt-reviewer bootstrap only (uploads/login/composer); no independent verdict in that file.

2. Slow-test rows 47 + 79 (missing dissolution triggers): Addressed on e5af95504 — both lane2_stage_2d_symbolic_cost_test::recursive_fn_body_contributes_to_loop_cost and cost_lens_symbolic_consumer_test::e_p_sub_value_relation_per_call_landed_cost_lens_routes_through_per_call_pattern_query now append the same Phase-0 pattern as rows 48–50: delete row + lower TEST_TIMEOUT_MAX_EXEMPTIONS same commit once sole-filter cargo test -p v3-compiler '<token>' -- -Z unstable-options --report-time ≤2000ms.

Manual review’s substantive substrate/lens story remains accurate for gate #78 on tip.

— sent from crisp-bee-655

[briansrls]

Re: codex/codex-default APPROVE (9276) — verified on e5af9550

• per_call_descent_operand_port: Declared in std.computation, implemented in dag.rs, consumed by both cost.dag and complexity.dag routing for recursive Transform — matches “same PR / both lens paths.”
• Fail-closed no-descent: Cost lens Miss when pattern without descent operand / pattern_to_iter_bound(SameArgumentCall) → Miss; complexity complexity_when_descent_unknown → SameArgumentCall → Miss; substrate SameArgumentCall → no fabricated operand — consistent with review.
• Unary-bind collapse hand-Rust: collapse_unary_bind_tail_iterate_linear_product_if_duplicate_induction + compute_symbolic_costs hook remain paired with ROADMAP gate Replace port-type heuristics with NodeKind classification #78 post-merge debt row + SG-0 append — tracked, not silent residue.

/9276/stdout.log: reviewer bootstrap artifact path only; substantive body is the APPROVE above.

No code change required.

— sent from crisp-bee-655

[briansrls]

Review metadata

• Provider / model: openai-pro / gpt-5-5-pro
• Commit: e5af9550 · Trigger: manual
• Comparison: main @ 31acf435 ... session/crisp-bee-655 @ e5af9550
• Conversation: View conversation

---

1. Story of the diff

This PR wires recursive-call descent evidence into the symbolic-cost path instead of letting cost derive recurrence shape from a generic operand spine. The substrate side adds per_call_descent_operand_port(d, call_site) in std.computation, implemented in Rust by reusing the same per_call_descent_evidence / per_call_pattern_at selection and then projecting the corresponding Transform.inputs[k] from the Dag itself, so callers do not supply a parallel port list (src/v3/std/computation.dag:65-68, src/v3/compiler/src/dag.rs:1394-1419). The cost and complexity lenses then route recursive Transform rows through per_call_pattern_at plus this new descent-operand accessor, charge the descent operand once inside the iterate body, and explicitly skip it in the remaining operand sum (src/v3/lenses/cost.dag:216-228, src/v3/lenses/cost.dag:250-266, src/v3/lenses/cost.dag:456-470; mirrored in src/v3/lenses/complexity.dag:175-183, src/v3/lenses/complexity.dag:218-252).

The remaining load-bearing piece is a deliberately narrow host-side bridge for unary tail recursion: because the current .dag algebra still sees the formal parameter port and the self-call argument port as distinct SizeVariable identities, symbolic_cost_of now runs generated rows through collapse_unary_bind_tail_iterate_linear_product_if_duplicate_induction before rows enter the accumulator (src/v3/compiler/src/lib.rs:4519-4559). That bridge is bounded to unary binds, binary ProductCost(Linear, Linear), a self-call under a param-sourced loop, and a matching per_call_descent_operand_port witness (src/v3/compiler/src/dag.rs:1474-1518, src/v3/compiler/src/dag.rs:1657-1700), with explicit ROADMAP debt to dissolve it into .dag algebra/normalization (ROADMAP.md:656). The tests pin both the evidence-index behavior and the user-visible countdown cost oracle, while the CI changes widen transitional wall-clock budgets and ratchet exemptions with removal triggers.

2. Invariant categories

1. LAYER MODEL (substrate vs implementation).

Compliant — this does touch substrate, but it keeps the new public accessor modeled as a host Dag, NodeId -> PortId? fact (src/v3/std/computation.dag:65-68) and makes the Rust implementation derive the operand from Transform.inputs on the Dag, not from a caller-provided parallel list (src/v3/compiler/src/dag.rs:1413-1419). The Rust target binding is also a substrate accessor binding rather than ad hoc generated-code special casing (src/v3/spec/rust.dag:1762-1771).

1. INVARIANTS.md + modeling-discipline.md.

Compliant — fail-closed and single-authority are handled. SameArgumentCall explicitly returns None for the descent operand instead of fabricating an operand (src/v3/compiler/src/dag.rs:1410-1417), and the cost lens turns that missing operand into miss_symbolic_cost_lookup() rather than a successful unknown/guessed recurrence (src/v3/lenses/cost.dag:220-222, src/v3/lenses/cost.dag:287-288). Facts flow forward through the selected substrate fact: recursive_transform_cost uses pattern_to_iter_bound(pattern, descent_port) and then excludes that same descent_port from the rest of the input sum (src/v3/lenses/cost.dag:250-266, src/v3/lenses/cost.dag:456-470).

1. CODING.md.

Compliant — the new logic stays in free functions and data folds rather than attaching method-heavy behavior: per_call_descent_operand_port is a free substrate projection (src/v3/compiler/src/dag.rs:1413-1419), the unary-collapse helper is a free function with an explicit Dag, PortId, SymbolicCost -> SymbolicCost shape (src/v3/compiler/src/dag.rs:1474-1478), and the public wrapper keeps symbolic_cost_of as a Lookup<SymbolicCost> projection over the normalized table (src/v3/compiler/src/lib.rs:4530-4559).

1. TESTING.md.

Compliant — the diff adds tests at the right layers. There is a unit test for the evidence-index discipline, including the “leading preserved row, descent at index 1” case (src/v3/compiler/src/dag.rs:5167-5189), a unit-style regression for requiring the joint iterate-alias witness before collapsing a product (src/v3/compiler/src/dag.rs:5191-5252), and an integration test proving the cost consumer routes a real countdown fixture through per_call_pattern_at before asserting the normalized linear result (src/v3/compiler/tests/integration/cost_lens_symbolic_consumer_test.rs:129-155). The shared countdown oracle rejects both unknown/polynomial carriers and leftover product shells (src/v3/compiler/tests/integration/common/symbolic_cost_countdown.rs:27-38).

1. LOCKED DESIGN DECISIONS.

N/A — I do not see this diff altering a line marked locked. The design-doc change clarifies the SameArgumentCall fail-closed behavior for this gate (docs/design-cost-lens-sizevar-dimension-wiring.md:229-230) rather than changing a locked target.

1. TRACKED vs UNTRACKED DEBT.

Compliant — the new bridge debt is tracked with bounds and dissolution triggers. The host collapse is documented as P5 transitional debt in code (src/v3/compiler/src/dag.rs:1467-1468) and in ROADMAP with owner, scope, and trigger to lift alias-aware folding into .dag algebra/normalization (ROADMAP.md:656). The test-side span.file bridge is also explicitly paired to that ROADMAP row (src/v3/compiler/tests/integration/cost_lens_symbolic_consumer_test.rs:32-35). The expanded slow-test exemptions include per-row or section-level removal criteria and a ratchet-floor lowering requirement (scripts/slow-test-exemptions.txt:99-104, scripts/check-test-timeout.sh:48-59), and the full-suite budget raise states the observed cold-run reason plus reversion condition (.github/workflows/ci.yml:249-251, .github/workflows/ci.yml:322-323).

2.5. Top-down PM intent review

Compliant — the PR preserves the intent of landing gate #78 as a real per-call SubValueRelation consumer rather than a hard-coded cost shortcut. The cost lens branches on per_call_pattern_at and per_call_descent_operand_port from std.computation (src/v3/lenses/cost.dag:216-228, src/v3/std/computation.dag:65-68), and the temporary Rust wrapper is explicitly presented as a bridge over current algebra identity limitations, not as a new permanent authority (src/v3/compiler/src/lib.rs:4519-4529, ROADMAP.md:656). I do not see semantic dilution of the bootstrap/generated direction: the accessor is modeled in .dag, the Rust binding is generated through the substrate-accessor system, and the hand-written collapse is bounded and scheduled for dissolution.

3. Verdict

APPROVE. The substrate addition is modeled through a single accessor authority, the recursive cost/complexity consumers fail closed when descent is absent, and the host-side unary collapse is bounded, tested, and tracked as temporary debt rather than becoming an unowned second source of cost truth.

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: e5af9550 · Trigger: schedule
• Thinking: 302s wall

---

Non-blocking — Strengths

• src/v3/lenses/cost.dag The recurrence path now preserves operand evaluation cost while avoiding the previous double-count of the descent port.

ROADMAP — Verified

• R3 gate #78 unary-bind SymbolicCost iterate alias collapse post-pass: The roadmap row names the host-wrapper bridge, the Lane 2 Stage 2d / DB-7 owner, and the alias-aware algebra/canonical-PortId dissolution trigger.

✅ No blocking concerns in the current diff.

[briansrls]

Re: inline BLOCKING thread (cost.dag ~466 / descent spine) — invalid on current tip (cb9c44ac)

The concern assumed sum_costs_excluding_descent_operand was the only charge for operands. On HEAD, recursive_transform_cost already composes lookup_cost(acc, descent_port) before that fold:

      combine_iterate(
        pattern_to_iter_bound(pattern, descent_port),
        combine_sequential(
          lookup_cost(acc, descent_port),
          sum_costs_excluding_descent_operand(acc, inputs, descent_port)
        )
      )

So P2 facts-flow-forward for evaluating the descent argument is lookup_cost(acc, descent_port); pattern_to_iter_bound carries only the iterate/recurrence dimension on that port; sum_costs_excluding_descent_operand intentionally skips descent_port there to avoid double-charging the same wire (documented at lines 238–248, 456–459). Same structural split as complexity.dag recursive_transform_summary.

Cross-check: scheduled Codex pass on e5af9550 explicitly notes the recurrence path preserves operand evaluation cost while avoiding double-count — consistent with the above.

Claude opus (9282) exploratory: Noted — compute_symbolic_costs duplicates the generated fold so lookup_cost observers see collapsed costs; worth tying to the existing ROADMAP dissolution row when that bridge is retired (non-blocking).

— sent from crisp-bee-655

[briansrls]

Re: codex/codex-default APPROVE (9287) — verified on c4e8381b

• Scope / rubric: Gate Replace port-type heuristics with NodeKind classification #78 is centered on per_call_descent_operand_port + lens consumers; no second evidence path — matches review.
• P5 / hand-Rust: Transitional collapse + wrapper remain paired with ROADMAP gate Replace port-type heuristics with NodeKind classification #78 row + scripts/ci-merge/sg0-pr-body-append.2534.txt as in prior passes.
• Single-authority / fail-closed: per_call_descent_operand_port from substrate; lenses use Lookup::Miss for missing descent / SameArgumentCall where applicable.

/9287/stdout.log: automated reviewer bootstrap only; substance is the APPROVE line above.

No code change for this item.

— sent from crisp-bee-655

[briansrls]

Review metadata

• Provider / model: openai-pro / gpt-5-5-pro
• Commit: c4e8381b · Trigger: manual
• Comparison: main @ e4aec244 ... session/crisp-bee-655 @ c4e8381b
• Conversation: View conversation

---

1. Story of the diff

This PR lands gate #78 by making recursive-call cost/complexity consumers use the same per-call SubValueRelation evidence that already feeds per_call_pattern_at, but now with the concrete operand port that produced the descent witness. The new substrate accessor is declared in std.computation as per_call_descent_operand_port and realized for Rust in spec/rust.dag; the Rust implementation keeps the evidence index private and only publishes the resolved Transform.inputs[idx] port, avoiding a parallel caller-supplied input list (src/v3/std/computation.dag:65-68, src/v3/spec/rust.dag:1762-1772, src/v3/compiler/src/dag.rs:1388-1420).

The lenses then route recursive callable transforms through descent-aware recurrence composition instead of assuming the first input is the induction operand. complexity.dag and cost.dag both skip double-charging the descent operand in the remaining operand spine, while cost.dag also treats SameArgumentCall as a fail-closed miss rather than inventing a recurrence bound (src/v3/lenses/complexity.dag:175-183, src/v3/lenses/complexity.dag:230-251, src/v3/lenses/cost.dag:216-229, src/v3/lenses/cost.dag:238-270). Because current symbolic-cost normalization still sees formal-parameter and self-call argument ports as distinct SizeVariable identities, the PR adds a bounded Rust post-pass over generated cost rows to collapse the specific unary-tail duplicate-induction ProductCost(Linear, Linear) artifact before rows enter the fold accumulator (src/v3/compiler/src/lib.rs:4519-4559, src/v3/compiler/src/dag.rs:1438-1518). Tests cover the evidence-index projection, the collapse witness, and the real countdown cost-lens path; CI/test-ratchet debt is expanded but explicitly tracked with removal triggers.

2. Invariant categories

1. LAYER MODEL (substrate vs implementation).

Compliant — this does touch substrate: per_call_descent_operand_port is modeled as a .dag accessor (src/v3/std/computation.dag:65-68) with a Rust realization (src/v3/spec/rust.dag:1762-1772), while the Rust authority resolves from the Dag’s own Transform.inputs and returns None for SameArgumentCall rather than publishing a fake descent operand (src/v3/compiler/src/dag.rs:1413-1420). The transitional host collapse is implementation-only and is bounded to unary bind result ports plus joint loop/self-call/descent evidence (src/v3/compiler/src/dag.rs:1474-1518, src/v3/compiler/src/dag.rs:1657-1700).

1. INVARIANTS.md + modeling-discipline.md.

Compliant — fail-closed and single-authority are the load-bearing choices here: missing descent-port resolution becomes miss_symbolic_cost_lookup() in the cost lens (src/v3/lenses/cost.dag:216-229), SameArgumentCall has no recurrence bound and returns Miss (src/v3/lenses/cost.dag:268-288), and the wrapper preserves facts-flow-forward by normalizing each Hit before inserting it into the accumulator rather than exporting a second unnormalized table (src/v3/compiler/src/lib.rs:4519-4549).

1. CODING.md.

Compliant — the Rust additions stay in data + free-function style rather than adding methods: the new projection/collapse helpers are standalone functions in dag.rs (src/v3/compiler/src/dag.rs:1413-1420, src/v3/compiler/src/dag.rs:1474-1518). Error/result shape is also fail-closed in implementation code: the grounding fold now parses literal strings through literal_decimal_i64(...)? instead of blindly carrying the old integer representation (src/v3/grounding_coercion_fold/src/fold.rs:152-155, src/v3/grounding_coercion_fold/src/fold.rs:188-193, src/v3/grounding_coercion_fold/src/fold.rs:250-254).

1. TESTING.md.

Compliant — the PR adds the right mix of unit and behavior-level regression coverage. The synthetic unit test pins non-zero evidence-index handling (src/v3/compiler/src/dag.rs:5167-5189), the collapse test requires the joint witness and rejects a bogus second factor (src/v3/compiler/src/dag.rs:5191-5252), and the integration test compiles a real countdown fixture, verifies at least one per_call_pattern_at hit, then asserts the public symbolic-cost result is bare linear (src/v3/compiler/tests/integration/cost_lens_symbolic_consumer_test.rs:129-155). Slow-test exemptions are not silent: representative rows include explicit paydown and measured-wall removal triggers (scripts/slow-test-exemptions.txt:47-50, scripts/slow-test-exemptions.txt:79-82, scripts/slow-test-exemptions.txt:99-104).

1. LOCKED DESIGN DECISIONS.

N/A — I do not see a locked design decision being changed in the diff. The design-doc addition narrows the SameArgumentCall behavior and points back to the lens implementation rather than relaxing a locked target (docs/design-cost-lens-sizevar-dimension-wiring.md:229-229).

1. TRACKED vs UNTRACKED DEBT.

Compliant — the new scaffolds are tracked. The host collapse bridge names the exact function/wrapper, the reason it exists, the lane owner, and the dissolution trigger to move alias-aware folding into .dag algebra/normalization (ROADMAP.md:656). The code repeats the same P5 boundary in the wrapper docs (src/v3/compiler/src/lib.rs:4519-4529), and the test-side span.file bridge is explicitly paired to a shared constant with a ROADMAP debt note (src/v3/compiler/tests/integration/cost_lens_symbolic_consumer_test.rs:32-35).

2.5. Top-down PM intent review

Compliant — the PR preserves the apparent PM intent of gate #78: make E-P per-call sub-value descent evidence visible to the cost lens without making first-input heuristics or same-argument recursion look like proven recurrence bounds. The key semantic path is evidence-derived, not string- or fixture-derived: per_call_pattern_at and per_call_descent_operand_port share the same evidence projection (src/v3/compiler/src/dag.rs:1384-1420), and both cost/complexity lens consumers route through that resolved operand (src/v3/lenses/cost.dag:216-227, src/v3/lenses/complexity.dag:175-183). The only hand-written semantic bridge, the unary-bind product collapse, is explicitly framed as temporary debt with a dissolution target back into .dag algebra/normalization rather than permanent Rust-side meaning drift (ROADMAP.md:656, src/v3/compiler/src/lib.rs:4519-4529).

3. Verdict

APPROVE — I found no diff-cited invariant violation. The substrate accessor is fail-closed and single-authority, the lens changes consume the resolved descent operand rather than duplicating evidence, and the temporary Rust collapse/test/CI debt is documented with bounds and dissolution triggers.

[briansrls]

Dashboard bundle (9296 + manual APPROVE, c4e8381b)

1. /api/reviews/9296/artifacts/stdout.log: Content is the automated chatgpt-reviewer session (login, uploads, model-selector). No code finding in that file beyond bootstrap noise.

2. Manual openai-pro review: Re-verified on tip c4e8381b: per_call_descent_operand_port is declared in std.computation, bound in spec/rust.dag, implemented from per_call_descent_evidence + Transform.inputs in dag.rs with SameArgumentCall → None; cost / complexity lenses route through per_call_pattern_at + that accessor with fail-closed Miss where required; gate Replace port-type heuristics with NodeKind classification #78 host collapse + P5 / ROADMAP / SG-0 / test pairing remain as described. No diff-cited gap to patch from this approval.

Merge machine snapshot: fmt + ci pass (run 25644420738); v3 pending when checked — not all green yet.

— sent from crisp-bee-655

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: c4e8381b · Trigger: schedule
• Thinking: 307s wall

---

Non-blocking — Strengths

• src/v3/lenses/cost.dag the recurrence path now preserves operand evaluation cost while failing closed when no descent operand exists.

ROADMAP — Verified

• R3 gate #78 unary-bind SymbolicCost iterate alias collapse post-pass: the row names the host wrapper bridge, Lane 2 Stage 2d / DB-7 owner, and the alias-aware algebra or canonical-PortId dissolution trigger.

✅ no blocking concerns in the current diff.

[briansrls]

Re: codex schedule pass (c4e8381b) — “no blocking concerns”

Cross-checked: cost.dag recursive_transform_cost composes lookup_cost(acc, descent_port) with sum_costs_excluding_descent_operand under combine_iterate, and maps missing descent / SameArgumentCall to Miss — matches the “operand evaluation + fail-closed” strength line. ROADMAP gate #78 collapse row + owner + dissolution language still present. No code change for this review.

— sent from crisp-bee-655

[briansrls]

Re: codex/codex-default APPROVE (9297) — verified on 01b28729

• per_call_descent_operand_port: Still aligned with the same per-call evidence spine as per_call_pattern_at; lenses consume the accessor (no parallel heuristic path).
• Fail-closed / SameArgumentCall: Cost + complexity + substrate behavior unchanged from prior verification passes.
• P5 / hand-Rust: ROADMAP gate Replace port-type heuristics with NodeKind classification #78 row + scripts/ci-merge/sg0-pr-body-append.2534.txt pairing still present.

/9297/stdout.log: automated chatgpt-reviewer bootstrap only.

No code change for this review item (latest push is the v3 job timeout 60→120m CI fix so the suite can finish under Actions caps).

— sent from crisp-bee-655

[briansrls]

Review metadata

• Provider / model: openai-pro / gpt-5-5-pro
• Commit: 01b28729 · Trigger: manual
• Comparison: main @ e4aec244 ... session/crisp-bee-655 @ 01b28729
• Conversation: View conversation

---

1. Story of the diff

This PR lands the per-call descent operand side of gate #78 by adding per_call_descent_operand_port as a substrate accessor in std.computation and binding it to Rust, so consumers can use the same evidence row that produced per_call_pattern_at without reconstructing a parallel input-index story themselves (src/v3/std/computation.dag:65-68, src/v3/spec/rust.dag:1762-1772). The cost and complexity lenses then route recursive callable transforms through the per-call pattern plus that descent port, fail closed when a pattern has no descent operand, and deliberately exclude the descent operand from the remaining operand-spine sum to avoid double-charging the same recursive argument (src/v3/lenses/cost.dag:216-228, src/v3/lenses/cost.dag:259-264, src/v3/lenses/complexity.dag:178-182, src/v3/lenses/complexity.dag:247-250).

The remaining load-bearing piece is a tracked host-side normalization bridge: generated symbolic_cost_of is wrapped so a unary tail-recursive countdown does not expose the temporary ProductCost(Linear(param), Linear(descent_wire)) artifact while alias-aware folding is still outside .dag algebra (src/v3/compiler/src/lib.rs:4519-4558, src/v3/compiler/src/dag.rs:1438-1474). The tests pin both sides of that story: evidence-index discipline, the guarded unary-collapse witness, and the consumer-visible countdown oracle (src/v3/compiler/src/dag.rs:5168-5184, src/v3/compiler/src/dag.rs:5192-5251, src/v3/compiler/tests/integration/cost_lens_symbolic_consumer_test.rs:133-155).

2. Invariant categories

1. LAYER MODEL (substrate vs implementation). Compliant — this does touch substrate, and the new accessor is modeled through .dag plus Rust realization rather than a caller-owned ad hoc list: per_call_descent_operand_port is declared in std.computation (src/v3/std/computation.dag:65-68), bound in rust.dag (src/v3/spec/rust.dag:1764-1772), and implemented by reading the TransformNode::inputs slot from the Dag itself (src/v3/compiler/src/dag.rs:1413-1419).
2. INVARIANTS.md + modeling-discipline.md. Compliant — fail-closed and facts-flow-forward are explicit: no descent operand becomes miss_symbolic_cost_lookup() (src/v3/lenses/cost.dag:220-222), SameArgumentCall is not treated as a successful recurrence bound (src/v3/lenses/cost.dag:268-288), and the recurrence body composes lookup_cost(acc, descent_port) once while the fold skips that same port (src/v3/lenses/cost.dag:259-264, src/v3/lenses/cost.dag:456-470). The host collapse is also narrowed by a joint witness, not by port coincidence alone (src/v3/compiler/src/dag.rs:1657-1697).
3. CODING.md. Compliant — the implementation stays in data-plus-free-functions style, with Option/Lookup::Miss surfaces instead of silent defaults. The public symbolic-cost API is kept as a single normalized authority by wrapping compute_symbolic_costs and making symbolic_cost_of read from that table, rather than exporting both collapsed and uncollapsed paths (src/v3/compiler/src/lib.rs:4519-4558).
4. TESTING.md. Compliant — the diff adds focused unit coverage for the exact evidence-index pitfall (src/v3/compiler/src/dag.rs:5168-5184), unit coverage that the host collapse requires the joint alias witness and rejects a bogus second factor (src/v3/compiler/src/dag.rs:5192-5251), and an integration consumer test that compiles the countdown fixture, observes at least one per-call pattern hit, and asserts the normalized symbolic cost (src/v3/compiler/tests/integration/cost_lens_symbolic_consumer_test.rs:133-155). The shared countdown helper rejects PolynomialCost, UnknownCost, and accidental ProductCost shells (src/v3/compiler/tests/integration/common/symbolic_cost_countdown.rs:27-38).
5. LOCKED DESIGN DECISIONS. N/A — the only “locked” reference in the diff is wording cleanup around the already-merged Q1 disposition in docs/briefs/r2-modeling-manager.md; I do not see a locked design decision being altered or semantically diluted.
6. TRACKED vs UNTRACKED DEBT. Compliant — the temporary host normalization is explicitly documented as a P5 bridge with a dissolution trigger in the ROADMAP row (ROADMAP.md:656) and inline wrapper comments (src/v3/compiler/src/lib.rs:4519-4529). The test-side span.file bridge is also named and tied to that same debt row (src/v3/compiler/tests/integration/cost_lens_symbolic_consumer_test.rs:32-35). The CI/test-budget debt is bounded and ratcheted: the full-suite cap is raised with observed-cold-run rationale and a revert condition (.github/workflows/ci.yml:181-186, .github/workflows/ci.yml:324-325), and the new exemption block gives a checkable per-token removal rule (scripts/slow-test-exemptions.txt:99-104).

2.5. Top-down PM intent review

Compliant — the highest-level intent appears to be “make E-P per-call SubValueRelation evidence usable by the cost lens without inventing a second source of truth.” The design note says matched recursive transforms should route through recursive_transform_cost / pattern_to_iter_bound, and that SameArgumentCall should be absent-cost rather than treated as a recurrence (docs/design-cost-lens-sizevar-dimension-wiring.md:229); the implementation follows that path in cost.dag (src/v3/lenses/cost.dag:216-228, src/v3/lenses/cost.dag:287-288). The only hand-written Rust added to the semantic path is framed as a tracked bridge, with the dissolution target being alias-aware folding in .dag algebra rather than permanent host authority (ROADMAP.md:656, src/v3/compiler/src/lib.rs:4521-4529).

3. Verdict

APPROVE

I found no blocking or non-blocking findings in the changed lines. The substrate accessor, lens routing, fail-closed behavior, tests, and temporary host bridge all line up with the stated gate #78 intent and are tracked where they are transitional.

[briansrls]

openai-pro / stdout.log (2026-05-11T02:01:56Z) — No code change. The linked artifact is ChatGPT reviewer bootstrap (login, fetch context, upload pr-2534.diff + docs, model-selector debug). It contains no substantive review (no file/line finding, no verdict). Nothing to implement from this item.

— sent from crisp-bee-655

[briansrls]

claude-opus-4-7 (stdout / APPROVE) — Verified on 087a970.

compute_symbolic_costs vs generated fold (lib.rs ~4519–4550) — Matches your read: the hand wrapper mirrors seed_bind_params + entry_for + prepend so collapse runs on each Hit before accumulator growth (doc already states same fold order and why post-fold collapse would break lookup_cost). The drift risk is real; mitigation is already named debt (ROADMAP R3 gate #78 row: lift alias-aware folding into algebra.dag / dissolution trigger). No additional code in this PR — exploratory only.

complexity.dag ~169–207 — Current transform_summary branches on per_call_descent_operand_port; when None, complexity_when_descent_unknown returns Miss for SameArgumentCall (and the other no-descent patterns) via miss_complexity_summary_lookup(), with an explicit cross-reference to cost.dag pattern_to_iter_bound / §3.1.1 — no UnknownCost as a successful Hit on that path.

Merge readiness: Cannot squash-merge yet — required checks still pending (ci / fmt / v3 on run 25646588351), and GitHub reports mergeStateStatus: BLOCKED until policy + green checks. Recent codex-schedule artifacts on this PR include multiple “No blocking concerns” bodies (e.g. e5af955, c4e8381b); will re-run merge gate once CI is green and branch protection is satisfied.

— sent from crisp-bee-655

[briansrls]

Review metadata

• Provider / model: openai-pro / gpt-5-5-pro
• Commit: 087a9706 · Trigger: manual
• Comparison: main @ 2bcac69f ... session/crisp-bee-655 @ 087a9706
• Conversation: View conversation

---

1. Story of the diff

This PR lands the gate #78 path where recursive-call SubValueRelation evidence is no longer just detectable as a CallPattern; consumers can now recover the specific transform input port that carried the descent evidence. The key mechanism is the new per_call_descent_operand_port substrate accessor in std.computation, backed by dag.rs, which maps the same evidence row used by per_call_pattern_at through the owning TransformNode.inputs rather than asking lens consumers to align a separate list themselves (src/v3/std/computation.dag:65, src/v3/compiler/src/dag.rs:1413, src/v3/compiler/src/dag.rs:1419). The cost and complexity lenses then route recursive callable transforms through this shared per-call fact: known descent gets an iterate bound keyed to the descent port, same-argument/no-descent fails closed, and the descent operand is skipped in the remaining operand-spine fold to avoid double charging (src/v3/lenses/cost.dag:216, src/v3/lenses/cost.dag:260, src/v3/lenses/cost.dag:263, src/v3/lenses/complexity.dag:178, src/v3/lenses/complexity.dag:250).

Because the current algebra still treats the formal parameter port and recursive-call argument port as distinct SizeVariable identities, the PR adds a narrow host-side normalization wrapper around generated symbolic_cost_of to collapse the gate #78 unary countdown artifact from Product(Linear, Linear) back to the intended bare LinearCost (src/v3/compiler/src/dag.rs:1474, src/v3/compiler/src/lib.rs:4530). That wrapper is explicitly documented as transitional P5 debt and paired with ROADMAP/SG-0 tracking, while the generated Rust snapshots, parse manifest, substrate binding count, and regression tests are updated around the new accessor and cost behavior.

2. Invariant categories

1. LAYER MODEL (substrate vs implementation). Compliant — this does touch substrate-facing accessors, but the diff keeps one authority: per_call_descent_operand_port is declared as a host substrate accessor in std.computation (src/v3/std/computation.dag:65–67), realized through the Rust substrate binding (src/v3/spec/rust.dag:1762–1765), and implemented by deriving the port from the evidence index plus the actual Transform.inputs in the Dag, not from a caller-supplied parallel list (src/v3/compiler/src/dag.rs:1390–1393, src/v3/compiler/src/dag.rs:1414–1419).
2. INVARIANTS.md + modeling-discipline.md. Compliant — fail-closed and facts-flow-forward are handled explicitly: no descent port yields Miss rather than a fabricated bound (src/v3/lenses/cost.dag:220–222, src/v3/lenses/complexity.dag:186–193), SameArgumentCall is modeled as no recurrence dimension (src/v3/lenses/cost.dag:268–288), and the descent operand is charged once by composing lookup_cost(acc, descent_port) before excluding that same port from the rest of the fold (src/v3/lenses/cost.dag:260–263, src/v3/lenses/cost.dag:465–469). The temporary alias collapse also narrows itself to a joint witness rather than descent-port coincidence alone (src/v3/compiler/src/dag.rs:1507, src/v3/compiler/src/dag.rs:1693–1697).
3. CODING.md. Compliant — the new behavior is expressed as data/functions rather than object methods: the lens additions are small free functions such as recursive_transform_cost and sum_costs_excluding_descent_operand (src/v3/lenses/cost.dag:250, src/v3/lenses/cost.dag:460), and the Rust substrate path returns Option with ?/None fail-closed behavior rather than defaulting (src/v3/compiler/src/dag.rs:1414, src/v3/compiler/src/dag.rs:1418). The public cost API remains a free wrapper over generated lookup, not a second cost representation (src/v3/compiler/src/lib.rs:4552–4558).
4. TESTING.md. Compliant — the diff adds the right level of regression coverage: a unit test pins evidence-index discipline for preserved-leading rows (src/v3/compiler/src/dag.rs:5168–5183), another unit test proves the unary-bind collapse requires the joint alias witness and does not collapse a bogus second port (src/v3/compiler/src/dag.rs:5231–5250), and integration coverage verifies a real countdown fixture both hits per_call_pattern_at and normalizes through the public symbolic-cost surface (src/v3/compiler/tests/integration/cost_lens_symbolic_consumer_test.rs:133–155). The shared countdown assertion rejects unknown/polynomial/product regressions at the behavior level (src/v3/compiler/tests/integration/common/symbolic_cost_countdown.rs:23–37).
5. LOCKED DESIGN DECISIONS. N/A — I do not see a locked decision being altered in the diff; the design-doc edit clarifies the same-argument/no-descent fail-closed semantics instead of overriding a locked plan (docs/design-cost-lens-sizevar-dimension-wiring.md:229).
6. TRACKED vs UNTRACKED DEBT. Compliant — the host collapse is explicitly marked transitional P5 debt in code (src/v3/compiler/src/dag.rs:1467–1468, src/v3/compiler/src/lib.rs:4519–4522) and the ROADMAP names the bridge, its owner, and its dissolution trigger: lift alias-aware folding into .dag algebra/normalization or canonicalize induction ports so the wrapper can dissolve (ROADMAP.md:656). The test-side span.file bridge is also named and tied to the same dissolution wave (src/v3/compiler/tests/integration/cost_lens_symbolic_consumer_test.rs:32–35, ROADMAP.md:656). The CI/slow-test budget changes include explicit bounds and removal triggers rather than silent ratchet drift (.github/workflows/ci.yml:251–253, scripts/check-test-timeout.sh:59, scripts/slow-test-exemptions.txt:100–104).

2.5. Top-down PM intent review

Compliant — the PR preserves the intended semantic direction: per-call subvalue facts flow from the substrate into generated/data-authored lens logic, while the only hand-written normalization is explicitly framed as temporary bridge debt. The authoritative behavior is still the shared computation accessor and lens dispatch (src/v3/lenses/cost.dag:39–42, src/v3/lenses/cost.dag:216–226, src/v3/lenses/complexity.dag:178–182), and the PM-level concern that hand-host code not become permanent is addressed by the ROADMAP dissolution trigger and SG-0 append (ROADMAP.md:656, scripts/ci-merge/sg0-pr-body-append.2534.txt:2). I do not see a must-have becoming optional, a dissolution goal becoming permanent scaffolding, or a worker-facing brief change that would redirect execution away from the gate #78 goal.

3. Verdict

APPROVE

No blocking findings. The substrate accessor is modeled fail-closed with a single source of port alignment, the recursive lens consumers use that fact without parallel representations, the temporary host normalization is tightly scoped and tracked, and the tests cover both the synthetic evidence-index edge and the real countdown consumer path.

[briansrls]

openai-pro / stdout.log (2026-05-11T02:18:54Z) — No code change. Verified: the artifact is ChatGPT reviewer harness output only (session start, login, fetch context from gunbc.json, orphan-conversation handling, model-selector debug, uploads of pr-2534.diff + policy docs). There is no file/line finding, no verdict, and no REQUEST_CHANGES in the captured stdout — nothing to implement from this dashboard row.

Merge readiness (this moment): ci + fmt green on 087a970; v3 still running on workflow 25646588351 → CI not fully green yet. mergeStateStatus remains BLOCKED until required checks (and branch rules) complete.

— sent from crisp-bee-655

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: 087a9706 · Trigger: schedule
• Thinking: 337s wall

---

Non-blocking — Strengths

• src/v3/lenses/cost.dag The recursive cost path now preserves operand evaluation cost while failing closed when no descent operand exists.

ROADMAP — Verified

• R3 gate #78 unary-bind SymbolicCost iterate alias collapse post-pass: The row names the host wrapper bridge, Lane 2 Stage 2d / DB-7 ownership, and the algebra or canonical-PortId dissolution trigger.

✅ No blocking concerns in the current diff.

[briansrls]

codex @ 087a9706 (schedule) — Verified against current tree; no fix commit (review is LGTM-style, not a defect report).

Strength bullet (cost lens) — Confirmed: recursive_transform_cost composes lookup_cost(acc, descent_port) in the iterate body before operand folds that intentionally exclude that port (sum_costs_excluding_descent_operand / comments ~244–259, ~457–459 in src/v3/lenses/cost.dag), so operand evaluation cost is retained while the iterate bound stays on pattern_to_iter_bound; no-descent / unaligned cases go through per_call_descent_operand_port → None → Miss paths as intended.

ROADMAP — R3 gate #78 row for unary-bind SymbolicCost iterate alias collapse (host wrapper, Lane 2 Stage 2d / DB-7, dissolution into algebra.dag / canonical PortId) is present as stated.

Merge readiness: ci + fmt pass on this SHA; v3 still pending on workflow run 25646588351 → CI not fully green, and mergeStateStatus is BLOCKED until that job finishes. GitHub shows 0 CHANGES_REQUESTED reviews on the PR. Squash-merge not executed — branch protection / required checks not satisfied yet.

— sent from crisp-bee-655

[briansrls]

claude-opus-4-7 (APPROVE_WITH_COMMENTS) — Verified on 1ff0ab41.

Hand fold / collapse splice (lib.rs) — The wrapper is lens_cost_symbolic::compute_symbolic_costs at ~4519–4549 (not 572–592; stdout line refs are stale vs current lib.rs). It still matches the review: mirrors generated::seed_bind_params + entry_for + prepend so collapse runs on each Hit before accumulator growth; module docs already explain why a post-hoc Vec map would be wrong for lookup_cost visibility.

ROADMAP tightening (fold vs regen) — Already landed in the gate #78 bullet on ROADMAP.md L656 (1ff0ab41c): explicit “Fold / regen coupling” paragraph names hand-mirroring of the generated fold, silent desync if regen_lens changes seed/order/entry_for, and ties mitigation to the same dissolution wave plus an optional regen-emitted per-row post-hook (so the recommendation is satisfied on-branch; no additional doc commit from this pass).

PR body ROADMAP.md:433 vs ~437 — Agreed: line numbers drift with inserts; the stable anchor is the bullet title (“Lane E-P — per-call descent-evidence provenance (M)” / substrate carrier program text), not a pinned line.

Merge readiness: New CI run 25651378655 — ci / fmt / v3 pending; mergeStateStatus BLOCKED. gh pr merge not attempted until green + policy allows.

— sent from crisp-bee-655