peaks-loop 4.0.48 → 4.0.50

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

@@ -36,13 +36,14 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { getSessionIdCanonical } from '../session/session-manager.js';
+import { getSessionDir } from '../session/getSessionDir.js';
 import { resolveOuterSessionId } from '../session/binding-status-service.js';
 import { resolveCanonicalProjectRoot } from '../config/config-service.js';
 import { describeHarnessWindowSync, harnessWindowSyncWarning } from '../context/harness-window-config.js';
 import { AUTO_COMPACT_PRE_COMPACT_RATIO, DEPRECATED_ENVELOPE_FIELDS } from '../context/auto-compact-types.js';
 import { describeMode, thresholdFor } from './auto-compact-modes.js';
 import { resolveAutoCompactProfile } from '../mode/mode-status-service.js';
-import { CompactLifecyclePublisher, fillEventSettledMeasurement, newCompactRunId, resolveDispatchedStage, settleOpenLifecycleRun, summarizeLifecycleError } from './auto-compact-lifecycle.js';
+import { CompactLifecyclePublisher, fillEventSettledMeasurement, newCompactRunId, readOpenDispatchRun, resolveDispatchedStage, settleOpenLifecycleRun, summarizeLifecycleError } from './auto-compact-lifecycle.js';
 const PRE_COMPACT_REASON = 'pre-compact-auto';
 /**
  * Map a context ratio to a `CompactTrigger` action. Pure; the side
@@ -195,7 +196,10 @@ export function buildConvergencePlan(input) {
  * transcript).
  */
 function appendAutoDecisionLog(input) {
-    const dir = join(input.projectRoot, '.peaks', '_runtime', input.sessionId, 'txt');
+    // Repair R6: same hand-rolled join as `writePreCompactCheckpoint`. All four
+    // session-scoped paths in this file now go through the axis builder; none
+    // composes the join itself, so none can resolve outside the project root.
+    const dir = join(getSessionDir(input.projectRoot, input.sessionId), 'txt');
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
     const logPath = join(dir, 'auto-decisions.md');
@@ -235,7 +239,7 @@ function appendAutoDecisionLog(input) {
  * state re-injection. Not a capability peaks-loop has today.
  */
 function writeMainSessionCompactIntent(input) {
-    const dir = join(input.projectRoot, '.peaks', '_runtime', input.sessionId, 'txt');
+    const dir = join(getSessionDir(input.projectRoot, input.sessionId), 'txt');
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
     const path = join(dir, 'auto-compact-pending.json');
@@ -255,7 +259,12 @@ function writeMainSessionCompactIntent(input) {
  * checkpoint` so D7's post-compact-detect picks it up unchanged.
  */
 function writePreCompactCheckpoint(input) {
-    const dir = join(input.projectRoot, '.peaks', '_runtime', input.sessionId, 'checkpoints');
+    // Repair R6: this used to hand-roll the session join, which is the one shape
+    // `getSessionDir`'s own header records as NOT covered by the guard — an
+    // unsafe id resolved outside the project root and the checkpoint was written
+    // there. The gate above now refuses an unresolvable id before this point, but
+    // `--force` outranks that gate, so this join has to hold on its own.
+    const dir = join(getSessionDir(input.projectRoot, input.sessionId), 'checkpoints');
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
     const prefix = input.redLine === true ? 'red-line-' : 'pre-compact-';
@@ -382,25 +391,37 @@ export async function runAutoCompact(input) {
         // still open at `compacting`. Nothing is written when there is no
         // open run, when the ratio is still high, or when the probe could
         // not measure at all.
-        const settled = settleOpenLifecycleRun({
+        const settleRead = settleOpenLifecycleRun({
             projectRoot: input.projectRoot,
             sessionId,
             measuredRatio: probe.ratio,
             source: probe.source,
             autoFireThreshold: thresholdFor(mode, 'autoFire'),
-            onLifecycleStage: input.onLifecycleStage
-        }) ??
-            // Repair R1 (`2026-09-13-compact-event-settle`): the HARNESS event may
-            // already have closed this run WITHOUT an honest post-compact number —
-            // in which case the call above finds nothing open, and without this the
-            // calibration pair stays blank for exactly the compactions the event path
-            // exists to witness. Fills the number the event owed.
-            fillEventSettledMeasurement({
-                projectRoot: input.projectRoot,
-                sessionId,
-                measuredRatio: probe.ratio,
-                source: probe.source
-            });
+            onLifecycleStage: input.onLifecycleStage,
+            failLifecycleWrite: input.testHooks?.failLifecycleWrite
+        });
+        // Repair R6 (AC3): a settle whose lifecycle write FAILED has not settled the
+        // run — the record is still resting at `armed` / `compacting`, so the next
+        // probe finds the same run open and settles it again. Appending the
+        // "observed compaction point" row anyway writes one row per probe for a
+        // compaction the lifecycle store never recorded: an unbounded append driven
+        // by a write that did not happen, and a history row whose paired lifecycle
+        // record does not exist. Nothing is lost by deferring the row — `probe.ratio`
+        // is re-measured on every probe, so the retry carries a fresh number.
+        const settled = settleRead !== null && !settleRead.lifecycleWritten
+            ? null
+            : (settleRead ??
+                // Repair R1 (`2026-09-13-compact-event-settle`): the HARNESS event may
+                // already have closed this run WITHOUT an honest post-compact number —
+                // in which case the call above finds nothing open, and without this the
+                // calibration pair stays blank for exactly the compactions the event path
+                // exists to witness. Fills the number the event owed.
+                fillEventSettledMeasurement({
+                    projectRoot: input.projectRoot,
+                    sessionId,
+                    measuredRatio: probe.ratio,
+                    source: probe.source
+                }));
         // Slice 2026-09-13-auto-compact-trigger-ownership (T4): a settle means a
         // dispatched compact demonstrably landed. Append an `observed` row
         // carrying the measured ratio, so `peaks compact history` can show
@@ -460,6 +481,85 @@ export async function runAutoCompact(input) {
     }
     const isRedLine = decision.reason === 'red-line';
     const now = input.now ?? new Date();
+    // rid `2026-09-14-compact-dispatch-backoff`: ONE dispatch per compact
+    // attempt.
+    //
+    // The decision above fires whenever the ratio is at or over the auto-fire
+    // threshold, and the ratio does not come back down on its own — nothing in
+    // peaks-loop can compact a running session, and the harness fires only at
+    // its own red line. So "shouldCompact" was true on every probe, forever: one
+    // real session's `compact-history.jsonl` holds 1075 dispatch rows, 444
+    // checkpoints and ZERO compactions over 15.5 h — and the file was still
+    // growing while this slice ran. Re-dispatching bought nothing, because the
+    // `ide-native` dispatch only installs a PreToolUse hook and installing it
+    // again is a documented no-op: 1074 of those 1075 rows say `already
+    // installed` in their own `dispatchMessage`. It produced rows, not
+    // compactions.
+    //
+    // The lifecycle store already knows whether an attempt is outstanding (see
+    // `readOpenDispatchRun` — `armed`/`compacting` = dispatched, `completed`/
+    // `failed` = over), so the gate needs no new state and no threshold: it is
+    // keyed on the STAGE of the open run, never on a ratio, which is why it
+    // survives any future realignment of the 0.65/0.70/0.85/0.95 table.
+    //
+    // What is NOT suppressed: the probe still measures and still reports. The
+    // envelope carries the LIVE ratio plus the ratio the open ask was made at,
+    // so "it crossed and it is still high, unanswered" stays legible on every
+    // turn — the difference between a quiet signal and a silenced one.
+    //
+    // `force` (the `--force` test seam, "force compact at any ratio") outranks
+    // the inference: an explicit instruction must not be silently reduced to a
+    // no-op, which would make the published flag a lie.
+    // Repair R6: `readOpenDispatchRun` answers in THREE states, not two. `none`
+    // admits the dispatch; `unresolvable` means the backoff's question could not
+    // be asked — the session id names no session directory, so no lifecycle
+    // record can exist under it and the gate used to read that as "nothing is
+    // outstanding". Measured on ONE directory before this: a legal sid found the
+    // open `armed` run and suppressed the dispatch; `./<legal sid>`, which joins
+    // to the identical path, returned `null` and dispatched. A gate that reads a
+    // string instead of the artifact the string names is the defect the whole
+    // id axis exists to close, so an unanswerable question is NOT an admit: the
+    // conservative direction is to leave the dispatch undone and say why.
+    const openRun = readOpenDispatchRun({ projectRoot: input.projectRoot, sessionId });
+    if (openRun.kind === 'unresolvable' && input.force !== true) {
+        return {
+            ok: true,
+            code: 'AUTO_COMPACT_UNRESOLVED_SESSION',
+            message: `Context at ${(probe.ratio * 100).toFixed(1)}%; a compact may be warranted, but this session's ` +
+                `directory could not be resolved (${openRun.reason}), so whether a compact was already dispatched ` +
+                `for this crossing cannot be answered. Not dispatching: an unanswered question is not a 'no'. ` +
+                `The session id comes from the active binding or from the caller.`,
+            data: {
+                sessionId,
+                ratio: probe.ratio,
+                source: probe.source,
+                decision: 'unresolved-session',
+                harnessWindow
+            }
+        };
+    }
+    if (openRun.kind === 'open' && input.force !== true) {
+        return {
+            ok: true,
+            code: 'AUTO_COMPACT_ALREADY_ARMED',
+            message: `Context at ${(probe.ratio * 100).toFixed(1)}% — still above the ` +
+                `${(thresholdFor(mode, 'autoFire') * 100).toFixed(0)}% auto-fire threshold (mode=${mode}); ` +
+                `a compact was already dispatched for this crossing at ${(openRun.triggerRatio * 100).toFixed(1)}% ` +
+                `(run ${openRun.runId}, resting at '${openRun.stage}') and nothing has compacted since. ` +
+                `Not dispatching again: the trigger is already registered, so a second dispatch would install the ` +
+                `same hook and add a checkpoint and a history row without adding a capability. ` +
+                `Re-probe with \`peaks code context-now\`.`,
+            data: {
+                sessionId,
+                ratio: probe.ratio,
+                source: probe.source,
+                decision: 'already-armed',
+                armedAtRatio: openRun.triggerRatio,
+                armedRunId: openRun.runId,
+                harnessWindow
+            }
+        };
+    }
     // Slice 2026-08-01-compact-lifecycle (Task 5): the decision has now
     // committed to compacting, so the run is `queued`. One runId per
     // attempt; every later transition carries it forward.
@@ -665,7 +765,7 @@ export async function runAutoCompact(input) {
     };
 }
 export function appendCompactHistoryEvent(input) {
-    const dir = join(input.projectRoot, '.peaks', '_runtime', input.sessionId);
+    const dir = getSessionDir(input.projectRoot, input.sessionId);
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
     const path = join(dir, 'compact-history.jsonl');

package/dist/services/code/compact-event-settle.d.ts

@@ -29,18 +29,30 @@ export type CompactSettleResult = {
     /** Present only when the harness reported one. */
     readonly trigger?: CompactTrigger;
     /**
-     * False when the run settled but the `observed` row could not be
-     * appended. The settlement is the load-bearing half and is never undone
-     * for this, but the two outcomes are not the same fact.
+     * Whether the `observed` row for this event is on disk. `false` means
+     * there is none, for one of two DIFFERENT reasons, told apart by
+     * `lifecycleWritten`:
+     *
+     *   - `lifecycleWritten: true` — the append was attempted and threw.
+     *   - `lifecycleWritten: false` — the append was deliberately not made,
+     *     because the settle it would describe is one the store never
+     *     recorded (see `lifecycleWritten`).
      */
     readonly historyWritten: boolean;
     /**
      * False when the lifecycle record could not be written. The run is then
-     * still open, so a later probe will settle it from its own measurement —
-     * but the `observed` row is appended anyway, because the harness's
-     * statement is evidence independent of that write. The two failures are
-     * reported separately rather than collapsed: a caller that sees only one
-     * of them cannot say which half of the settlement landed.
+     * still open, and this path does NOT append the `observed` row: the row
+     * would assert a settled measurement for a run the store still holds at
+     * `armed` / `compacting`, and each arrival would add another one. The
+     * row is deferred rather than lost — the run stays open, so the retry
+     * that does land owns the row and measures the ratio at that moment.
+     * This is repair R6's answer on the probe path
+     * (`auto-compact-orchestrator.ts`), applied here so the two settle
+     * paths agree.
+     *
+     * The two halves are reported separately rather than collapsed: a caller
+     * that sees only one of them cannot say which half of the settlement
+     * landed.
      */
     readonly lifecycleWritten: boolean;
 } | {

package/dist/services/code/compact-event-settle.js

@@ -161,6 +161,27 @@ export function settleCompactFromHarnessEvent(input) {
     if (settled === null) {
         return { settled: false, reason: 'nothing-to-settle' };
     }
+    if (!settled.lifecycleWritten) {
+        // Repair R9 (AC2): a settle whose lifecycle write FAILED has not settled the
+        // run. The record is still resting at `armed` / `compacting`, so the next
+        // arrival — another `PostCompact`, or a probe — finds the SAME run open and
+        // settles it again. Appending the row anyway writes one per arrival for a
+        // compaction the lifecycle store never recorded, each one carrying an
+        // `afterRatio` that reads as a settled measurement; and when the store does
+        // recover, the retry appends a SECOND row for the same compaction, which
+        // `computeWindowCalibration` is free to attach to a later dispatch pair.
+        // Nothing is lost by deferring: `probe.ratio` is re-measured at the retry,
+        // and the retry is the settlement this row is about.
+        return {
+            settled: true,
+            runId: settled.runId,
+            beforeRatio: settled.triggerRatio,
+            afterRatio: settled.afterRatio,
+            historyWritten: false,
+            lifecycleWritten: false,
+            ...(input.trigger !== undefined ? { trigger: input.trigger } : {})
+        };
+    }
     const event = {
         schemaVersion: 1,
         kind: 'observed',

package/dist/services/code/post-compact-detector.js

@@ -24,6 +24,7 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { getSkillPresence } from '../skills/skill-presence-service.js';
+import { isExpectedFsMiss } from '../../shared/fs-utils.js';
 import { emitObservabilityEvent } from '../observability/observability-service.js';
 import { isCodeMode } from './mode-gate.js';
 export const POST_COMPACT_RESUME_REASONS = [
@@ -65,12 +66,19 @@ function safeReadCheckpoint(absPath) {
         const content = mutable;
         return { path: absPath, mtime: stat.mtime, content };
     }
-    catch (err) { // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
-        if (err instanceof ReferenceError)
-            throw err; // surface module-load bugs
+    catch (err) {
+        // P1 site (S6, 2026-09-15). The TODO(g2) marker this replaces said the
+        // catch "narrows to IO errors only" — it did not. It rethrew the two JS
+        // error classes it happened to name and swallowed everything else,
+        // including the ReferenceError an ESM `require()` bug produces on the one
+        // platform this file's whole defence exists for. Corrupt JSON stays loud
+        // (we cannot read a checkpoint we cannot parse); every non-fs-miss error
+        // now propagates. See `isExpectedFsMiss`.
         if (err instanceof SyntaxError)
-            throw err; // surface parse bugs
-        return null; // only swallow IO errors
+            throw err;
+        if (!isExpectedFsMiss(err))
+            throw err;
+        return null;
     }
 }
 function readLatestTodayCheckpoint(runtimeDir, now) {
@@ -227,12 +235,13 @@ function readActiveSkillName(projectRoot) {
         const presence = getSkillPresence(projectRoot);
         return presence?.skill;
     }
-    catch (err) { // TODO(g2): legacy silent catch — now narrows to IO errors only (grace: 1 minor release, v2.14.0)
-        if (err instanceof ReferenceError)
-            throw err; // surface module-load bugs
-        if (err instanceof SyntaxError)
-            throw err; // surface parse bugs
-        return undefined; // only swallow IO errors
+    catch (err) {
+        // P1 site (S6, 2026-09-15) — same correction as `safeReadCheckpoint`
+        // above: a non-fs-miss failure reading the active skill is a bug, not an
+        // absence, and no longer resolves to `undefined` (i.e. to "no skill").
+        if (!isExpectedFsMiss(err))
+            throw err;
+        return undefined;
     }
 }
 /**

package/dist/services/code/step-08-gate.js

@@ -35,6 +35,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { readJobShapeDecision, JobShapeDecisionError, JOB_SHAPE_NOT_DECIDED } from './job-shape-decision.js';
+import { isExpectedFsMiss } from '../../shared/fs-utils.js';
 export const STEP_08_GATE_FILE_NAME = 'job-shape.json';
 export const STEP_08_PROGRESS_FILE_NAME = 'progress.json';
 /**
@@ -85,12 +86,16 @@ function readProgressIfAny(projectRoot, sessionId, jid) {
         }
         return null;
     }
-    catch (err) { // narrows to IO errors only — surface ReferenceError / SyntaxError so future module-load or parse bugs fail loudly (instead of silently masking progress.json corruption)
-        if (err instanceof ReferenceError)
-            throw err; // surface module-load bugs
+    catch (err) {
+        // P1 site (S6, 2026-09-15) — same correction as `readPromptFromLastPromptFile`
+        // below: corrupt progress.json stays loud, and a failure that is not an
+        // fs miss (module-load ReferenceError, TypeError from a bad field, …)
+        // propagates instead of reading as "no progress yet".
         if (err instanceof SyntaxError)
-            throw err; // surface parse bugs (corrupt progress.json)
-        return null; // only swallow IO errors (ENOENT, EACCES, …)
+            throw err;
+        if (!isExpectedFsMiss(err))
+            throw err;
+        return null;
     }
 }
 function readPromptFromLastPromptFile(projectRoot, sessionId) {
@@ -100,7 +105,17 @@ function readPromptFromLastPromptFile(projectRoot, sessionId) {
     try {
         return readFileSync(path, 'utf8');
     }
-    catch {
+    catch (err) {
+        // P1 site (S6, 2026-09-15). This catch was bare — it bound nothing and
+        // swallowed every error class. The sibling reads in this file had been
+        // narrowed; this one had not, so the ONE path that feeds the step-08
+        // backup regex was also the one that could not tell "no prompt file" from
+        // "the module is broken". On the platform this gate exists for, that is
+        // the difference between blocking a disavowal prompt and silently
+        // allowing it. Missing/unreadable text is an empty prompt; anything else
+        // propagates.
+        if (!isExpectedFsMiss(err))
+            throw err;
         return '';
     }
 }

package/dist/services/compact-statusline/compact-statusline-service.js

@@ -9,8 +9,8 @@
 //
 // Decision priority (explicit, no implicit fall-through):
 //   1. lifecycle missing  → fall back to legacy (pending → queued,
-//      recent history → completed WITHOUT an invented after-ratio,
-//      else none)
+//      a recent `observed` history row → completed WITHOUT an invented
+//      after-ratio, else none)
 //   2. lifecycle invalid  → 'invalid' (NEVER fall back to legacy
 //      — a corrupted lifecycle is not a green progress bar)
 //   3. lifecycle valid    → map stage to filledCells via the
@@ -37,9 +37,10 @@
 // ratios. After-ratio is only rendered when the lifecycle record
 // carries a real one; otherwise the bar shows a stable "no
 // measurement" hint.
-import { existsSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { getSessionDir } from '../session/getSessionDir.js';
 import { AUTO_COMPACT_RED_LINE_RATIO } from '../context/auto-compact-types.js';
+import { readCompactHistory } from '../compact-history/compact-history-service.js';
 import { readCompactLifecycle, } from './compact-lifecycle-store.js';
 /**
  * Concrete first-version stale timeout. Adjustable after real timing
@@ -58,7 +59,12 @@ const DEFAULT_STALE_AFTER_MS = 120_000;
  * to not flap on subsequent reads. Adjustable after real timing feedback.
  */
 export const COMPLETED_EXPIRY_MS = 10_000;
-/** Legacy mtime window for the "just compacted" indicator. */
+/**
+ * How recently the last history row must itself have been written for the
+ * legacy path to report it as "just compacted". Measured against the row's own
+ * `ts` — the fact — rather than the file's mtime, which is only a proxy for it
+ * and is also moved by rows that record no compaction (repair R9).
+ */
 const LEGACY_JUST_COMPACTED_WINDOW_MS = 30_000;
 // PRD-002b slice 2 — extract cell-table magic numbers (4/6/8) into named
 // consts so the no-magic-numbers lint rule stops flagging the typed
@@ -142,6 +148,7 @@ export function decideCompactStatusline(input) {
     // lifecycle.kind === 'missing' → fall back to legacy files.
     return decideLegacyFallback({
         projectRoot: input.projectRoot,
+        sessionId: input.sessionId,
         sessionDir,
         now: input.now,
     });
@@ -212,26 +219,53 @@ function decideLegacyFallback(input) {
             // fall through to history check
         }
     }
-    // Priority 2 within legacy: a recent history event within 30s.
-    if (existsSync(historyPath)) {
-        try {
-            const mtimeMs = statSync(historyPath).mtimeMs;
-            if (now - mtimeMs <= LEGACY_JUST_COMPACTED_WINDOW_MS) {
-                // CRITICAL: no invented after-ratio. The history event may
-                // carry a beforeRatio, but never a measured after-ratio;
-                // this is the legacy path and we honour the "no measurement"
-                // default.
-                return {
-                    kind: 'completed',
-                    filledCells: 8,
-                    detail: historyPath,
-                };
-            }
-        }
-        catch {
-            // fall through to idle
+    // Priority 2 within legacy: a history row TESTIFIES that a compaction was
+    // witnessed, recently enough to still be the one being reported.
+    //
+    // Repair R9 (AC4). This used to read the file's mtime — freshness taken as
+    // evidence that "a compact just landed". Freshness is evidence of neither:
+    // the same file takes a `dispatch` row every time peaks-loop ASKS for a
+    // compact, and an ask is an intent, not an outcome. One real session
+    // (2026-09-13, ~15.5 h) holds 1075 dispatch rows and ZERO compactions
+    // (`auto-compact-orchestrator.ts`), so a fresh file was the NORMAL state of a
+    // session in which nothing had compacted at all — and each of those asks
+    // painted this 8-cell "completed" bar.
+    //
+    // So the row's own testimony is read instead, through the same reader the CLI
+    // uses. Only `kind: 'observed'` means a compaction was witnessed (a row with
+    // no `kind` is a dispatch — every pre-`kind` row is one), and the row's `ts`
+    // is the moment compared, not the filesystem's.
+    //
+    // Repair R11. The testimony is looked for in EVERY row inside the window, not
+    // only in the last one. Reading the last row alone made the indicator depend
+    // on the ASK: a `dispatch` row lands on every probe, so an `observed` row
+    // stopped counting the moment peaks-loop asked again — `[observed, dispatch]`
+    // one second apart answered `none` for a compaction that had just been
+    // witnessed — i.e. it deleted the very indicator the mtime read had shown,
+    // the one the replacement was meant to keep honest. A `dispatch` row alone
+    // still testifies
+    // to nothing (the direction R9 closed): what is required is an `observed` row
+    // inside the window, wherever in the file it sits.
+    try {
+        // The reader answers `file-missing` / `empty` itself; the `catch` is for the
+        // read itself, which it does not guard.
+        const read = readCompactHistory({ projectRoot: input.projectRoot, sessionId: input.sessionId });
+        const witnessed = read.kind === 'ok' &&
+            read.events.some((row) => row.kind === 'observed' && now - Date.parse(row.ts) <= LEGACY_JUST_COMPACTED_WINDOW_MS);
+        if (witnessed) {
+            // CRITICAL: no invented after-ratio. The row may carry a measured
+            // afterRatio, but this is the legacy path and we honour the
+            // "no measurement" default.
+            return {
+                kind: 'completed',
+                filledCells: 8,
+                detail: historyPath,
+            };
         }
     }
+    catch {
+        // fall through to idle
+    }
     return { kind: 'none', filledCells: 0 };
 }
 /**

package/dist/services/config/config-safety.js

@@ -173,15 +173,17 @@ export function resolveCanonicalProjectRootStrict(startPath) {
     catch {
         throw new InvalidProjectRootError('non-existent', startPath);
     }
-    if (realStart !== start) {
-        // User passed a path through a symlink; reject as non-canonical
-        // for trust-boundary entry points.
-        throw new InvalidProjectRootError('non-canonical', startPath);
-    }
-    // Delegate to the existing canonicalization (git root → heuristic)
-    // AFTER the strict pre-checks pass.
-    const canonical = resolveCanonicalProjectRoot(startPath);
-    if (canonical === startPath || canonical === realStart) {
+    // Use the realpath form as the canonical input. macOS exposes
+    // `/var/folders/...` as a symlink to `/private/var/folders/...`, so any
+    // path returned by `os.tmpdir()` (and therefore any `mkdtempSync(...)`
+    // result) has `realStart !== start`. Rejecting that case as
+    // "non-canonical" would block the legitimate SessionStart hook path
+    // and the test fixtures under `tests/unit/hooks/`. The security
+    // property is preserved: `realpathSync` collapses any attacker-
+    // controlled symlink chain, so `realStart` IS the canonical form
+    // regardless of which prefix the caller used.
+    const canonical = resolveCanonicalProjectRoot(realStart);
+    if (canonical === realStart) {
         return canonical;
     }
     // Canonicalization moved the path (e.g. to a git root) — accept it

package/dist/services/context/auto-compact-types.d.ts

@@ -128,13 +128,31 @@ export type AutoCompactResult = {
     readonly nextActions: readonly string[];
 } | {
     readonly ok: true;
-    readonly code: 'AUTO_COMPACT_SKIP' | 'AUTO_COMPACT_WAIT';
+    readonly code: 'AUTO_COMPACT_SKIP' | 'AUTO_COMPACT_WAIT' | 'AUTO_COMPACT_ALREADY_ARMED' | 'AUTO_COMPACT_UNRESOLVED_SESSION';
     readonly message: string;
     readonly data: {
         readonly sessionId: string;
         readonly ratio: number;
         readonly source: string;
-        readonly decision: 'below-threshold' | 'in-flight-batch';
+        /**
+         * `unresolved-session` (repair R6): the session id named no session
+         * directory, so the compact backoff's question — "is an attempt already
+         * outstanding?" — could not be asked. It is NOT `already-armed` (no run
+         * was found; the record could not be read at all) and NOT an admit: the
+         * dispatch is left undone because an unanswerable question is not a
+         * "no", and admitting on one is how a gate ends up reading a string
+         * instead of the artifact the string names.
+         */
+        readonly decision: 'below-threshold' | 'in-flight-batch' | 'already-armed' | 'unresolved-session';
+        /**
+         * rid `2026-09-14-compact-dispatch-backoff`, `already-armed` only: the
+         * ratio the open run was dispatched at, and its id. `ratio` above is the
+         * LIVE reading — the pair is what keeps "it is still high" legible after
+         * the backoff drops the per-probe rows: the ask is at `armedAtRatio`, and
+         * the context is now at `ratio`, above it and not yet compacted.
+         */
+        readonly armedAtRatio?: number;
+        readonly armedRunId?: string;
         /**
          * Slice 2026-09-13-auto-compact-trigger-ownership: what syncing the
          * harness auto-compact window did on this probe. `null` = the active