peaks-loop 4.0.48 → 4.0.50

package/dist/services/capability-guard-runner/registry.js

@@ -0,0 +1,140 @@
+// src/services/capability-guard-runner/registry.ts
+//
+// The single production entry point for the 15 P0 guard contracts.
+//
+// Why a registry: before this, `baseline run-guard` hard-coded `J01`, and the
+// only caller of `runAllGuards` was its own unit test (which passed synthetic
+// contracts against `projectRoot: '/'`). There was no production path that ran
+// all fifteen journeys — so "15 pass / 0 fail" was an assertion nobody made.
+//
+// Each contract declares the baseline row AND the verbatim invariant text it
+// enforces; `assertBaselineRef` resolves that against
+// openspec/baselines/current/capability-baseline.json before the contract runs.
+import { P0_JOURNEY_IDS } from '../capability-baseline/types.js';
+import { runJ01Contract } from './contracts/J01.js';
+import { runJ02Contract } from './contracts/J02.js';
+import { runJ03Contract } from './contracts/J03.js';
+import { runJ04Contract } from './contracts/J04.js';
+import { runJ05Contract } from './contracts/J05.js';
+import { runJ06Contract } from './contracts/J06.js';
+import { runJ07Contract } from './contracts/J07.js';
+import { runJ08Contract } from './contracts/J08.js';
+import { runJ09Contract } from './contracts/J09.js';
+import { runJ10Contract } from './contracts/J10.js';
+import { runJ11Contract } from './contracts/J11.js';
+import { runJ12Contract } from './contracts/J12.js';
+import { runJ13Contract } from './contracts/J13.js';
+import { runJ14Contract } from './contracts/J14.js';
+import { runJ15Contract } from './contracts/J15.js';
+/** The integration test that pins each journey's contract. */
+const ARTIFACTS = {
+    J01: 'tests/integration/capability-guard/J01-envelope-arg-shapes.test.ts',
+    J02: 'tests/integration/capability-guard/J02-workflow-trace.test.ts',
+    J03: 'tests/integration/capability-guard/J03-problem-resolution-flow.test.ts',
+    J04: 'tests/integration/capability-guard/J04-audit-goal-binding.test.ts',
+    J05: 'tests/integration/capability-guard/J05-final-review-shape.test.ts',
+    J06: 'tests/integration/capability-guard/J06-resume-deepest-gate.test.ts',
+    J07: 'tests/integration/capability-guard/J07-test-runner-fidelity.test.ts',
+    J08: 'tests/integration/capability-guard/J08-asset-roundtrip.test.ts',
+    J09: 'tests/integration/capability-guard/J09-sop-register.test.ts',
+    J10: 'tests/integration/capability-guard/J10-ide-install-assertion.test.ts',
+    J11: 'tests/integration/capability-guard/J11-doctor-cli-snapshot.test.ts',
+    J12: 'tests/integration/capability-guard/J12-lease-lifecycle.test.ts',
+    J13: 'tests/integration/capability-guard/J13-content-pipeline-trace.test.ts',
+    J14: 'tests/integration/capability-guard/J14-issue-orchestrator-trace.test.ts',
+    J15: 'tests/integration/capability-guard/J15-spec-coverage.test.ts'
+};
+/** One row per P0 journey. `invariant` must be verbatim baseline text. */
+const SPECS = {
+    J01: {
+        kind: 'envelope-arg-shapes',
+        invariant: 'The CLI verb is never shown to the user as a required input',
+        execute: runJ01Contract
+    },
+    J02: {
+        kind: 'workflow-trace',
+        invariant: 'Every hard gate (audit / RD / QA / final-review) is enforced; a failure transitions state back to the prior role',
+        execute: runJ02Contract
+    },
+    J03: {
+        kind: 'workflow-trace',
+        invariant: 'No silent-catch or fake-green pattern is reintroduced in src/services/**',
+        execute: runJ03Contract
+    },
+    J04: {
+        kind: 'hook-assertion',
+        invariant: 'The audit covers exactly six dimensions: correctness, completeness, scope, risks, alternatives, constraints',
+        execute: runJ04Contract
+    },
+    J05: {
+        kind: 'workflow-trace',
+        invariant: 'Every final review contains exactly four dimensions: functional-completeness, problem-resolution, no-new-bugs, existing-functionality-intact',
+        execute: runJ05Contract
+    },
+    J06: {
+        kind: 'workflow-trace',
+        invariant: 'The resume option always identifies the deepest completed gate (audit / RD / QA / final-review)',
+        execute: runJ06Contract
+    },
+    J07: {
+        kind: 'cli-output-golden',
+        invariant: "Per-test fingerprint cache never returns 'passed' for an unverified file (fileMtime + fileSha256 gate)",
+        execute: runJ07Contract
+    },
+    J08: {
+        kind: 'asset-roundtrip',
+        invariant: 'Crystallization requires all gates (audit / RD / QA / final-review) to be in a passing state',
+        execute: runJ08Contract
+    },
+    J09: {
+        kind: 'sop-register',
+        invariant: 'An SOP id must match SOP_ID_PATTERN (lowercase kebab, no dots/slashes) to prevent path traversal',
+        execute: runJ09Contract
+    },
+    J10: {
+        kind: 'hook-assertion',
+        invariant: 'planHookInstall() runs before applyHookInstall() so the diff is reviewable',
+        execute: runJ10Contract
+    },
+    J11: {
+        kind: 'cli-output-golden',
+        invariant: 'Doctor checks live under src/services/doctor/doctor-service/checks/ as a code-driven fixed-registry tree',
+        execute: runJ11Contract
+    },
+    J12: {
+        kind: 'concurrency-lease',
+        invariant: 'Auto-release on terminal heartbeat is best-effort but idempotent: duplicate release is a no-op',
+        execute: runJ12Contract
+    },
+    J13: {
+        kind: 'workflow-trace',
+        invariant: 'The skill does NOT import peaks-code internals; it reuses the Loop Engineering primitives',
+        execute: runJ13Contract
+    },
+    J14: {
+        kind: 'workflow-trace',
+        invariant: 'Every fix carries an AI-modified declaration in the commit body (RL-3)',
+        execute: runJ14Contract
+    },
+    J15: {
+        kind: 'spec-coverage',
+        invariant: 'Coverage-summary discovery order is fixed: <projectRoot>/coverage/coverage-summary.json then /openspec/coverage-summary.json',
+        execute: runJ15Contract
+    }
+};
+export const GUARD_CONTRACTS = P0_JOURNEY_IDS.map((journeyId) => {
+    const spec = SPECS[journeyId];
+    return {
+        journeyId,
+        kind: spec.kind,
+        source: { baselineRow: journeyId, invariant: spec.invariant },
+        execute: spec.execute,
+        evidence: { kind: spec.kind, artifact: ARTIFACTS[journeyId] }
+    };
+});
+export function getGuardContract(journeyId) {
+    return GUARD_CONTRACTS.find((c) => c.journeyId === journeyId);
+}
+export function isJourneyId(value) {
+    return P0_JOURNEY_IDS.includes(value);
+}

