peaks-loop 4.1.3 → 4.1.4

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

@@ -1,688 +1,208 @@
 /**
+ * Drives the whole compaction of a session's context.
  *
- * knows the current plan, open questions, recent decisions, in-flight
- * batches, todo state, git status, and active skills. That context is
- * strictly more valuable than what `/compact` can synthesize from raw
- * conversation history — so peaks-loop drives the entire compaction:
+ * peaks-loop knows the current plan, open questions, recent decisions, in-flight
+ * batches, todo state, git status, and active skills. That context is strictly more
+ * valuable than what `/compact` can synthesise from raw conversation history — so
+ * peaks-loop drives the entire compaction:
  *
- *   1. Read current context % (via IDE adapter's `readContextPercent`).
- *   2. If ratio ≥ 0.95 (RED LINE): peaks-loop ASKS the harness to
- *      compact and reports that it is waiting. It does NOT block
- *      sub-agent dispatch (slice
- *      the *decision*, the harness owns the *capability*, and peaks-loop
- *      has no way to compact a running session itself — so a "gate"
- *      here gated nothing and deadlocked the runner at the worst
- *      moment. If the ratio keeps rising and the harness has not
- *      compacted, the honest move is to say so and hand control back.
- *   3. If 0.85 ≤ ratio < 0.95 (pre-compact zone): peaks-loop prepares
- *      the convergence toolkit (checkpoint + auto-decisions log +
- *      IDE-dispatch handle) and surfaces it to the LLM. The LLM
- *      DECIDES when to fire `peaks code auto-compact`;
- *      peaks-loop does NOT auto-fire. The toolkit is ready so the
- *      LLM doesn't lose context to a last-second `/compact` panic.
- *   4. If ratio < 0.85: skip — return a one-line info row.
+ *   1. Read the current context % (via the IDE adapter's `readContextPercent`).
+ *   2. If the ratio ≥ the mode's red line: peaks-loop ASKS the harness to compact and
+ *      reports that it is waiting. It does NOT block sub-agent dispatch — the harness
+ *      owns the *capability*, peaks-loop only owns the *decision*, and peaks-loop has
+ *      no way to compact a running session itself, so a "gate" here gated nothing and
+ *      deadlocked the runner at the worst moment. If the ratio keeps rising and the
+ *      harness has not compacted, the honest move is to say so and hand control back.
+ *   3. If the ratio ≥ the mode's auto-fire threshold: peaks-loop prepares the
+ *      convergence toolkit (checkpoint + auto-decisions log + IDE-dispatch handle) and
+ *      fires it without LLM confirmation.
+ *   4. Below that: skip — return a one-line info row.
  *
- * Why two tiers (vs. one): the LLM uses the 0.85–0.95 zone for
- * intelligent convergence — wait for in-flight sub-agents, finish
- * the current todo row, persist a checkpoint, then compact. At 0.95
- * peaks-loop stops negotiating and requests the compact outright. Net
- * effect: the LLM-runner keeps working at any ratio without human
- * intervention, and without a gate it cannot satisfy.
+ * The tiers exist so the ratio is never left to drift: peaks-loop preempts at the
+ * auto-fire threshold, and the LLM is not asked to guess when to compact.
+ *
+ * This file owns the run: one probe, one decision, one attempt. The decision table
+ * lives in `auto-compact-decision.js`, the artifacts in `auto-compact-artifacts.js`,
+ * and the envelopes in `auto-compact-envelopes.js`.
  */
-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 { thresholdFor } from './auto-compact-modes.js';
 import { resolveAutoCompactProfile } from '../mode/mode-status-service.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
