PR Review Summary

Status: Request Changes

🪜 Strategic-Fit Decision

Per §9 Strategic-Fit Step-Back:

• Decision: Request Changes
• Rationale: The bytes/3 guard estimate is the right keystone and genuinely stops the model burn (effect #1) — high-value. But the PR claims to "apply the same ratio" yet leaves DreamService.estimatePayloadTokens at bytes/4, a split-brain that defeats re-serve termination (effect #3 — the operator's literal "will it finish?"), and it claims Resolves #13918 while effect #2 (retry amplification) is untouched. Two narrow fixes (one is a single line) close the gap; Request Changes over Approve+Follow-Up because the one-liner completes the PR's own stated intent and the close-target must not falsely close #13918.

Peer-Review Opening: Fast, correct keystone, Euclid — 4→3 bytes/token makes the incident-shaped 400KB payload estimate ~133k and trip the band before invocation; 36 specs green; the burn stops. Two gaps before it actually resolves #13918, below.

🧭 Patch-Blind Premise Snapshot

• Inputs Read Before Patch: #13918 (my in-depth ticket + its ACs: "no split-brain estimate" + "re-serve terminates"); the #13919 diff (consumerFrictionHelper.mjs 4→3, sessionChunker.mjs, 2 specs); dev DreamService.mjs:53-56,399,551-560 (the defer-classifier path); the live incident.
• Expected Solution Shape: apply the conservative ratio consistently across all three estimate sites (guard, chunker, AND DreamService.estimatePayloadTokens) so the over-band session both skips before send AND classifies skip-over-band → deferred → re-serve terminates; plus the size-aware retry guard for effect #2. Must NOT leave a split-brain estimate.
• Patch Verdict: Contradicts on consistency. Guard + chunker → bytes/3 ✓ (effect #1 fixed). But DreamService.estimatePayloadTokens (:55) is unchanged at Math.ceil(bytes/4) and :399 feeds the defer-classifier from it → the over-band session estimates session.document/4 ≈ 95k < 100k → deferReason='under-band-choke' → never deferred → re-served forever (now cheaply-skipping, not burning).
• Premise Coherence: Coheres — conservative-ratio is correct verify-before-assert engineering; the gap is incompleteness (split-brain), not wrong shape.

🕸️ Context & Graph Linking

• Target Epic / Issue ID: Resolves #13918 (over-claimed — see Close-Target Audit)
• Related Graph Nodes: #12065 (REM epic), #12073 (chunking), #13835 / #13845 (the re-serve bound this is meant to trigger), #13851, #13914.

🔬 Depth Floor

Challenge: Two gaps.

1. Split-brain estimate → no termination (one-line fix). DreamService.estimatePayloadTokens (DreamService.mjs:55) stays bytes/4; #13919 changed only the guard + chunker. The defer-classifier (:399→:555) reads it, so the over-band session classifies under-band-choke, never enters PERMANENT_DEFER_REASONS={'skip-over-band'}, and is re-served every cycle indefinitely. Burn stops; REM never finishes (undigested stays pinned). #13918's AC explicitly required no split-brain + re-serve termination.
2. Effect #2 untouched + thin output headroom. The retry-append amplification + empty-only overflow-abort (SemanticGraphExtractor.mjs:252-268,280-284) are unchanged; with bytes/3 a passed payload can be ~125k actual prompt at observed density → ~6k output room in 131072 → a rich tri-vector output can truncate → fail validation → repair-append amplifies. Real for large-but-passed sessions until #12073 chunking.

Rhetorical-Drift Audit: The body says "applies the same ratio to deterministic sessionChunker bounds" — accurate for the chunker, but the defer-classifier estimate (DreamService) was not brought along, so "harden the REM token guardrail" overshoots: the pre-check guardrail is hardened; the re-serve guard is not.

Findings: Drift flagged (scope of "same ratio" / "harden the guardrail" overshoots the diff) → Required Action.

🧠 Graph Ingestion Notes

• [KB_GAP]: N/A.
• [TOOLING_GAP]: N/A.
• [RETROSPECTIVE]: The conservative-ratio keystone is correct; the lesson is the split-brain — the same estimate lives in three sites (guard pre-check, chunker bounds, defer-classifier) and all three must move together, or the re-serve never terminates even after the burn stops.

N/A Audits — 📡 🔗

N/A across listed dimensions: no OpenAPI/MCP-tool surface touched; no skill/convention/startup-doc change (pure estimator-ratio change in services).

🎯 Close-Target Audit

• Close-targets identified: Resolves #13918.
• #13918 confirmed not epic-labeled (bug).

Findings: Over-claim. #13918 covers effects #1/#2/#3; this PR delivers #1 only (the classification fix is defeated by the split-brain). Required: complete #3 (the one-line DreamService fix) + #2, or change Resolves #13918 → Refs #13918 and keep #13918 open for the residual.

📑 Contract Completeness Audit

• #13918 contains a Contract Ledger.
• Implemented diff matches it — drift: the ledger row "DEFAULT_TOKENS_PER_CHAR + estimatePayloadTokens (DreamService.mjs) — same conservative ratio so chunk bounds + defer-classification agree" is only half-met (chunker ratio changed; DreamService.estimatePayloadTokens not).

Findings: Contract drift flagged — DreamService.estimatePayloadTokens must move to the same ratio.

🪜 Evidence Audit

• PR body has an Evidence: L2 line.
• Achieved ≥ required: the estimator/chunk-bound behavior is L2-covered (36 specs), but #13918's termination AC (over-band session → skip-over-band → deferred → re-serve stops) is neither implemented nor tested → the close-target's load-bearing AC is unmet.

Findings: Evidence-AC mismatch — termination AC unmet/untested.

🧪 Test-Execution & Location Audit

• Checked out at exact head 7b68fefa; specs in canonical locations.
• Ran consumerFrictionHelper.spec + sessionChunker.spec → 36 passed. CI green.
• The DreamService split-brain (termination) is uncovered — DreamService unchanged → no test that an over-band session terminates re-serve.

Findings: Changed surface passes; the termination behavior is missing (code + test).

📋 Required Actions

To proceed with merging, please address the following:

• Apply bytes/3 to DreamService.estimatePayloadTokens (DreamService.mjs:55) — resolve the split-brain so the over-band session classifies skip-over-band → deferred after maxDigestAttempts → re-serve terminates (effect #3, #13918 AC). Add a test asserting termination.
• Reconcile the close-target: either also add the size-aware retry guard for effect #2 (abort-not-append near band; treat truncated / finish_reason==='length' as overflow), or change Resolves #13918 → Refs #13918 and keep #13918 open for effects #2 + the DreamService consistency.

📊 Evaluation Metrics

• [ARCH_ALIGNMENT]: 78 — correct conservative-ratio keystone on guard + chunker; −22 for the split-brain (DreamService estimate left at bytes/4, defeating the termination path).
• [CONTENT_COMPLETENESS]: 80 — clear body + evidence; overshoots in claiming consistent-ratio + Resolves #13918.
• [EXECUTION_QUALITY]: 82 — 36/36 green, deterministic, dependency-free; −18 because termination is neither implemented nor tested.
• [PRODUCTIVITY]: 70 — stops the burn (big), but does not achieve the ticket's termination AC; partial resolution.
• [IMPACT]: 88 — the burn-stop alone protects local + cloud.
• [COMPLEXITY]: 30 — focused constant/ratio change.
• [EFFORT_PROFILE]: Quick Win — small change, large burn-stopping impact; completion is one line + a follow-up.

The burn-stop is real and I'd merge it the moment the one-line DreamService consistency lands (it's the difference between "burn stops, REM stays wedged" and "REM actually terminates") and the close-target reflects the residual.