Session/clever cat 457

[briansrls]

Evaluator freeze — src/v3/compiler/src/test_runner.rs (R3 Bundle 4b)

Summary

(What changed and why.)

Per-PR dissolution gate (required for new/expanded hand-Rust under v3/)

• Exactly one disposition (delete path or census shrink with N→M or lane + cited ROADMAP row/link): ___

SG-0 net-shrink discipline (required when sg0_census_test.rs changes)

CI reads raw PR description text. The lines the gate matches must start at column 0 with SG-0 hand-path delta: and (when required) SG-0 pairing: — a leading markdown list marker (- …) or bold wrapper on the same line will not satisfy the checker. Paste the two lines below the checklist into the description body as plain text (you can keep the bullets as a personal reminder).

• Paste into PR description — SG-0 hand-path delta: ___

• Paste into PR description — SG-0 pairing: ___ (n/a unless delta is strict +N, N>0)

Per-PR debt-paydown receipt (required for all PRs)

• Exactly one disposition (Debt paid or Debt found + routed or No debt touched): ___

Test plan

• (Bulleted checklist of TODOs for verifying the PR.)

[briansrls]

Review metadata

• Provider / model: codex / codex-default
• Commit: ead89364 · Trigger: schedule
• Comparison: origin/main @ 87291782 ... review/pr-2301-ead89364 @ ead89364
• Thinking: 47s wall

---

Verdict: APPROVE

Diff is small and coherent. I don’t see a concrete violation of the pinned modeling, coding, or testing discipline in the changed lines. The new memory_peak_cost helper reads from existing SymbolicCost / max_path authority rather than introducing a parallel representation, and the same PR adds both the integration receipt and the SG-0 census updates for the new hand-authored files.

[briansrls]

Review metadata

• Provider / model: openai-pro / gpt-5-5-pro
• Commit: ead89364 · Trigger: manual
• Comparison: main @ 87291782 ... session/clever-cat-457 @ 818c8b89
• Conversation: View conversation

---

1. Story of the diff

This PR demonstrates R3 gate #94 by carving out a small Rust-side memory-peak cost helper and wiring a cementing-style integration receipt around it. The core mechanism is that memory peak for disjoint/alternative regions uses the existing max_path/dominance lattice rather than the work-style sequential composition path: memory_peak_cost.rs delegates composition to max_path and enforcement to dominates, while src/v3/lenses/cost.dag:236-238 records that this is the same dominance-max basis already used by the cost lens. The test side adds both unit coverage in the new module and an integration demo that compiles a tiny function only to obtain a parameter port, then models a quadratic-vs-constant branch peak and checks it violates a linear memory budget. The SG-0 census is updated for the new hand-authored source and test files, and docs/r3-program-plan.md:295 marks the gate as passing while explicitly deferring full apply_lens(cost, …, Enforce { dimension: Memory, … }) consumption to gate #91.

2. Invariant categories

1. LAYER MODEL (substrate vs implementation).

Compliant — this is implementation-only Rust plus one .dag comment; it does not add a Dag-resident substrate type, field, or variant. The new public surface is registered through src/v3/compiler/src/lib.rs:3698: pub mod memory_peak_cost;, while the actual basis reads existing authorities (max_path, dominates) at src/v3/compiler/src/memory_peak_cost.rs:12.

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