package/dist/services/capability-guard-runner/runner.d.ts

@@ -1,5 +1,22 @@
+import type { CapabilityBaselineRow } from '../capability-baseline/types.js';
 import type { GuardContract, GuardContext, GuardRunResult } from './types.js';
+/**
+ * Resolve the contract's declared baseline row out of the frozen baseline and
+ * assert the declared invariant is verbatim text in that row.
+ *
+ * Before this, the check was `if (!source.baselineRow || !source.invariant)`,
+ * i.e. it only asserted the two fields were truthy. Nothing ever read the
+ * baseline, so a contract could name a journey / invariant that does not exist
+ * in the frozen file and still run to a green result.
+ */
+export declare function assertBaselineRef(contract: GuardContract, projectRoot: string): CapabilityBaselineRow;
 export declare function runGuard(contract: GuardContract, ctx: GuardContext): Promise<GuardRunResult>;
+/**
+ * Run every contract and aggregate. A contract that throws (bad baseline
+ * reference, unreadable source file, a probe that blows up) is recorded as a
+ * `fail` result rather than aborting the whole run — the gate has to be able
+ * to say "this journey is broken", not just crash.
+ */
 export declare function runAllGuards(contracts: ReadonlyArray<GuardContract>, ctx: GuardContext): Promise<{
     readonly pass: number;
     readonly fail: number;
@@ -7,3 +24,12 @@ export declare function runAllGuards(contracts: ReadonlyArray<GuardContract>, ct
     readonly total: number;
     readonly results: ReadonlyArray<GuardRunResult>;
 }>;
+/**
+ * Exit-code contract for a guard summary. `skipped` must not be
+ * indistinguishable from `pass`: a run that quietly skipped work is a
+ * different outcome from a run that verified work, so it gets its own code.
+ */
+export declare function exitCodeForGuardSummary(summary: {
+    readonly fail: number;
+    readonly skipped: number;
+}): 0 | 1 | 2;

package/dist/services/capability-guard-runner/runner.js

@@ -1,16 +1,61 @@
-function assertBaselineRef(contract) {
-    if (!contract.source.baselineRow || !contract.source.invariant) {
-        throw new Error('GUARD_CONTRACT_MISSING_BASELINE_REF: contract must reference a baseline row and invariant');
+// src/services/capability-guard-runner/runner.ts
+import { readBaselineFile } from '../capability-baseline/store.js';
+/**
+ * Resolve the contract's declared baseline row out of the frozen baseline and
+ * assert the declared invariant is verbatim text in that row.
+ *
+ * Before this, the check was `if (!source.baselineRow || !source.invariant)`,
+ * i.e. it only asserted the two fields were truthy. Nothing ever read the
+ * baseline, so a contract could name a journey / invariant that does not exist
+ * in the frozen file and still run to a green result.
+ */
+export function assertBaselineRef(contract, projectRoot) {
+    const r = readBaselineFile(projectRoot);
+    if (!r.ok) {
+        throw new Error(`GUARD_CONTRACT_MISSING_BASELINE_REF: ${contract.journeyId} cannot read the frozen baseline at ${projectRoot} (${r.error.code}: ${r.error.message})`);
     }
+    const row = r.file.rows.find((x) => x.journeyId === contract.source.baselineRow);
+    if (!row) {
+        throw new Error(`GUARD_CONTRACT_MISSING_BASELINE_REF: ${contract.journeyId} references baseline row ${contract.source.baselineRow}, which is not in the frozen baseline`);
+    }
+    const declared = contract.source.invariant;
+    if (typeof declared !== 'string' || declared.trim().length === 0) {
+        throw new Error(`GUARD_CONTRACT_MISSING_BASELINE_REF: ${contract.journeyId} declares an empty invariant`);
+    }
+    if (!row.invariants.includes(declared)) {
+        throw new Error(`GUARD_CONTRACT_MISSING_BASELINE_REF: ${contract.journeyId} declares invariant "${declared}", which is not a verbatim invariant of baseline row ${row.journeyId}`);
+    }
+    return row;
 }
 export async function runGuard(contract, ctx) {
-    assertBaselineRef(contract);
-    return contract.execute(ctx);
+    assertBaselineRef(contract, ctx.projectRoot);
+    return contract.execute({ ...ctx, contract });
 }
+/**
+ * Run every contract and aggregate. A contract that throws (bad baseline
+ * reference, unreadable source file, a probe that blows up) is recorded as a
+ * `fail` result rather than aborting the whole run — the gate has to be able
+ * to say "this journey is broken", not just crash.
+ */
 export async function runAllGuards(contracts, ctx) {
     const results = [];
     for (const c of contracts) {
-        results.push(await runGuard(c, ctx));
+        try {
+            results.push(await runGuard(c, ctx));
+        }
+        catch (e) {
+            results.push({
+                journeyId: c.journeyId,
+                contract: c.kind,
+                status: 'fail',
+                diff: {
+                    before: 'contract runs against the frozen baseline',
+                    after: e.message,
+                    reason: `${c.journeyId} contract could not run`
+                },
+                artifactPath: c.evidence.artifact
+            });
+        }
     }
     return {
         pass: results.filter((r) => r.status === 'pass').length,
@@ -20,3 +65,15 @@ export async function runAllGuards(contracts, ctx) {
         results
     };
 }
+/**
+ * Exit-code contract for a guard summary. `skipped` must not be
+ * indistinguishable from `pass`: a run that quietly skipped work is a
+ * different outcome from a run that verified work, so it gets its own code.
+ */
+export function exitCodeForGuardSummary(summary) {
+    if (summary.fail > 0)
+        return 1;
+    if (summary.skipped > 0)
+        return 2;
+    return 0;
+}

package/dist/services/code/auto-compact-lifecycle.d.ts

@@ -51,6 +51,65 @@ export declare function resolveDispatchedStage(input: {
  * attempts inside the same millisecond distinct.
  */
 export declare function newCompactRunId(now: Date): string;
+/**
+ * rid `2026-09-14-compact-dispatch-backoff`: the compact run this session has
+ * already DISPATCHED and whose outcome is still unknown — the backoff token.
+ *
+ * WHY A BACKOFF IS NEEDED AT ALL. Once the ratio crosses the auto-fire
+ * threshold it STAYS crossed: nothing in peaks-loop can compact a running
+ * session, and the harness fires only at its own red line. So the dispatch
+ * obligation became unsatisfiable and fired on every probe. Measured in one
+ * real session (2026-09-13T22:43:33Z → 2026-09-14T14:15:02Z, ~15.5 h):
+ * 1035 `dispatch` rows, 444 checkpoints, and ZERO compactions — 1075 by
+ * 14:22:09.112Z. The dispatch itself is idempotent — `ide-native` only
+ * installs a PreToolUse hook, and a second install of the same hook is a
+ * documented no-op — so 1074 of those rows installed nothing (their own
+ * `dispatchMessage` says `already installed`) and carried no new information.
+ * Only noise: a signal that fires a thousand times is not a signal.
+ *
+ * WHY NO NEW STORE. The one-record-per-session lifecycle store already holds
+ * the one fact the backoff needs: is a compact attempt dispatched and not yet
+ * superseded? `armed` and `compacting` are exactly those two stages, and
+ * `completed` / `failed` mean the attempt is over and the next crossing is a
+ * legitimate new one. The state lives here rather than in
+ * `compact-history.jsonl`, which is append-only and never rewritten — so the
+ * backoff cannot be built by editing history, which is the point.
+ *
+ * STALENESS IS DELIBERATELY IGNORED, for `settleOpenLifecycleRun`'s reason: a
+ * probe arriving after `staleAfterMs` has learned nothing about whether the run
+ * is still live. Age cannot make re-dispatching honest, so the stale window
+ * must not decide it. (`settleOpenLifecycleRun` reads with the same window for
+ * the same reason; the two must not grow two policies.)
+ *
+ * `queued` / `preparing` / `verifying` are NOT open here: they are transient
+ * stages inside a dispatch or a settle, and a process that died in one of them
+ * left no compact attempt to protect — the next probe should be free to
+ * dispatch. `failed` is not open either, by the same argument: a failure is a
+ * reason to try again, not a reason to stay quiet.
+ */
+/**
+ * The answer to "is a compact attempt outstanding for this session?".
+ *
+ * `none` and `unresolvable` must not be the same value. The caller uses
+ * `none` to ADMIT a dispatch; `unresolvable` means the question could
+ * not be asked, and a caller that admits on "could not ask" has a gate
+ * that reads a string rather than the artifact it names.
+ */
+export type OpenDispatchRunRead = {
+    readonly kind: 'open';
+    readonly runId: string;
+    readonly stage: 'armed' | 'compacting';
+    readonly triggerRatio: number;
+} | {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'unresolvable';
+    readonly reason: string;
+};
+export declare function readOpenDispatchRun(input: {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+}): OpenDispatchRunRead;
 /**
  * Slice 2026-08-01-compact-lifecycle (Task 5): the local transition
  * builder. Carries `runId`, `triggerRatio` and `redLine` forward from
@@ -132,6 +191,18 @@ export declare function summarizeLifecycleError(error: unknown): string;
  * `afterRatio` to append the "observed compaction point" row that makes the
  * intent-vs-observed gap readable after a real session. The return value is
  * telemetry only — callers that ignore it are unaffected.
+ *
+ * `lifecycleWritten` (repair R6) makes the returned record honest about
+ * whether the RUN actually moved. Before it, a failed write still returned
+ * the full envelope, so a store that could not be written reported a settle
+ * on every probe, forever: the run stayed `armed`, the next probe found it
+ * open again, and each one added another "observed compaction point" row —
+ * an unbounded append driven by a write that never happened. A failed write
+ * is not an absent run (the facts are real and stay true, so the caller may
+ * still record the measurement), but it is also not a settled one. This is
+ * the same field `settleOpenLifecycleRunOnCompactEvent` carries, for the
+ * same reason, so the two settle paths no longer disagree about what a write
+ * failure means.
  */
 export declare function settleOpenLifecycleRun(input: {
     readonly projectRoot: string;
@@ -140,10 +211,14 @@ export declare function settleOpenLifecycleRun(input: {
     readonly source: string;
     readonly autoFireThreshold: number;
     readonly onLifecycleStage?: ((stage: CompactLifecycleStage, record: CompactLifecycleRecord) => void) | undefined;
+    /** Failure injection for the write below — the seam `CompactLifecyclePublisher` already takes. */
+    readonly failLifecycleWrite?: boolean | undefined;
 }): {
     readonly runId: string;
     readonly triggerRatio: number;
     readonly afterRatio: number;
+    /** `false` when the `completed` write threw, so the run is STILL open. */
+    readonly lifecycleWritten: boolean;
 } | null;
 /**
  * rid `2026-09-13-compact-event-settle`: close out an open compact run because

package/dist/services/code/auto-compact-lifecycle.js

@@ -13,6 +13,7 @@
  */
 import { readCompactLifecycle, writeCompactLifecycle } from '../compact-statusline/compact-lifecycle-store.js';
 import { AUTO_COMPACT_RED_LINE_RATIO } from '../context/auto-compact-types.js';
+import { tryGetSessionDir } from '../session/getSessionDir.js';
 /**
  * PRD-002b slice 2 — extract the few cross-cutting magic numbers
  * that actually appear at runtime call sites in this orchestrator.
@@ -68,11 +69,18 @@ export function newCompactRunId(now) {
  * later. Wrapping that unbounded read here keeps the magic number out
  * of the settle path and makes the intent self-documenting.
  *
- * Returns `null` for any non-`valid` kind (missing / invalid /
- * stalled). Errors from the underlying read are swallowed — settling
- * is best-effort telemetry and must never bubble.
+ * The session id is resolved through `tryGetSessionDir` FIRST, so the
+ * guard's throw is answered before the store is entered and the failing
+ * branch is a value the caller must handle rather than a `catch` nobody
+ * reads. The residual `catch` is therefore unreachable for a bad id;
+ * anything that reaches it is a store fault, and a store fault is still
+ * not "there is no open run" — hence `unresolvable`, never `none`.
  */
 function readOpenCompactLifecycle(input) {
+    const resolved = tryGetSessionDir(input.projectRoot, input.sessionId);
+    if (!resolved.ok) {
+        return { kind: 'unresolvable', reason: resolved.reason };
+    }
     let out;
     try {
         out = readCompactLifecycle({
@@ -85,10 +93,21 @@ function readOpenCompactLifecycle(input) {
             staleAfterMs: Number.MAX_SAFE_INTEGER
         });
     }
-    catch {
-        return null;
+    catch (error) {
+        return { kind: 'unresolvable', reason: summarizeLifecycleError(error) };
     }
-    return out.kind === 'valid' ? out.record : null;
+    return out.kind === 'valid' ? { kind: 'found', record: out.record } : { kind: 'none' };
+}
+export function readOpenDispatchRun(input) {
+    const read = readOpenCompactLifecycle(input);
+    if (read.kind === 'unresolvable')
+        return read;
+    if (read.kind === 'none')
+        return { kind: 'none' };
+    const record = read.record;
+    if (record.stage !== 'armed' && record.stage !== 'compacting')
+        return { kind: 'none' };
+    return { kind: 'open', runId: record.runId, stage: record.stage, triggerRatio: record.triggerRatio };
 }
 /**
  * Slice 2026-08-01-compact-lifecycle (Task 5): the local transition
@@ -220,6 +239,18 @@ export function summarizeLifecycleError(error) {
  * `afterRatio` to append the "observed compaction point" row that makes the
  * intent-vs-observed gap readable after a real session. The return value is
  * telemetry only — callers that ignore it are unaffected.
+ *
+ * `lifecycleWritten` (repair R6) makes the returned record honest about
+ * whether the RUN actually moved. Before it, a failed write still returned
+ * the full envelope, so a store that could not be written reported a settle
+ * on every probe, forever: the run stayed `armed`, the next probe found it
+ * open again, and each one added another "observed compaction point" row —
+ * an unbounded append driven by a write that never happened. A failed write
+ * is not an absent run (the facts are real and stay true, so the caller may
+ * still record the measurement), but it is also not a settled one. This is
+ * the same field `settleOpenLifecycleRunOnCompactEvent` carries, for the
+ * same reason, so the two settle paths no longer disagree about what a write
+ * failure means.
  */
 export function settleOpenLifecycleRun(input) {
     // A `conservative-fallback` probe means no signal was available at
@@ -229,12 +260,17 @@ export function settleOpenLifecycleRun(input) {
         return null;
     if (input.measuredRatio >= input.autoFireThreshold)
         return null;
-    const prior = readOpenCompactLifecycle({
+    const openRead = readOpenCompactLifecycle({
         projectRoot: input.projectRoot,
         sessionId: input.sessionId
     });
-    if (prior === null)
+    // Both `none` and `unresolvable` mean "nothing to settle" HERE, and the
+    // collapse is legitimate on this path rather than a fail-open: settling
+    // ADMITS nothing. No record can exist under an id that names no session
+    // directory, so there is nothing this probe could have been about.
+    if (openRead.kind !== 'found')
         return null;
+    const prior = openRead.record;
     // Only a run that was actually dispatched can be completed by a
     // post-compact measurement. Both `compacting` (the in-band trigger is
     // satisfied) and `armed` (a trigger was registered and could fire at
@@ -253,6 +289,8 @@ export function settleOpenLifecycleRun(input) {
             ...(withAfterRatio ? { afterRatio: input.measuredRatio } : {})
         };
         try {
+            if (input.failLifecycleWrite)
+                throw new Error('lifecycle store unavailable');
             writeCompactLifecycle({
                 projectRoot: input.projectRoot,
                 sessionId: input.sessionId,
@@ -260,7 +298,10 @@ export function settleOpenLifecycleRun(input) {
             });
         }
         catch {
-            return;
+            // Best-effort telemetry, as everywhere in this file — but the failure is
+            // REPORTED to the caller as `lifecycleWritten: false` rather than folded
+            // into a record that reads as settled.
+            return false;
         }
         try {
             input.onLifecycleStage?.(stage, record);
@@ -268,12 +309,14 @@ export function settleOpenLifecycleRun(input) {
         catch {
             // Observer failures are not ours to propagate.
         }
+        return true;
     };
     // `verifying` = we hold a measurement and are checking it.
     emit('verifying', false);
-    // `completed` = the measurement confirms the drop; publish it.
-    emit('completed', true);
-    return { runId: prior.runId, triggerRatio: prior.triggerRatio, afterRatio: input.measuredRatio };
+    // `completed` = the measurement confirms the drop; publish it. This write
+    // is the one that closes the run, so it is the one that is reported.
+    const lifecycleWritten = emit('completed', true);
+    return { runId: prior.runId, triggerRatio: prior.triggerRatio, afterRatio: input.measuredRatio, lifecycleWritten };
 }
 /**
  * rid `2026-09-13-compact-event-settle`: close out an open compact run because
@@ -332,12 +375,16 @@ export function settleOpenLifecycleRun(input) {
  * two apart ends up telling the user a falsehood (see `compact-event-settle.ts`).
  */
 export function settleOpenLifecycleRunOnCompactEvent(input) {
-    const prior = readOpenCompactLifecycle({
+    const openRead = readOpenCompactLifecycle({
         projectRoot: input.projectRoot,
         sessionId: input.sessionId
     });
-    if (prior === null)
+    // Same collapse as `settleOpenLifecycleRun` above, for the same reason:
+    // an unresolvable id names no session directory, so no open run exists
+    // for this event to be about, and `null` here admits nothing.
+    if (openRead.kind !== 'found')
         return null;
+    const prior = openRead.record;
     if (prior.stage !== 'compacting' && prior.stage !== 'armed')
         return null;
     const afterRatio = input.measuredRatio !== null && input.measuredRatio < prior.triggerRatio ? input.measuredRatio : null;
@@ -410,12 +457,14 @@ export function settleOpenLifecycleRunOnCompactEvent(input) {
 export function fillEventSettledMeasurement(input) {
     if (input.source === 'conservative-fallback')
         return null;
-    const prior = readOpenCompactLifecycle({
+    const openRead = readOpenCompactLifecycle({
         projectRoot: input.projectRoot,
         sessionId: input.sessionId
     });
-    if (prior === null)
+    // Same collapse as the two settle paths above — `null` here admits nothing.
+    if (openRead.kind !== 'found')
         return null;
+    const prior = openRead.record;
     // Exactly one shape is owed a number: the one the EVENT path leaves behind.
     // `settleOpenLifecycleRun` never writes it (it always carries `afterRatio`),
     // and a `failed` run never dispatched, so it has no row to pair with.

package/dist/services/code/auto-compact-modes.d.ts

@@ -2,8 +2,8 @@
  * Slice 2026-07-28 — auto-compact mode table for 24h long-run awareness.
  *
  * The default `'standard'` mode preserves the v2.13.0 zero-pause contract
- * thresholds (preCompact=0.85, redLine=0.95). The `'partial'` mode fires
- * earlier for 24h long-run scenarios where the user has explicitly
+ * thresholds (autoFire=0.80, preCompact=0.85, redLine=0.95). The `'partial'`
+ * mode fires earlier for 24h long-run scenarios where the user has explicitly
  * opted into higher compaction cadence via `peaks session 24h-mode`.
  *
  * Slice 2026-07-29-context-evaluation-accuracy Part 22: a new
@@ -26,5 +26,16 @@ export declare const AUTO_COMPACT_THRESHOLDS: Readonly<Record<AutoCompactMode, {
 }>>;
 export declare function thresholdFor(mode: AutoCompactMode, kind: 'autoFire' | 'preCompact' | 'redLine'): number;
 export declare function isValidMode(value: string): value is AutoCompactMode;
+/**
+ * Human-readable form of a mode's threshold row.
+ *
+ * Derived from `AUTO_COMPACT_THRESHOLDS` rather than hand-written. Diagnosis
+ * 2026-09-15 (C1) found this string advertising `0.85/0.95` for `standard`
+ * while the table had auto-fired at `0.80` since slice
+ * 2026-07-29-context-evaluation-accuracy added the `autoFire` tier — the
+ * description named only the two thresholds that were left over from the
+ * v2.13.0 contract, and skipped the one that actually fires. Reading the
+ * numbers out of the table makes that drift unrepresentable.
+ */
 export declare function describeMode(mode: AutoCompactMode): string;
 export declare function isPartialModeEligible(contextPercent: number): boolean;

package/dist/services/code/auto-compact-modes.js

@@ -2,8 +2,8 @@
  * Slice 2026-07-28 — auto-compact mode table for 24h long-run awareness.
  *
  * The default `'standard'` mode preserves the v2.13.0 zero-pause contract
- * thresholds (preCompact=0.85, redLine=0.95). The `'partial'` mode fires
- * earlier for 24h long-run scenarios where the user has explicitly
+ * thresholds (autoFire=0.80, preCompact=0.85, redLine=0.95). The `'partial'`
+ * mode fires earlier for 24h long-run scenarios where the user has explicitly
  * opted into higher compaction cadence via `peaks session 24h-mode`.
  *
  * Slice 2026-07-29-context-evaluation-accuracy Part 22: a new
@@ -28,10 +28,26 @@ export function thresholdFor(mode, kind) {
 export function isValidMode(value) {
     return value === 'standard' || value === 'partial';
 }
+function pct(ratio) {
+    return `${(ratio * 100).toFixed(0)}%`;
+}
+/**
+ * Human-readable form of a mode's threshold row.
+ *
+ * Derived from `AUTO_COMPACT_THRESHOLDS` rather than hand-written. Diagnosis
+ * 2026-09-15 (C1) found this string advertising `0.85/0.95` for `standard`
+ * while the table had auto-fired at `0.80` since slice
+ * 2026-07-29-context-evaluation-accuracy added the `autoFire` tier — the
+ * description named only the two thresholds that were left over from the
+ * v2.13.0 contract, and skipped the one that actually fires. Reading the
+ * numbers out of the table makes that drift unrepresentable.
+ */
 export function describeMode(mode) {
+    const { autoFire, preCompact, redLine } = AUTO_COMPACT_THRESHOLDS[mode];
+    const bands = `auto-fire ${pct(autoFire)} / pre-compact ${pct(preCompact)} / red-line ${pct(redLine)}`;
     return mode === 'standard'
-        ? 'standard (0.85/0.95 — v2.13.0 zero-pause contract)'
-        : 'partial (0.70/0.85 — 24h long-run mode)';
+        ? `standard (${bands} — v2.13.0 zero-pause contract)`
+        : `partial (${bands} — 24h long-run mode)`;
 }
 export function isPartialModeEligible(contextPercent) {
     return contextPercent >= AUTO_COMPACT_THRESHOLDS.partial.preCompact;