- * effects (checkpoint + IDE dispatch) live in `runAutoCompact`. Two
- * tiers (standard mode; partial mode shifts both thresholds):
- *
- *   - ratio < preCompact → 'none' or 'soft-warn'
- *   - ratio ≥ preCompact → 'pre-compact' (async-friendly path)
- *   - ratio ≥ redLine    → 'red-line' (ask the harness; dispatch continues)
- *
- * Default `'standard'` (0.85/0.95). `'partial'` (0.70/0.85) is used
- * when 24h long-run mode is active or `--mode partial` is passed.
- */
-export function evaluateCompactTrigger(ratio, mode = 'standard') {
-    const autoFire = thresholdFor(mode, 'autoFire');
-    const preCompact = thresholdFor(mode, 'preCompact');
-    const redLine = thresholdFor(mode, 'redLine');
-    if (ratio < autoFire) {
-        return ratio < 0.5
-            ? { kind: 'none' }
-            : {
-                kind: 'soft-warn',
-                ratio,
-                message: `Context at ${(ratio * 100).toFixed(1)}%; below the ${(autoFire * 100).toFixed(0)}% auto-fire threshold (mode=${mode}).`
-            };
-    }
-    if (ratio >= redLine) {
-        // longer claims it blocks anything. It cannot: peaks-loop has no
-        // executor for a running session (no `/compact` the model may invoke, no
-        // hook-initiated compact, no `--compact` flag), so "refuse dispatch until
-        // ratio < 0.85" was a gate with no key — a constructive deadlock at the
-        // exact moment the runner most needed to keep working. What peaks-loop
-        // CAN do is ask the harness (whose own trigger is armed) and say so.
-        return {
-            kind: 'red-line',
-            ratio,
-            message: `Context at ${(ratio * 100).toFixed(1)}% ≥ ${(redLine * 100).toFixed(0)}% red line (mode=${mode}). peaks-loop has asked the harness to compact and is WAITING for it — sub-agent dispatch is NOT blocked; carry on and re-probe with \`peaks code context-now\`.`
-        };
-    }
-    if (ratio < preCompact) {
-        // Part 22: auto-fire zone (0.80 ≤ ratio < 0.85). peaks-loop
-        // preempts and runs `peaks code auto-compact` itself
-        // without LLM involvement. The LLM is not asked to "decide";
-        // the toolkit is applied synchronously. Closes the
-        // LLM-misjudges-context window that previously let the
-        // ratio drift to 0.95 before the auto-fire kicked in.
-        return {
-            kind: 'auto-fire',
-            ratio,
-            message: `Context at ${(ratio * 100).toFixed(1)}% in auto-fire zone (≥${(autoFire * 100).toFixed(0)}% / <${(preCompact * 100).toFixed(0)}%, mode=${mode}). peaks-loop will fire compact without LLM confirmation.`
-        };
-    }
-    // pre-compact zone (0.85 ≤ ratio < 0.95): kept for backward
-    // compat with operators who configured the higher threshold.
-    // In practice peaks-loop already auto-fired at the lower
-    // threshold; the pre-compact zone today is the "already fired"
-    // zone.
-    return {
-        kind: 'pre-compact',
-        ratio,
-        toolkitReady: true,
-        message: `Context at ${(ratio * 100).toFixed(1)}% in pre-compact zone (≥${(preCompact * 100).toFixed(0)}% / <${(redLine * 100).toFixed(0)}%, mode=${mode}). peaks-loop already fired the auto-compact pathway at the auto-fire threshold; the LLM does not need to act.`
-    };
-}
+import { fillEventSettledMeasurement, resolveDispatchedStage, settleOpenLifecycleRun } from './auto-compact-lifecycle.js';
+import { evaluateAutoCompactDecision } from './auto-compact-decision.js';
+import { appendCompactHistoryEvent } from './auto-compact-history.js';
+import { readOpenRunGate } from './auto-compact-dispatch-gate.js';
+import { dispatchAttempt, prepareCompactAttempt } from './auto-compact-attempt.js';
+import { compactResult, noSessionResult, skipResult } from './auto-compact-envelopes.js';
+export { evaluateCompactTrigger, evaluateAutoCompactDecision, buildConvergencePlan } from './auto-compact-decision.js';
+export { appendCompactHistoryEvent } from './auto-compact-history.js';
 /**
- * Decide whether to run the auto-compact flow. Pure function for the
- * decision; side effects (checkpoint + IDE dispatch) live in
- * `runAutoCompact` below. Zero human / zero LLM intervention:
- *
- *   - ratio < 0.85           → skip (LLM keeps working; no action)
- *   - 0.85 ≤ ratio < 0.95    → pre-compact; if in-flight batch
- *                                present, defer (D6.e); else dispatch
- *                                IDE compact asynchronously.
- *   - ratio ≥ 0.95           → red-line; ask the harness to compact
- *                                regardless of in-flight batch. Nothing is
- *                                gated — dispatch is NOT blocked (slice
- *                                peaks-loop cannot compact a running session,
- *                                so a "block" gated nothing and deadlocked the
- *                                runner).
+ * The below-threshold path still has work to do: a ratio that has fallen back under
+ * the auto-fire threshold is the real, measured proof that a previously-dispatched
+ * compact landed, so any run still open at `compacting` is settled here. Nothing is
+ * written when there is no open run, when the ratio is still high, or when the probe
+ * could not measure at all.
  */
