peaks-loop 4.1.3 → 4.1.4

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

@@ -0,0 +1,135 @@
+/**
+ * The files one auto-compact run writes: checkpoint, intent and decision log.
+ *
+ * Split out of `auto-compact-orchestrator.ts` (file-size cap campaign). The
+ * orchestrator re-exports every name declared here, so existing importers keep
+ * using `./auto-compact-orchestrator.js` unchanged.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getSessionDir } from '../session/getSessionDir.js';
+import { describeHarnessWindowSync } from '../context/harness-window-config.js';
+/**
+ * What the caller is told to do next. The harness-window notice rides along because
+ * the run also rewrites the harness's own settings, so it says so too: the user
+ * accepted that write on the condition 要告知, and a write only one of the two
+ * syncing commands reports is not a notice.
+ */
+export function compactNextActions(isRedLine, harnessWindow) {
+    if (isRedLine) {
+        return [
+            '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',
+            describeHarnessWindowSync(harnessWindow)
+        ];
+    }
+    return [
+        '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)
+    ];
+}
+const PRE_COMPACT_REASON = 'pre-compact-auto';
+/**
+ * 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).
+ */
+export 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');
+        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.
+ */
+export 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.
+ */
+export 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;
+}

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

@@ -0,0 +1,46 @@
+/**
+ * The two side-effecting phases of a run: prepare the artifacts, then dispatch.
+ *
+ * Split out of `auto-compact-orchestrator.ts` (file-size cap campaign). The
+ * orchestrator re-exports every name declared here, so existing importers keep
+ * using `./auto-compact-orchestrator.js` unchanged.
+ */
+import { type AutoCompactResult, type CompactDispatchResult, type ConvergencePlan } from '../context/auto-compact-types.js';
+import type { CompactTarget } from '../context/auto-compact-dispatcher.js';
+import { CompactLifecyclePublisher } from './auto-compact-lifecycle.js';
+import type { CompactRun } from './auto-compact-run-types.js';
+export type PrepareOutcome = {
+    readonly ok: true;
+    readonly lifecycle: CompactLifecyclePublisher;
+    readonly checkpointPath: string;
+    readonly plan: ConvergencePlan;
+} | {
+    readonly ok: false;
+    readonly envelope: AutoCompactResult;
+};
+/**
+ * One runId per attempt, committed to compacting: the publisher is created at
+ * `queued` and every later transition carries the same id forward. `preparing`
+ * covers the checkpoint, the convergence plan and the decision-log write; a throw
+ * in any of them rests the record at `failedAt: 'preparing'`.
+ */
+export declare function prepareCompactAttempt(ctx: CompactRun): PrepareOutcome;
+export type DispatchOutcome = {
+    readonly ok: true;
+    readonly target: CompactTarget;
+    readonly dispatch: CompactDispatchResult;
+} | {
+    readonly ok: false;
+    readonly envelope: AutoCompactResult;
+};
+/**
+ * The IDE-dispatch phase. The intent record is written only for `main`: without it
+ * the main-session LLM has no signal that the orchestrator asked for compact, and
+ * the dispatcher alone would have been a no-op against the main Claude Code window.
+ */
+export declare function dispatchAttempt(args: {
+    readonly ctx: CompactRun;
+    readonly lifecycle: CompactLifecyclePublisher;
+    readonly checkpointPath: string;
+    readonly plan: ConvergencePlan;
+}): Promise<DispatchOutcome>;

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