Finding — NON-BLOCKING, API-level enforcement / illegal-states-unrepresentable. src/v3/compiler/src/memory_peak_cost.rs:17: pub fn compose_sequential_memory_peak(a: SymbolicCost, b: SymbolicCost) -> SymbolicCost { exposes a public helper whose correctness depends on the doc precondition at src/v3/compiler/src/memory_peak_cost.rs:14 that the two sequential regions’ live ranges “do not overlap,” but the signature carries no evidence of disjointness and the implementation at src/v3/compiler/src/memory_peak_cost.rs:18 always applies max_path. The integration receipt then uses the same “sequential” API for branch arms at src/v3/compiler/tests/integration/cementing/memory_peak_cost_basis_demo.rs:67, which is semantically disjoint/alternative rather than sequential. I would rename this to the actual modeled basis, e.g. compose_disjoint_memory_peak / compose_branch_memory_peak, or add a typed witness if the intended API is truly sequential-with-nonoverlap. As-is, the invariant is enforced by naming/comment convention rather than the API.

1. CODING.md.

Finding — NON-BLOCKING, clear interfaces. The same line is also the coding-style issue: src/v3/compiler/src/memory_peak_cost.rs:17: pub fn compose_sequential_memory_peak(a: SymbolicCost, b: SymbolicCost) -> SymbolicCost { names the helper as “sequential,” but both the module-level story (src/v3/compiler/src/memory_peak_cost.rs:3-4) and the cost-lens comment (src/v3/lenses/cost.dag:236-238) say the load-bearing operation is max over alternative/disjoint peaks. A clearer name would make the function’s contract readable from the signature instead of from the doc caveat.

1. TESTING.md.

Compliant — the diff adds focused unit tests for the new helper behavior in src/v3/compiler/src/memory_peak_cost.rs:46-92, and adds one integration/demo receipt wired through src/v3/compiler/tests/integration.rs:144-145. The integration test is heavier than a pure unit test, but it is explicitly a gate demonstration and keeps the actual cost-basis assertion focused at src/v3/compiler/tests/integration/cementing/memory_peak_cost_basis_demo.rs:73-77.

1. LOCKED DESIGN DECISIONS.

Compliant — the diff does not alter a locked substrate design; it names the design-lock traceability anchor in the receipt at src/v3/compiler/tests/integration/cementing/memory_peak_cost_basis_demo.rs:38 and records that full apply_lens enforcement remains deferred at docs/r3-program-plan.md:295 / src/v3/compiler/tests/integration/cementing/memory_peak_cost_basis_demo.rs:11-13.

1. TRACKED vs UNTRACKED DEBT.

Compliant — the new Rust authority is explicitly temporary and bounded: src/v3/compiler/src/memory_peak_cost.rs:8-10 says it lasts until class-5 bodies can name memory-dimension folds in v3.std.algebra and until the gate #91 EnforcedApplication fold consumes apply_lens(cost, …) sites. The SG-0 census also records both new hand-authored paths at src/v3/compiler/tests/integration/sg0_census_test.rs:267-268 and src/v3/compiler/tests/integration/sg0_census_test.rs:343-344.

3. Verdict

APPROVE_WITH_COMMENTS. The gate receipt is coherent and the temporary Rust surface is tracked with a named dissolution trigger, but the public helper name/signature currently encodes a disjoint/branch max operation as “sequential” without carrying the non-overlap premise. That is small to fix and non-blocking, but worth tightening before the API attracts more callers.

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: 818c8b89 · Trigger: schedule
• Thinking: 222s wall

---

BLOCKING (2)

Root Cause

• src/v3/compiler/src/memory_peak_cost.rs memory-peak enforcement defines violation as observed inclusively dominating declared instead of first proving the declared budget covers the observed peak → implement the threshold predicate as budget-covers-observed and add equality/incomparable tests.
• src/v3/compiler/src/memory_peak_cost.rs the new demo constructs SizeVariable from an assumed label field that the substrate explicitly says is deferred → remove display_name from all new constructors or land the substrate field plus generated mirror in this PR.

ROADMAP — Incomplete

• memory_peak_cost_basis_demonstrated: Gate #94 should not be marked CONSUMER_LANDED + PASSING until the compile break and enforcement-threshold semantics above are fixed.

⚠️ The PR needs the memory-peak helper to match the declared substrate and enforce budget thresholds correctly before this gate can close.

[briansrls]

BLOCKING: SizeVariable's declared authority in src/v3/std/algebra.dag has only source_port, so this Rust-only display_name field invents an undeclared fact and will not compile against the generated mirror (P1/P2).

[briansrls]

Review metadata

• Provider / model: codex / codex-default
• Commit: 30b34f5f · Trigger: schedule
• Comparison: origin/main @ 87291782 ... review/pr-2301-30b34f5f @ 30b34f5f
• Thinking: 42s wall

---

Verdict: APPROVE

Diff is small and narrowly scoped. I did not find a concrete violation of the pinned modeling, coding, or testing guidance in the changed lines. The new Rust helper establishes a single authority for branch-memory-peak composition, the .dag comment points at that same authority rather than creating a parallel one, and the added cementing test is an acceptable integration-style receipt for the current gate shape.

[briansrls]

Review metadata

• Provider / model: openai-pro / gpt-5-5-pro
• Commit: 30b34f5f · Trigger: manual
• Comparison: main @ 87291782 ... session/clever-cat-457 @ 30b34f5f
• Conversation: View conversation

---

1. Story of the diff

This PR closes R3 gate #94 by declaring the memory-peak cost-basis demonstration “CONSUMER_LANDED + PASSING” while explicitly deferring full apply_lens(cost, …, Enforce { dimension: Memory, … }) to gate #91 (docs/r3-program-plan.md:295). Mechanically, it adds a new exported Rust helper module (src/v3/compiler/src/lib.rs:3698) where branch-style memory peaks compose via max_path and enforcement checks use dominates (src/v3/compiler/src/memory_peak_cost.rs:22, src/v3/compiler/src/memory_peak_cost.rs:32). It then adds unit tests for that helper and a cementing integration receipt that compiles a small function, models branch peaks, and asserts that a quadratic observed peak violates a linear budget (src/v3/compiler/tests/integration/cementing/memory_peak_cost_basis_demo.rs:38). The PR also updates SG-0 census bookkeeping for the new hand-authored Rust paths and adds a cost.dag comment tying memory-peak branch aggregation back to the existing dominant / max_path basis (src/v3/lenses/cost.dag:236). Separately, it changes the SG-0 PR-body checker so that when no SG-0 hand-path delta: line exists, the script synthesizes SG-0 header text from the computed census delta (scripts/check-pr-sg0-net-shrink-discipline.sh:344).

2. Invariant categories

1. LAYER MODEL (substrate vs implementation).

N/A — this diff does not add or mutate substrate carriers in dag.rs or substrate .dag types; the new cost surface is implementation-owned Rust exported from lib.rs (src/v3/compiler/src/lib.rs:3698) and explicitly marked interim rather than substrate-authoritative (src/v3/compiler/src/memory_peak_cost.rs:8).

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

Finding — P5 Progress Is Dissolution / SG-0 gate fail-closedness. scripts/check-pr-sg0-net-shrink-discipline.sh:349 synthesizes a valid-looking pairing line for every positive computed SG-0 net increase: SG-0 pairing: (c) structural deferral; follow-up dispatch: T-Lens-Application-Surface Slice B lens-fold consumer .... Because that line is manufactured whenever the body lacks the anchor (scripts/check-pr-sg0-net-shrink-discipline.sh:344), a PR can add unrelated hand-authored paths and still pass with a hard-coded deferral to gate #91. That turns missing authored debt tracking into plausible output, which is the exact shape P5/P3 are meant to reject. The safe shape is to auto-synthesize only the mechanically checkable delta, or only for non-positive deltas; positive net additions should still require an explicit PR-body pairing or a fetched real PR body.

1. CODING.md.

Compliant — the memory-peak implementation follows the data + free-functions convention: compose_branch_memory_peak(a, b) is a pure function over explicit SymbolicCost inputs (src/v3/compiler/src/memory_peak_cost.rs:22), and memory_peak_enforcement_violates takes the budget and observed peak directly rather than reading hidden state (src/v3/compiler/src/memory_peak_cost.rs:32).

1. TESTING.md.

Finding — regression coverage gap for the CI fix. The memory-peak helper is covered by focused unit tests (src/v3/compiler/src/memory_peak_cost.rs:51) and the gate #94 cementing test (src/v3/compiler/tests/integration/cementing/memory_peak_cost_basis_demo.rs:38), but the fix(ci) behavior itself changes the SG-0 gate at scripts/check-pr-sg0-net-shrink-discipline.sh:344 and scripts/check-pr-sg0-net-shrink-discipline.sh:349 without a script-level regression in the diff. Given that the new branch can alter whether debt discipline passes or fails, it needs a hermetic shell test for at least “missing body + positive net” and “missing body + non-positive net” cases, with the positive case preserving explicit-pairing requirements.

1. LOCKED DESIGN DECISIONS.

Compliant — the PR references the locked lens-application surface as a traceability anchor but does not silently claim the full enforcement path has landed: the test states parser-level apply_lens(cost, DeclarationScope, Enforce { ... }) still awaits the gate #91 fold consumer (src/v3/compiler/tests/integration/cementing/memory_peak_cost_basis_demo.rs:11), and the program-plan row says the same (docs/r3-program-plan.md:295).

1. TRACKED vs UNTRACKED DEBT.

Finding — synthesized debt tracking is not tracked debt. The new memory_peak_cost Rust authority is properly bounded as interim and names the dissolution trigger at gate #91 (src/v3/compiler/src/memory_peak_cost.rs:8), but the SG-0 fallback fabricates the debt receipt for positive net additions (scripts/check-pr-sg0-net-shrink-discipline.sh:349) and injects it into the body used for validation (scripts/check-pr-sg0-net-shrink-discipline.sh:361). A tracked bridge needs documentation, bounds, and a named dissolution trigger authored for the actual added path; a generic auto-inserted “structural deferral” cannot satisfy that for arbitrary future PRs.

3. Verdict

REQUEST_CHANGES

The memory-peak helper and its tests are shaped cleanly, and the gate #94 story is coherent. The blocking issue is the SG-0 checker: it can manufacture a positive-net pairing line instead of requiring the PR to carry the explicit debt receipt the gate is supposed to enforce.

[briansrls]

Review metadata

• Provider / model: openai-pro / gpt-5-5-pro
• Commit: eb2e617a · Trigger: manual
• Comparison: main @ 87291782 ... session/clever-cat-457 @ c2be6269
• Conversation: View conversation

---

1. Story of the diff

This PR adds an interim Rust-side memory-peak cost authority for R3 gate #94. The new memory_peak_cost module models branch/alternative peak memory composition as max_path rather than sequential sum, and it defines enforcement as “violation unless the declared budget dominates the observed peak,” including fail-closed behavior for incomparable costs (src/v3/compiler/src/memory_peak_cost.rs:22-42). It then wires a cementing integration demo that compiles a tiny function only to obtain a parameter-backed SizeVariable, manually models a quadratic-vs-constant branch peak, and checks that a linear declared memory budget is rejected (src/v3/compiler/tests/integration/cementing/memory_peak_cost_basis_demo.rs:40-73). The PR also updates the SG-0 census and R3 program-plan gate status to mark this interim receipt as landed, while leaving the full apply_lens(cost, …, Enforce { dimension: Memory, … }) path deferred to gate #91.

The one problematic part is not the memory-peak helper itself; it is the CI fallback in check-pr-sg0-net-shrink-discipline.sh. That fallback now fabricates a positive-delta SG-0 pairing line when the PR body lacks the required anchor, which turns the debt gate from an explicit author receipt into a generic script-authored deferral.

2. Invariant categories

1. LAYER MODEL (substrate vs implementation).

N/A — the diff does not introduce or alter substrate types, Dag fields, or new Dag variants; the memory-peak behavior is an implementation helper over existing SymbolicCost, max_path, and dominates (src/v3/compiler/src/memory_peak_cost.rs:12-23).

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

Finding — BLOCKING, P5 Progress Is Dissolution / tracked debt must be explicit. The SG-0 fallback fabricates a structural-deferral receipt for any positive census delta when the body lacks an anchor:

scripts/check-pr-sg0-net-shrink-discipline.sh:348:   if [ "$computed_net" -ge 1 ]; thenscripts/check-pr-sg0-net-shrink-discipline.sh:349:     synth_pair=$'SG-0 pairing: (c) structural deferral; follow-up dispatch: T-Lens-Application-Surface Slice B lens-fold consumer (\`apply_lens(cost, …)\`; gate #91 per docs/r3-program-plan.md).'

That synthetic pair is then inserted into the body passed to validation:

scripts/check-pr-sg0-net-shrink-discipline.sh:361:   if [ -n "$synth_pair" ]; thenscripts/check-pr-sg0-net-shrink-discipline.sh:362:     body="$(printf '%s\n%s\n\n%s\n' "$delta_line" "$synth_pair" "$body")"

The net-delta count is mechanically derivable, but the pairing lane and dissolution trigger are not. For unrelated future PRs that add hand-authored paths and omit the SG-0 body section, this will let CI certify the addition as “T-Lens-Application-Surface Slice B” debt even when that is not the actual lane. The gate should either auto-fill only non-positive/count-only cases, or fetch/require the real PR-authored pairing for positive deltas; it should not invent a valid positive-delta deferral.

1. CODING.md.

Compliant — the memory-peak implementation uses small free functions with explicit inputs: compose_branch_memory_peak(a, b) delegates to the existing authority max_path(&[a, b]) (src/v3/compiler/src/memory_peak_cost.rs:22-23), and memory_peak_enforcement_violates is a pure predicate over two SymbolicCost references (src/v3/compiler/src/memory_peak_cost.rs:38-42).

1. TESTING.md.

Compliant — the new helper has focused unit tests for the max-path delegation, strict exceed, covering budget, equality, and incomparable-variable fail-closed behavior (src/v3/compiler/src/memory_peak_cost.rs:59-131), and the cementing demo is registered in the integration suite (src/v3/compiler/tests/integration.rs:144-145).

1. LOCKED DESIGN DECISIONS.

Compliant — the integration test references the design-lock name as a traceability anchor (src/v3/compiler/tests/integration/cementing/memory_peak_cost_basis_demo.rs:36) and explicitly limits the demo as interim until the Slice B lens-fold consumer lands (src/v3/compiler/tests/integration/cementing/memory_peak_cost_basis_demo.rs:11-13); I do not see a divergence from a locked decision in the diff.

1. TRACKED vs UNTRACKED DEBT.

Finding — BLOCKING. The new memory-peak Rust authority itself is tracked: it names the interim status and dissolution target at src/v3/compiler/src/memory_peak_cost.rs:8-10, and the census records the new hand-authored production and test paths at src/v3/compiler/tests/integration/sg0_census_test.rs:267-268 and src/v3/compiler/tests/integration/sg0_census_test.rs:343-344. However, the CI fallback creates untracked debt for future positive-delta PRs by hard-coding a generic “structural deferral” pairing at scripts/check-pr-sg0-net-shrink-discipline.sh:349; that makes missing PR-specific documentation appear tracked when it is not.

3. Verdict

REQUEST_CHANGES

The memory-peak cost basis looks well-scoped and well-tested, but the SG-0 fallback weakens the tracked-debt gate by synthesizing a positive-delta pairing that CI cannot actually know. Fixing that now is important because this script is a repository-wide enforcement surface, not just a local helper for gate #94.

[briansrls]

Review metadata

• Provider / model: claude / claude-opus-4-7
• Commit: c2be6269 · Trigger: schedule
• Comparison: origin/main @ 87291782 ... review/pr-2301-c2be6269 @ c2be6269
• Thinking: 31s wall

---

Findings

• scripts/check-pr-sg0-net-shrink-discipline.sh:341-369 — The new fallback auto-synthesizes both the SG-0 hand-path delta: line and a hardcoded pairing rationale ((c) structural deferral … gate #91) whenever the body lacks the anchor. The numeric equality check vs computed_net is preserved, but the pairing attestation — which the script header describes as the contributor's load-bearing attestation for positive deltas — is now mechanically forged to a fixed Slice-B deferral target regardless of what the PR is actually doing. That converts a thoughtful gate into a rubber stamp for any PR that omits the template. Non-blocking (process tooling, not substrate), but worth reconsidering: at minimum log a stronger warning, or refuse to synthesize the pairing line and only auto-fill the numeric line so contributors must still own the rationale.

• src/v3/compiler/tests/integration/cementing/memory_peak_cost_basis_demo.rs:27-34 — 64 MB stack thread to compile a one-line if n <= 0 then 0 else n fixture looks like cargo-cult from heavier cementing demos. Non-blocking, but if not load-bearing it's noise.

The Rust module itself is clean: it's implementation-layer (not Dag substrate), reuses max_path/dominates rather than parallel-representing the order, and the test for enforcement_clean_when_budget_ties_observed_peak_under_dominance correctly pins the "violates iff strict exceed (incomparable fail-closed)" contract stated in lens_application.dag. The cost.dag comment correctly cross-links to the Rust authority without duplicating logic.

Verdict

APPROVE_WITH_COMMENTS — Rust authority for gate #94 is small, well-grounded in existing dominance machinery, and the cementing demo plus census entries are appropriate. Main concern is the SG-0 script change auto-synthesizing pairing rationale; recommend tightening that before relying on it.