-export function evaluateAutoCompactDecision(input) {
-    const trigger = evaluateCompactTrigger(input.ratio, input.mode ?? 'standard');
-    // Normalize both `inFlightBatch` and `inflightBatch` (boolean | probe)
-    // into a single `InFlightBatchProbe` shape. The probe reads
-    // `hasInFlightBatch`; the boolean reads truthiness.
-    const rawProbe = input.inFlightBatch ?? input.inflightBatch;
-    const probe = typeof rawProbe === 'boolean' ? { hasInFlightBatch: rawProbe } : rawProbe;
-    if (trigger.kind === 'none') {
-        return { shouldCompact: false, reason: 'below-threshold', trigger, action: 'ok' };
-    }
-    if (trigger.kind === 'soft-warn') {
-        return { shouldCompact: false, reason: 'below-threshold', trigger, action: 'soft-warn' };
-    }
-    if (trigger.kind === 'red-line') {
-        // Red line: ignore in-flight batch — the harness is asked NOW rather than
-        // waiting for the batch to drain. Not "synchronous dispatch": peaks-loop
-        // has no synchronous compact to run, it can only request one and report
-        // that it is waiting.
-        return { shouldCompact: true, reason: 'red-line', trigger, action: 'red-line' };
-    }
-    // pre-compact zone (0.85 ≤ ratio < 0.95): honor D6.e in-flight deferral.
-    if (probe?.hasInFlightBatch === true) {
-        return { shouldCompact: false, reason: 'in-flight-batch', trigger, action: 'defer' };
-    }
-    if (input.force) {
-        return { shouldCompact: true, reason: 'pre-compact', trigger, action: 'auto-compact-now' };
-    }
-    // is the ONLY signal available on Mac Claude Code (no env-var, no statusline
-    // poll). The gate above already returns shouldCompact: true at ratio ≥ 0.85,
-    // but this forward-compat carve-out makes the source-aware rule explicit so
-    // any future source-aware downgrading cannot silently re-introduce the
-    // Mac auto-compact silent-failure mode without an audit. No higher-priority
-    // source is present (`claude-code-env` would have been P1, `statusline-poll`
-    // P2, `user-overridden` P4) — Mac's only signal is `transcript-estimate`.
-    if (input.source === 'transcript-estimate' && input.ratio >= AUTO_COMPACT_PRE_COMPACT_RATIO)
-        return { shouldCompact: true, reason: 'pre-compact', trigger, action: 'auto-compact-now' };
-    // Default: peaks-loop drives pre-compact autonomously.
-    return { shouldCompact: true, reason: 'pre-compact', trigger, action: 'auto-compact-now' };
-}
-/**
- * Build the convergence plan that D7's post-compact-detect will read
- * back. Includes the current plan, open questions, recent decisions,
- * todo state, and recent artifact paths — strictly more than what a
- * raw `/compact` would preserve.
- */
-export function buildConvergencePlan(input) {
-    return {
-        schemaVersion: 1,
-        sessionId: input.sessionId,
+function settleBelowThreshold(ctx) {
+    const { input, sessionId, probe, mode } = ctx;
+    const settleRead = settleOpenLifecycleRun({
         projectRoot: input.projectRoot,
-        createdAt: new Date().toISOString(),
-        ratio: input.ratio,
-        checkpointPath: input.checkpointPath,
-        nextActions: [...input.nextActions],
-        resumeHint: input.redLine === true
-            ? 'RED-LINE compact requested from the harness; work CONTINUES (nothing is blocked). Re-probe with `peaks code context-now`; if the ratio is still ≥ 0.95 and the harness has not compacted, report it and hand control back to the user.'
-            : 'post-compact-detect shouldAutoResume → resume pre-compact plan from checkpoint'
-    };
-}
-/**
- * Append a one-row convergence decision to the LLM-readable log.
- * The LLM reads this on the post-compact turn to pick up exactly
- * where it left off (vs. blindly trusting the IDE's compressed
- * transcript).
- */
-function appendAutoDecisionLog(input) {
-    // 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');
-    const row = [
-        '',
-        `## Auto-compact decision — ${input.plan.createdAt}`,
-        `- ratio: ${(input.plan.ratio * 100).toFixed(1)}%`,
-        `- checkpoint: ${input.plan.checkpointPath}`,
-        `- next-actions: ${input.plan.nextActions.join(' | ')}`,
-        `- resume-hint: ${input.plan.resumeHint}`,
-        ''
-    ].join('\n');
-    if (!existsSync(logPath)) {
-        writeFileSync(logPath, `# peaks-code auto-decisions log\n${row}`, 'utf8');
+        sessionId,
+        measuredRatio: probe.ratio,
+        source: probe.source,
+        autoFireThreshold: thresholdFor(mode, 'autoFire'),
+        onLifecycleStage: input.onLifecycleStage,
+        failLifecycleWrite: input.testHooks?.failLifecycleWrite
+    });
+    // A settle whose lifecycle write FAILED has not settled the run — the record still
+    // rests at `armed` / `compacting`, so the next probe finds the same run open and
+    // retries. Appending the "observed compaction point" row anyway would write one row
+    // per probe for a compaction the store never recorded: an unbounded append driven by
+    // a write that did not happen. Nothing is lost by deferring — `probe.ratio` is
+    // re-measured on every probe, so the retry carries a fresh number.
+    const settled = settleRead !== null && !settleRead.lifecycleWritten
+        ? null
+        : (settleRead ??
+            // The event path may have closed this run WITHOUT an honest post-compact
+            // number — the call above then 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
+            }));
+    // A dispatched compact demonstrably landed: append an `observed` row carrying the
+    // measured ratio, so `peaks compact history` can show "asked at R (intent) / landed
+    // by R' (observed)" once a real session has run. Without this row the intent has
+    // nothing to be compared against.
+    if (settled === null)
         return;
-    }
-    const existing = readFileSync(logPath, 'utf8');
-    writeFileSync(logPath, `${existing}${row}`, 'utf8');
-}
-/**
- * main-session compact intent so the main-session LLM picks it up on
- * its next turn and fires `/compact` in-band. Without this file the
- * orchestrator's "main-session compact" request is invisible to the
- * main Claude Code window (defeats the whole point of auto-compact
- * for the main context).
- *
- * The file is gitignored under `.peaks/_runtime/<sessionId>/txt/` and
- * is one-shot: the LLM should `mv` it to `.consumed` after firing
- * `/compact`. A re-run will overwrite.
- *
- * write survives, but nothing consumes the file, and its `nextAction` asks
- * for a `/compact` the model cannot invoke (the Skill tool exposes only
- * `/init` and `/security-review`; hooks can observe or veto, never initiate).
- * Retained deliberately for the sibling A2 slice, which owns harness-side
- * state re-injection. Not a capability peaks-loop has today.
- */
-function writeMainSessionCompactIntent(input) {
-    const dir = join(getSessionDir(input.projectRoot, input.sessionId), 'txt');
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const path = join(dir, 'auto-compact-pending.json');
-    const payload = {
-        schemaVersion: 1,
-        pending: true,
-        target: 'main',
-        requestedAt: input.now.toISOString(),
-        ratio: input.ratio,
-        redLine: input.redLine,
-        nextAction: 'next LLM turn MUST fire `/compact` then `mv .peaks/_runtime/<sid>/txt/auto-compact-pending.json .peaks/_runtime/<sid>/txt/auto-compact-pending.consumed.json`'
-    };
-    writeFileSync(path, JSON.stringify(payload, null, 2), 'utf8');
-}
-/**
- * Write a pre-compact checkpoint. The shape mirrors `peaks session
- * checkpoint` so D7's post-compact-detect picks it up unchanged.
- */
-function writePreCompactCheckpoint(input) {
-    // 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-';
-    const filename = `${prefix}${input.now.toISOString().replace(/[:.]/g, '-')}.json`;
-    const path = join(dir, filename);
-    const content = {
-        schemaVersion: 1,
-        reason: input.redLine === true ? 'pre-compact-red-line' : PRE_COMPACT_REASON,
-        sessionId: input.sessionId,
-        createdAt: input.now.toISOString(),
-        // D7 reads `mode`, `currentPlan`, `openQuestions`, `recentDecisions`
-        // out of this JSON. We seed empty arrays; the post-compact LLM
-        // rehydrates from the auto-decisions log + open question list.
-        mode: 'full-auto',
-        currentPlan: input.redLine === true
-            ? 'RED-LINE compact REQUESTED from the harness (not executed by peaks-loop); work continues'
-            : 'auto-compact in progress; resume from auto-decisions.md',
-        openQuestions: [],
-        recentDecisions: [],
-        recentArtifactPaths: [],
-        gitStatus: '',
-        skillsActive: ['peaks-code'],
-        todoState: []
-    };
-    writeFileSync(path, JSON.stringify(content, null, 2), 'utf8');
-    return path;
-}
-/**
- * the PRESENCE MODE, not the 24h state machine. Returns `'partial'`
- * when the mode is `24h`, otherwise `'standard'`. The CLI flag
- * `--mode` takes precedence (caller passes `input.mode` directly), so
- * this helper is only consulted when the flag is absent.
- */
-function resolveAutoCompactMode(projectRoot) {
-    return resolveAutoCompactProfile(projectRoot);
+    appendObservedCompactEvent({
+        projectRoot: input.projectRoot,
+        sessionId,
+        event: {
+            schemaVersion: 1,
+            kind: 'observed',
+            ts: new Date().toISOString(),
+            target: input.target ?? 'main',
+            mode,
+            ide: probe.ide,
+            pathway: 'post-compact-probe',
+            beforeRatio: settled.triggerRatio,
+            afterRatio: probe.ratio,
+            redLine: false,
+            ok: true,
+            checkpointPath: '',
+            dispatchMessage: `post-compact probe measured ratio ${(probe.ratio * 100).toFixed(1)}% (source=${probe.source}) after the compact dispatched at ${(settled.triggerRatio * 100).toFixed(1)}%`,
+            windowTokens: probe.capacityTokens ?? null,
+            windowSource: probe.capacitySource ?? null
+        }
+    });
 }
 /**
- * Execute the auto-compact flow.
- *
- * Steps (orchestration):
- *   1. Resolve session id.
- *   3. Evaluate trigger via `evaluateCompactTrigger`.
- *   4. If trigger.kind === 'none' / 'soft-warn' → return skip.
- *   5. If trigger.kind === 'pre-compact' AND in-flight batch → wait.
- *   6. If trigger.kind === 'pre-compact' → async dispatch (write
- *      checkpoint + IDE compact; orchestrator returns immediately).
- *   7. If trigger.kind === 'red-line' → dispatch the IDE compact, report
- *      that the harness has been asked and that dispatch continues.
- *
- * The caller (CLI or skill body) handles the actual return — D7's
- * post-compact-detect will pick up the checkpoint on the next turn. For
- * red-line, the caller keeps working; it re-probes and, if the ratio is
- * still rising with no compact from the harness, reports that instead of
- * stalling.
+ * Execute the auto-compact flow. The caller handles the return — the post-compact
+ * detector picks the checkpoint up on the next turn. For the red line the caller keeps
+ * working: it re-probes and, if the ratio is still rising with no compact from the
+ * harness, reports that instead of stalling.
  */
 export async function runAutoCompact(input) {
     const sessionId = input.sessionId ?? getSessionIdCanonical(input.projectRoot);
-    if (sessionId === null) {
-        return {
-            ok: false,
-            code: 'AUTO_COMPACT_NO_SESSION',
-            message: 'No active session; cannot run auto-compact. Run `peaks workspace init` first.',
-            nextActions: ['Run `peaks workspace init --change-id <id>` to bind a session']
-        };
+    if (sessionId === null)
+        return noSessionResult();
+    const mode = input.mode ?? resolveAutoCompactProfile(input.projectRoot);
+    const ctx = await openRun(input, sessionId, mode);
+    if (!ctx.decision.shouldCompact) {
+        settleBelowThreshold(ctx);
+        return skipResult(ctx);
+    }
+    const armed = readOpenRunGate(ctx);
+    if (armed !== null)
+        return armed;
+    const attempt = prepareCompactAttempt(ctx);
+    if (!attempt.ok)
+        return attempt.envelope;
+    const { lifecycle, checkpointPath, plan } = attempt;
+    const dispatched = await dispatchAttempt({ ctx, lifecycle, checkpointPath, plan });
+    if (!dispatched.ok)
+        return dispatched.envelope;
+    // The stage is chosen from what the dispatch ACTUALLY did, never from the hope that it
+    // compacted. `ide-native` on claude-code only installs a PreToolUse hook that fires at
+    // the red line — below that nothing is in flight and the honest stage is `armed`.
+    // Writing `compacting` there published a heartbeat that would never arrive, which is
+    // exactly what pinned the statusline at `stalled` for 92 minutes in the field. A
+    // dispatcher that returns `ok: false` compacted nothing either, so it is recorded as a
+    // failure at `compacting` rather than left looking in progress.
+    if (dispatched.dispatch.ok) {
+        lifecycle.advance(resolveDispatchedStage({ pathway: dispatched.dispatch.pathway, ratio: ctx.probe.ratio }));
     }
-    // presence MODE ('24h' → 'partial'); 'standard' preserves the
-    // v2.13.0 zero-pause contract.
-    const mode = input.mode ?? resolveAutoCompactMode(input.projectRoot);
+    else {
+        lifecycle.fail(new Error(dispatched.dispatch.message), 'compacting');
+    }
+    appendDispatchHistory(ctx, checkpointPath, dispatched.dispatch, dispatched.target);
+    return compactResult(ctx, {
+        checkpointPath,
+        plan,
+        target: dispatched.target,
+        dispatch: dispatched.dispatch
+    });
+}
+/** One probe, one window sync, one decision — the state every phase below reads. */
+async function openRun(input, sessionId, mode) {
     const { readContextPercent, syncHarnessWindowForProject } = await import('../context/auto-compact-reader.js');
-    const outerSessionId = resolveOuterSessionId(input.projectRoot, sessionId, input.env ?? process.env);
     const probe = readContextPercent({
         projectRoot: input.projectRoot,
         sessionId,
-        outerSessionId,
+        outerSessionId: resolveOuterSessionId(input.projectRoot, sessionId, input.env ?? process.env),
         env: input.env
     });
-    // denominator this probe divided by into the harness's own machine-local
-    // settings, so "peaks-loop's 85%" and "the harness's trigger" are the same
-    // point on one scale. Idempotent — an unchanged value performs no write, so
-    // a hook firing this on every Bash call cannot churn the file.
+    // The probe's denominator is materialized into the harness's own machine-local
+    // settings, so "peaks-loop's 85%" and "the harness's trigger" are the same point on one
+    // scale. Idempotent — an unchanged value performs no write. The project root is
+    // promoted to the git root first (`--project .` is what the PreToolUse hook passes):
+    // the harness's settings live at the project root, and the envelope must report an
+    // absolute path for the write it claims to have made. Fail-open.
     const harnessWindow = syncHarnessWindowForProject({
-        // Promoted to the git root first (`--project .` is what the PreToolUse
-        // hook passes): the harness's settings live at the project root, and the
-        // envelope must report an absolute path for the write it claims to have
-        // made. Fail-open — `resolveCanonicalProjectRoot` returns its input when
-        // nothing resolves.
         projectRoot: resolveCanonicalProjectRoot(input.projectRoot),
         env: input.env,
         tokens: probe.capacityTokens ?? null
     });
     const decision = evaluateAutoCompactDecision({
         ratio: probe.ratio,
-        // Slice 4.0.8 (D4d): production `inFlightBatch` MUST come from
-        // the graph probe (see `workflow-inflight-probe.ts`). The
-        // legacy boolean is preserved as a TEST-ONLY seam: when
-        // `probeInflightBatch` is supplied, we call it and pass the
-        // result as a `InFlightBatchProbe` so the pure decision function
-        // sees a graph-backed value. When only the boolean is
-        // supplied, we treat it as the test seam (the CLI gates it
-        // behind `PEAKS_TEST_SEAM === '1'`).
+        // Production `inFlightBatch` MUST come from the graph probe. The legacy boolean is
+        // preserved as a TEST-ONLY seam: when `probeInflightBatch` is supplied we call it and
+        // pass an `InFlightBatchProbe`, so the pure decision sees a graph-backed value. The
+        // CLI gates the boolean behind `PEAKS_TEST_SEAM === '1'`.
         inFlightBatch: input.probeInflightBatch !== undefined
             ? { hasInFlightBatch: input.probeInflightBatch() }
             : input.inFlightBatch,
         force: input.force,
         bypassRedLine: input.bypassRedLine,
         mode,
-        // tag through so `evaluateAutoCompactDecision` can apply the
-        // source-aware carve-out for Mac's `transcript-estimate` signal.
+        // Tagged through so the decision can apply the source-aware carve-out for Mac's
+        // `transcript-estimate` signal.
         source: probe.source
     });
-    if (!decision.shouldCompact) {
-        // adapter's `postCompactDetectCommand`. A ratio that has fallen
-        // back below the auto-fire threshold is the real, measured proof
-        // that a previously-dispatched compact landed — so settle any run
-        // 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 settleRead = settleOpenLifecycleRun({
-            projectRoot: input.projectRoot,
-            sessionId,
-            measuredRatio: probe.ratio,
-            source: probe.source,
-            autoFireThreshold: thresholdFor(mode, 'autoFire'),
-            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 ??
-                // 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
-                }));
-        // dispatched compact demonstrably landed. Append an `observed` row
-        // carrying the measured ratio, so `peaks compact history` can show
-        // "asked at R (intent) / landed by R' (observed)" once a real session has
-        // run. Without this row the intent has nothing to be compared against.
-        if (settled !== null) {
-            appendObservedCompactEvent({
-                projectRoot: input.projectRoot,
-                sessionId,
-                event: {
-                    schemaVersion: 1,
-                    kind: 'observed',
-                    ts: new Date().toISOString(),
-                    target: input.target ?? 'main',
-                    mode,
-                    ide: probe.ide,
-                    pathway: 'post-compact-probe',
-                    beforeRatio: settled.triggerRatio,
-                    afterRatio: probe.ratio,
-                    redLine: false,
-                    ok: true,
-                    checkpointPath: '',
-                    dispatchMessage: `post-compact probe measured ratio ${(probe.ratio * 100).toFixed(1)}% (source=${probe.source}) after the compact dispatched at ${(settled.triggerRatio * 100).toFixed(1)}%`,
-                    windowTokens: probe.capacityTokens ?? null,
-                    windowSource: probe.capacitySource ?? null
-                }
-            });
-        }
-        return {
-            ok: true,
-            code: decision.reason === 'in-flight-batch' ? 'AUTO_COMPACT_WAIT' : 'AUTO_COMPACT_SKIP',
-            message: `${decision.trigger.kind === 'soft-warn'
-                ? decision.trigger.message
-                : decision.reason === 'in-flight-batch'
-                    ? `In-flight batch detected; deferring pre-compact (ratio=${(probe.ratio * 100).toFixed(1)}%); next probe will re-evaluate.`
-                    : `Context at ${(probe.ratio * 100).toFixed(1)}%; below the ${(thresholdFor(mode, 'autoFire') * 100).toFixed(0)}% auto-fire threshold (mode=${mode}).`}${
-            // No compact was needed, but the sync may still have rewritten the
-            // harness's settings (the first probe of a project always does). The
-            // notice is appended ONLY for an actual write — the other actions'
-            // sentences would be noise on every quiet probe — PLUS the one refusal
-            // that is not quiet: a refused write that leaves peaks-loop's number and
-            // the harness's pinned window disagreeing. That is the moment the ratio
-            // stops describing the harness's trigger, so staying silent is exactly
-            // the failure 要告知 exists to prevent.
-            harnessWindow !== null &&
-                harnessWindow !== undefined &&
-                (harnessWindow.action === 'written' || harnessWindowSyncWarning(harnessWindow) !== null)
-                ? ` ${describeHarnessWindowSync(harnessWindow)}`
-                : ''}`,
-            data: {
-                sessionId,
-                ratio: probe.ratio,
-                source: probe.source,
-                decision: decision.reason === 'in-flight-batch' ? 'in-flight-batch' : 'below-threshold',
-                harnessWindow
-            }
-        };
-    }
-    const isRedLine = decision.reason === 'red-line';
-    const now = input.now ?? new Date();
-    // 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
-    // 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
-            }
-        };
-    }
-    // committed to compacting, so the run is `queued`. One runId per
-    // attempt; every later transition carries it forward.
-    const lifecycle = new CompactLifecyclePublisher({
-        projectRoot: input.projectRoot,
+    return {
+        input,
         sessionId,
-        runId: newCompactRunId(now),
-        triggerRatio: probe.ratio,
-        redLine: isRedLine,
-        onLifecycleStage: input.onLifecycleStage,
-        failLifecycleWrite: input.testHooks?.failLifecycleWrite
-    });
-    lifecycle.advance('queued');
-    let checkpointPath;
-    let plan;
-    let nextActions;
-    try {
-        // `preparing` covers checkpoint + convergence-plan + recovery writes.
-        lifecycle.advance('preparing');
-        if (input.testHooks?.failPreparing)
-            throw new Error('disk full while writing checkpoint');
-        checkpointPath = writePreCompactCheckpoint({
-            projectRoot: input.projectRoot,
-            sessionId,
-            now,
-            redLine: isRedLine
-        });
-        nextActions = isRedLine
-            ? [
-                'RED-LINE: harness compact requested — sub-agent dispatch is NOT blocked; keep working',
-                'Post-compact resume picks up the convergence plan from auto-decisions.md',
-                'Next `peaks code context-now` probe will confirm the ratio dropped; if it keeps climbing and the harness has not compacted, report that to the user and hand control back',
-                // also rewrites the harness's own settings, so it says so too. The
-                // user accepted that write on the condition 要告知 — a write only
-                // one of the two syncing commands reports is not a notice.
-                describeHarnessWindowSync(harnessWindow)
-            ]
-            : [
-                'Pre-compact dispatched — IDE compact in progress (async)',
-                'Post-compact resume picks up the convergence plan from auto-decisions.md',
-                'Next `peaks code auto-compact` probe will confirm ratio dropped below 0.85',
-                describeHarnessWindowSync(harnessWindow)
-            ];
-        plan = buildConvergencePlan({
-            sessionId,
-            projectRoot: input.projectRoot,
-            ratio: probe.ratio,
-            checkpointPath,
-            nextActions,
-            redLine: isRedLine
-        });
-        appendAutoDecisionLog({ projectRoot: input.projectRoot, sessionId, plan });
-    }
-    catch (error) {
-        lifecycle.fail(error);
-        // Preserve the original error contract: the caller gets the same
-        // `AUTO_COMPACT_DISPATCH_FAILED` envelope shape it already handles,
-        // not a thrown exception and not a widened type.
-        return {
-            ok: false,
-            code: 'AUTO_COMPACT_DISPATCH_FAILED',
-            message: `Auto-compact preparation failed before IDE dispatch: ${summarizeLifecycleError(error)}`,
-            data: {
-                sessionId,
-                ratio: probe.ratio,
-                source: probe.source,
-                target: input.target ?? 'main',
-                mode,
-                redLineRequested: isRedLine,
-                // Compatibility alias + its record. `redLineGated` shipped from
-                // 2.13.0 to 4.0.46, so a consumer outside this repo reads it and must
-                // not start receiving `undefined`; the record is what makes the
-                // deprecation visible to that consumer. See the type.
-                redLineGated: isRedLine,
-                deprecatedFields: DEPRECATED_ENVELOPE_FIELDS,
-                harnessWindow
-            }
-        };
-    }
-    const { dispatchIdeCompact } = await import('../context/auto-compact-dispatcher.js');
-    const target = input.target ?? 'main';
-    let dispatch;
-    try {
-        if (input.testHooks?.failCompacting)
-            throw new Error('IDE dispatch exploded');
-        // intent record so the next main-session LLM turn fires `/compact`
-        // in-band. Without this record the LLM has no signal that the
-        // orchestrator asked for compact; the dispatcher alone would have
-        // been a no-op against the main Claude Code window.
-        if (target === 'main') {
-            writeMainSessionCompactIntent({
-                projectRoot: input.projectRoot,
-                sessionId,
-                ratio: probe.ratio,
-                redLine: isRedLine,
-                now
-            });
-        }
-        dispatch = await dispatchIdeCompact({
-            projectRoot: input.projectRoot,
-            sessionId,
-            env: input.env,
-            target
-        });
-    }
-    catch (error) {
-        // `compacting` is the phase this failure died in — a phase label,
-        // not a claim that a compaction was in flight.
-        lifecycle.fail(error, 'compacting');
-        return {
-            ok: false,
-            code: 'AUTO_COMPACT_DISPATCH_FAILED',
-            message: `Auto-compact checkpoint written but IDE dispatch threw: ${summarizeLifecycleError(error)}`,
-            data: {
-                sessionId,
-                ratio: probe.ratio,
-                source: probe.source,
-                checkpointPath,
-                convergencePlan: plan,
-                target,
-                mode,
-                redLineRequested: isRedLine,
-                redLineGated: isRedLine,
-                deprecatedFields: DEPRECATED_ENVELOPE_FIELDS,
-                harnessWindow
-            }
-        };
-    }
-    // chosen from what the dispatch ACTUALLY did, never from the hope
-    // that it compacted. `ide-native` on claude-code only installs a
-    // PreToolUse hook that fires at ratio ≥ 0.95 — below that nothing is
-    // in flight and the honest stage is `armed` (see
-    // `resolveDispatchedStage`). Writing `compacting` there published a
-    // heartbeat that would never arrive, which is exactly what pinned
-    // the statusline at `stalled` for 92 minutes in the field.
-    if (dispatch.ok) {
-        lifecycle.advance(resolveDispatchedStage({ pathway: dispatch.pathway, ratio: probe.ratio }));
-    }
-    else {
-        // A dispatcher that returns `ok: false` did not compact anything —
-        // record that as a failure at `compacting` rather than leaving the
-        // run looking like it is still in progress.
-        lifecycle.fail(new Error(dispatch.message), 'compacting');
-    }
-    // event so the new 'peaks compact history' CLI and the
-    // 'peaks statusline compact' indicator have a record. The
-    // append is best-effort: a write failure must NOT block the
-    // compact return envelope.
+        mode,
+        probe,
+        harnessWindow,
+        decision,
+        isRedLine: decision.reason === 'red-line',
+        now: input.now ?? new Date()
+    };
+}
+/**
+ * Append the dispatch row the history CLI and the statusline indicator read. Best
+ * effort: a write failure must NOT block the compact return.
+ */
+function appendDispatchHistory(ctx, checkpointPath, dispatch, target) {
+    const { input, sessionId, probe, mode, isRedLine, now } = ctx;
     try {
         appendCompactHistoryEvent({
             projectRoot: input.projectRoot,
@@ -710,46 +230,8 @@ export async function runAutoCompact(input) {
     catch {
         /* best-effort; do not fail the compact return */
     }
-    return {
-        ok: dispatch.ok,
-        code: dispatch.ok
-            ? isRedLine
-                ? 'AUTO_COMPACT_RED_LINE'
-                : 'AUTO_COMPACT_DISPATCHED'
-            : 'AUTO_COMPACT_DISPATCH_FAILED',
-        message: dispatch.ok
-            ? isRedLine
-                ? `RED-LINE: harness compact REQUESTED (${dispatch.ide} / ${dispatch.pathway} / target=${target} / mode=${mode} — ${describeMode(mode)}); checkpoint at ${checkpointPath}. Sub-agent dispatch is NOT blocked — keep working and re-probe with \`peaks code context-now\`.`
-                : `Auto-compact dispatched (${dispatch.ide} / ${dispatch.pathway} / target=${target} / mode=${mode} — ${describeMode(mode)}); checkpoint at ${checkpointPath}.`
-            : `Auto-compact checkpoint written but IDE dispatch failed: ${dispatch.message}`,
-        data: {
-            sessionId,
-            ratio: probe.ratio,
-            source: probe.source,
-            checkpointPath,
-            convergencePlan: plan,
-            dispatch,
-            target,
-            mode,
-            redLineRequested: isRedLine,
-            redLineGated: isRedLine,
-            deprecatedFields: DEPRECATED_ENVELOPE_FIELDS,
-            harnessWindow
-        }
-    };
 }
-export function appendCompactHistoryEvent(input) {
-    const dir = getSessionDir(input.projectRoot, input.sessionId);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const path = join(dir, 'compact-history.jsonl');
-    appendFileSync(path, JSON.stringify(input.event) + '\n', 'utf8');
-}
-/**
- * Best-effort variant for the post-compact measurement row. Telemetry must
- * never change the probe's return envelope, so an append failure here is
- * swallowed — same discipline as the dispatch-path append.
- */
+/** Best-effort variant for the post-compact measurement row. Telemetry must never change the probe's return envelope. */
 function appendObservedCompactEvent(input) {
     try {
         appendCompactHistoryEvent(input);
@@ -758,6 +240,3 @@ function appendObservedCompactEvent(input) {
         /* best-effort; the probe result is already settled */
     }
 }
-// Keep dirname import live for symmetry with sibling services that
-// use it for path joins; tree-shaking removes it in builds.
-void dirname;