@@ -0,0 +1,88 @@
+import { CompactLifecyclePublisher, newCompactRunId } from './auto-compact-lifecycle.js';
+import { appendAutoDecisionLog, compactNextActions, writeMainSessionCompactIntent, writePreCompactCheckpoint } from './auto-compact-artifacts.js';
+import { buildConvergencePlan } from './auto-compact-decision.js';
+import { dispatchFailureResult, prepareFailureResult } from './auto-compact-envelopes.js';
+/**
+ * One runId per attempt, committed to compacting: the publisher is created at
+ * `queued` and every later transition carries the same id forward. `preparing`
+ * covers the checkpoint, the convergence plan and the decision-log write; a throw
+ * in any of them rests the record at `failedAt: 'preparing'`.
+ */
+export function prepareCompactAttempt(ctx) {
+    const { input, sessionId, probe, harnessWindow, isRedLine, now } = ctx;
+    const lifecycle = new CompactLifecyclePublisher({
+        projectRoot: input.projectRoot,
+        sessionId,
+        runId: newCompactRunId(now),
+        triggerRatio: probe.ratio,
+        redLine: isRedLine,
+        onLifecycleStage: input.onLifecycleStage,
+        failLifecycleWrite: input.testHooks?.failLifecycleWrite
+    });
+    lifecycle.advance('queued');
+    try {
+        lifecycle.advance('preparing');
+        if (input.testHooks?.failPreparing)
+            throw new Error('disk full while writing checkpoint');
+        const checkpointPath = writePreCompactCheckpoint({
+            projectRoot: input.projectRoot,
+            sessionId,
+            now,
+            redLine: isRedLine
+        });
+        const plan = buildConvergencePlan({
+            sessionId,
+            projectRoot: input.projectRoot,
+            ratio: probe.ratio,
+            checkpointPath,
+            nextActions: compactNextActions(isRedLine, harnessWindow),
+            redLine: isRedLine
+        });
+        appendAutoDecisionLog({ projectRoot: input.projectRoot, sessionId, plan });
+        return { ok: true, lifecycle, checkpointPath, plan };
+    }
+    catch (error) {
+        lifecycle.fail(error);
+        return { ok: false, envelope: prepareFailureResult(ctx, error) };
+    }
+}
+/**
+ * The IDE-dispatch phase. The intent record is written only for `main`: without it
+ * the main-session LLM has no signal that the orchestrator asked for compact, and
+ * the dispatcher alone would have been a no-op against the main Claude Code window.
+ */
+export async function dispatchAttempt(args) {
+    const { ctx, lifecycle, checkpointPath, plan } = args;
+    const { input, sessionId, probe, isRedLine, now } = ctx;
+    const { dispatchIdeCompact } = await import('../context/auto-compact-dispatcher.js');
+    const target = input.target ?? 'main';
+    try {
+        if (input.testHooks?.failCompacting)
+            throw new Error('IDE dispatch exploded');
+        if (target === 'main') {
+            writeMainSessionCompactIntent({
+                projectRoot: input.projectRoot,
+                sessionId,
+                ratio: probe.ratio,
+                redLine: isRedLine,
+                now
+            });
+        }
+        const dispatch = await dispatchIdeCompact({
+            projectRoot: input.projectRoot,
+            sessionId,
+            env: input.env,
+            target
+        });
+        return { ok: true, target, dispatch };
+    }
+    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,
+            envelope: dispatchFailureResult(ctx, { checkpointPath, plan, target }, error)
+        };
+    }
+}

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

@@ -0,0 +1,74 @@
+/**
+ * The pure auto-compact decision surface: trigger, decision and plan.
+ *
+ * Split out of `auto-compact-orchestrator.ts` (file-size cap campaign). The
+ * orchestrator re-exports every name declared here, so existing importers keep
+ * using `./auto-compact-orchestrator.js` unchanged.
+ */
+import { type CompactTrigger, type ConvergencePlan, type InFlightBatchProbe } from '../context/auto-compact-types.js';
+import { type AutoCompactMode } from './auto-compact-modes.js';
+export declare function evaluateCompactTrigger(ratio: number, mode?: AutoCompactMode): CompactTrigger;
+/**
+ * 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).
+ */
+export declare function evaluateAutoCompactDecision(input: {
+    ratio: number;
+    /**
+     * Caller-provided in-flight batch signal. Accepts either a plain
+     * boolean (convenience / repro seam) or the full `InFlightBatchProbe`
+     * shape (production callers — graph-probe-backed). When the boolean
+     * form is `true`, the normalized probe carries
+     * `hasInFlightBatch: true`. Slice 4.0.8 hotfix.
+     */
+    inFlightBatch?: boolean | InFlightBatchProbe | undefined;
+    /**
+     * Legacy camelCase alias for `inFlightBatch`. Production repro
+     * inputs use `inflightBatch: true|false`; the orchestrator
+     * normalizes it to the same internal shape. Slice 4.0.8 hotfix.
+     */
+    inflightBatch?: boolean | InFlightBatchProbe | undefined;
+    force?: boolean | undefined;
+    /** Accepted and ignored — see `AutoCompactInput.bypassRedLine`. */
+    bypassRedLine?: boolean | undefined;
+    mode?: AutoCompactMode | undefined;
+    /**
+     * Source tag from `readContextPercent.source`. Optional — when absent, the
+     * function behaves exactly as pre-rid (ratio-only). Slice 2026-07-31-rid-
+     * mac-transcript-estimate-trigger uses this to carry forward an explicit
+     * carve-out for the Mac-only `transcript-estimate` signal.
+     */
+    source?: string | undefined;
+}): {
+    shouldCompact: boolean;
+    reason: 'below-threshold' | 'in-flight-batch' | 'pre-compact' | 'red-line';
+    trigger: CompactTrigger;
+    /** Typed verdict enum (RD §4 24h-mode contract). Slice 4.0.8 hotfix. */
+    action: 'ok' | 'soft-warn' | 'auto-compact-now' | 'red-line' | 'defer';
+};
+/**
+ * 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 declare function buildConvergencePlan(input: {
+    readonly sessionId: string;
+    readonly projectRoot: string;
+    readonly ratio: number;
+    readonly checkpointPath: string;
+    readonly nextActions: readonly string[];
+    readonly redLine?: boolean;
+}): ConvergencePlan;

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

@@ -0,0 +1,149 @@
+/**
+ * The pure auto-compact decision surface: trigger, decision and plan.
+ *
+ * Split out of `auto-compact-orchestrator.ts` (file-size cap campaign). The
+ * orchestrator re-exports every name declared here, so existing importers keep
+ * using `./auto-compact-orchestrator.js` unchanged.
+ */
+import { AUTO_COMPACT_PRE_COMPACT_RATIO } from '../context/auto-compact-types.js';
+import { thresholdFor } from './auto-compact-modes.js';
+/**
+ * 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.
+ */
+/** Below this ratio the probe is not even worth a soft warning. */
+const SOFT_WARN_RATIO_FLOOR = 0.5;
+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 < SOFT_WARN_RATIO_FLOOR
+            ? { 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.`
+    };
+}
+/**
+ * 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).
+ */
+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,
+        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'
+    };
+}

package/dist/services/code/auto-compact-dispatch-gate.d.ts

@@ -0,0 +1,36 @@
+import type { AutoCompactResult } from '../context/auto-compact-types.js';
+import type { CompactRun } from './auto-compact-run-types.js';
+/**
+ * The decision 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. 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 (`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.
+ *
+ * `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 answer it. Measured on ONE directory
+ * before this: a legal sid found the open `armed` run and suppressed the dispatch, while
+ * `./<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.
+ */
+export declare function readOpenRunGate(ctx: CompactRun): AutoCompactResult | null;

package/dist/services/code/auto-compact-dispatch-gate.js

@@ -0,0 +1,86 @@
+/**
+ * The dispatch back-off: whether a compact was already asked for this crossing.
+ *
+ * Split out of `auto-compact-orchestrator.ts` (file-size cap campaign). The
+ * orchestrator re-exports every name declared here, so existing importers keep
+ * using `./auto-compact-orchestrator.js` unchanged.
+ */
+import { readOpenDispatchRun } from './auto-compact-lifecycle.js';
+import { thresholdFor } from './auto-compact-modes.js';
+/**
+ * The decision 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. 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 (`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.
+ *
+ * `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 answer it. Measured on ONE directory
+ * before this: a legal sid found the open `armed` run and suppressed the dispatch, while
+ * `./<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.
+ */
+export function readOpenRunGate(ctx) {
+    const { input, sessionId, probe, mode, harnessWindow } = ctx;
+    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
+            }
+        };
+    }
+    return null;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * The result envelopes `runAutoCompact` can return.
+ *
+ * Split out of `auto-compact-orchestrator.ts` (file-size cap campaign). The
+ * orchestrator re-exports every name declared here, so existing importers keep
+ * using `./auto-compact-orchestrator.js` unchanged.
+ */
+import { type AutoCompactResult, type CompactDispatchResult, type ConvergencePlan } from '../context/auto-compact-types.js';
+import type { CompactTarget } from '../context/auto-compact-dispatcher.js';
+import type { CompactRun } from './auto-compact-run-types.js';
+/** No session is bound, so there is nothing to probe. */
+export declare function noSessionResult(): AutoCompactResult;
+/** The envelope for a probe that did not cross the auto-fire threshold. */
+export declare function skipResult(ctx: CompactRun): AutoCompactResult;
+/**
+ * The envelope for a throw during preparation. It preserves the original error
+ * contract: the caller gets the `AUTO_COMPACT_DISPATCH_FAILED` shape it already
+ * handles, not a thrown exception and not a widened type.
+ */
+export declare function prepareFailureResult(ctx: CompactRun, error: unknown): AutoCompactResult;
+/** The envelope for a throw or a refusal during the IDE dispatch. */
+export declare function dispatchFailureResult(ctx: CompactRun, attempt: {
+    readonly checkpointPath: string;
+    readonly plan: ConvergencePlan;
+    readonly target: CompactTarget;
+}, error: unknown): AutoCompactResult;
+/** The envelope for a run that reached the dispatch phase. */
+export declare function compactResult(ctx: CompactRun, attempt: {
+    readonly checkpointPath: string;
+    readonly plan: ConvergencePlan;
+    readonly target: CompactTarget;
+    readonly dispatch: CompactDispatchResult;
+}): AutoCompactResult;