peaks-loop 4.0.45 → 4.0.47

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

@@ -9,10 +9,15 @@
  * 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): synchronous gate — peaks-loop
- *      refuses sub-agent dispatch and forces IDE compact immediately.
- *      The LLM cannot opt out (compact red line — keeps the runner
- *      alive).
+ *   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
+ *      2026-09-13-auto-compact-trigger-ownership, T3): peaks-loop owns
+ *      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
@@ -24,18 +29,20 @@
  * 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
- * the window is gone; peaks-loop takes over synchronously. Net effect:
- * the LLM-runner keeps working with context < 95% without human
- * intervention.
+ * 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.
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { getSessionIdCanonical } from '../session/session-manager.js';
 import { resolveOuterSessionId } from '../session/binding-status-service.js';
-import { AUTO_COMPACT_PRE_COMPACT_RATIO } from '../context/auto-compact-types.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, newCompactRunId, settleOpenLifecycleRun, summarizeLifecycleError } from './auto-compact-lifecycle.js';
+import { CompactLifecyclePublisher, newCompactRunId, 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
@@ -44,7 +51,7 @@ const PRE_COMPACT_REASON = 'pre-compact-auto';
  *
  *   - ratio < preCompact → 'none' or 'soft-warn'
  *   - ratio ≥ preCompact → 'pre-compact' (async-friendly path)
- *   - ratio ≥ redLine    → 'red-line' (synchronous gate)
+ *   - ratio ≥ redLine    → 'red-line' (ask the harness; dispatch continues)
  *
  * Slice 2026-07-28 (rid-027): `mode` selects the threshold table.
  * Default `'standard'` (0.85/0.95). `'partial'` (0.70/0.85) is used
@@ -64,10 +71,17 @@ export function evaluateCompactTrigger(ratio, mode = 'standard') {
             };
     }
     if (ratio >= redLine) {
+        // Slice 2026-09-13-auto-compact-trigger-ownership (T3): the red line no
+        // 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}). Synchronous compact REQUIRED (LLM cannot opt out).`
+            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) {
@@ -104,8 +118,13 @@ export function evaluateCompactTrigger(ratio, mode = 'standard') {
  *   - 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; ALWAYS dispatch synchronously
- *                                regardless of in-flight batch.
+ *   - ratio ≥ 0.95           → red-line; ask the harness to compact
+ *                                regardless of in-flight batch. Nothing is
+ *                                gated — dispatch is NOT blocked (slice
+ *                                2026-09-13-auto-compact-trigger-ownership:
+ *                                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');
@@ -123,7 +142,10 @@ export function evaluateAutoCompactDecision(input) {
         return { shouldCompact: false, reason: 'below-threshold', trigger, action: 'soft-warn' };
     }
     if (trigger.kind === 'red-line') {
-        // Red line: ignore in-flight batch — synchronous dispatch wins.
+        // 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.
@@ -162,7 +184,7 @@ export function buildConvergencePlan(input) {
         checkpointPath: input.checkpointPath,
         nextActions: [...input.nextActions],
         resumeHint: input.redLine === true
-            ? 'RED-LINE compact: post-compact-detect must confirm ratio < 0.85 before resuming work.'
+            ? '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'
     };
 }
@@ -204,6 +226,13 @@ function appendAutoDecisionLog(input) {
  * 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.
+ *
+ * ZERO READERS as of slice 2026-09-13-auto-compact-trigger-ownership: the
+ * 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(input.projectRoot, '.peaks', '_runtime', input.sessionId, 'txt');
@@ -242,7 +271,7 @@ function writePreCompactCheckpoint(input) {
         // rehydrates from the auto-decisions log + open question list.
         mode: 'full-auto',
         currentPlan: input.redLine === true
-            ? 'RED-LINE compact just executed; confirm ratio < 0.85 before resuming work'
+            ? '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: [],
@@ -276,13 +305,14 @@ function resolveAutoCompactMode(projectRoot) {
  *   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' → synchronous gate: refuse
- *      sub-agent dispatch, dispatch IDE compact, mark `redLineGated`.
+ *   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 MUST block further tool calls until the
- * post-compact probe confirms ratio < 0.85.
+ * 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.
  */
 export async function runAutoCompact(input) {
     const sessionId = input.sessionId ?? getSessionIdCanonical(input.projectRoot);
@@ -300,7 +330,7 @@ export async function runAutoCompact(input) {
     // v2.13.0 zero-pause contract.
     const mode = input.mode ?? resolveAutoCompactMode(input.projectRoot);
     // Lazy import to avoid the AC-1 module depending on the orchestrator.
-    const { readContextPercent } = await import('../context/auto-compact-reader.js');
+    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,
@@ -308,6 +338,21 @@ export async function runAutoCompact(input) {
         outerSessionId,
         env: input.env
     });
+    // Slice 2026-09-13-auto-compact-trigger-ownership (T1 + T2): write the very
+    // 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.
+    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
@@ -337,7 +382,7 @@ 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.
-        settleOpenLifecycleRun({
+        const settled = settleOpenLifecycleRun({
             projectRoot: input.projectRoot,
             sessionId,
             measuredRatio: probe.ratio,
@@ -345,19 +390,60 @@ export async function runAutoCompact(input) {
             autoFireThreshold: thresholdFor(mode, 'autoFire'),
             onLifecycleStage: input.onLifecycleStage
         });
+        // 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
+        // "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'
+            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}).`,
+                    : `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'
+                decision: decision.reason === 'in-flight-batch' ? 'in-flight-batch' : 'below-threshold',
+                harnessWindow
             }
         };
     }
@@ -392,14 +478,20 @@ export async function runAutoCompact(input) {
         });
         nextActions = isRedLine
             ? [
-                'RED-LINE compact dispatched — further sub-agent dispatch BLOCKED until ratio < 0.85',
+                '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 auto-compact` probe will confirm ratio dropped below 0.85'
+                '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',
+                // Slice 2026-09-13-auto-compact-trigger-ownership: this command
+                // 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'
+                'Next `peaks code auto-compact` probe will confirm ratio dropped below 0.85',
+                describeHarnessWindowSync(harnessWindow)
             ];
         plan = buildConvergencePlan({
             sessionId,
@@ -426,7 +518,14 @@ export async function runAutoCompact(input) {
                 source: probe.source,
                 target: input.target ?? 'main',
                 mode,
-                redLineGated: isRedLine
+                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
             }
         };
     }
@@ -435,10 +534,6 @@ export async function runAutoCompact(input) {
     const target = input.target ?? 'main';
     let dispatch;
     try {
-        // `compacting` is the last stage this process can prove: the IDE
-        // performs the actual compaction out-of-band, so a successful
-        // dispatch return is NOT evidence the context shrank.
-        lifecycle.advance('compacting');
         if (input.testHooks?.failCompacting)
             throw new Error('IDE dispatch exploded');
         // Slice 2026-06-28: when targeting the main session, write an
@@ -463,7 +558,9 @@ export async function runAutoCompact(input) {
         });
     }
     catch (error) {
-        lifecycle.fail(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',
@@ -476,15 +573,29 @@ export async function runAutoCompact(input) {
                 convergencePlan: plan,
                 target,
                 mode,
-                redLineGated: isRedLine
+                redLineRequested: isRedLine,
+                redLineGated: isRedLine,
+                deprecatedFields: DEPRECATED_ENVELOPE_FIELDS,
+                harnessWindow
             }
         };
     }
-    // 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.
-    if (!dispatch.ok) {
-        lifecycle.fail(new Error(dispatch.message));
+    // Slice 2026-09-12-compact-band-policy (defect B): 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 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');
     }
     // Slice 2026-07-30-compact-visibility: append a compact-history
     // event so the new 'peaks compact history' CLI and the
@@ -497,6 +608,7 @@ export async function runAutoCompact(input) {
             sessionId,
             event: {
                 schemaVersion: 1,
+                kind: 'dispatch',
                 ts: now.toISOString(),
                 target,
                 mode,
@@ -507,6 +619,10 @@ export async function runAutoCompact(input) {
                 ok: dispatch.ok,
                 checkpointPath,
                 dispatchMessage: dispatch.message,
+                // T4 calibration: the exact denominator this dispatch divided by, so
+                // `beforeRatio * windowTokens` is the token point we asked for.
+                windowTokens: probe.capacityTokens ?? null,
+                windowSource: probe.capacitySource ?? null,
             },
         });
     }
@@ -518,7 +634,7 @@ export async function runAutoCompact(input) {
             : 'AUTO_COMPACT_DISPATCH_FAILED',
         message: dispatch.ok
             ? isRedLine
-                ? `RED-LINE compact dispatched (${dispatch.ide} / ${dispatch.pathway} / target=${target} / mode=${mode} — ${describeMode(mode)}); checkpoint at ${checkpointPath}. Further sub-agent dispatch is BLOCKED until ratio < 0.85.`
+                ? `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: {
@@ -530,7 +646,10 @@ export async function runAutoCompact(input) {
             dispatch,
             target,
             mode,
-            redLineGated: isRedLine
+            redLineRequested: isRedLine,
+            redLineGated: isRedLine,
+            deprecatedFields: DEPRECATED_ENVELOPE_FIELDS,
+            harnessWindow
         }
     };
 }
@@ -541,6 +660,17 @@ export function appendCompactHistoryEvent(input) {
     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.
+ */
+function appendObservedCompactEvent(input) {
+    try {
+        appendCompactHistoryEvent(input);
+    }
+    catch { /* 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;

package/dist/services/code/orchestrator-can-do.d.ts

@@ -18,8 +18,10 @@
  *        decide, ?, 选择, 决定). If yes → soft warning, NOT a blocker
  *        (the LLM should AskUserQuestion, which is cheap).
  *   Q4 — Is context usage sustainable? (probe `peaks code context-now
- *        --json`). ratio ≥ 0.95 → blocker (red-line); ≥ 0.85 →
- *        blocker (auto-compact-now).
+ *        --json`). ratio ≥ 0.95 → WARNING (red-line, ask-and-wait);
+ *        ≥ 0.85 → WARNING (pre-compact band). Never a blocker — see the
+ *        comment on the Q4 branch in `buildOrchestratorCanDoResult`, and
+ *        `evaluateCompactTrigger`, which is the face this one must agree with.
  *
  * Decision rule:
  *   canDoInSession === (blockers.length === 0)

package/dist/services/code/orchestrator-can-do.js

@@ -18,8 +18,10 @@
  *        decide, ?, 选择, 决定). If yes → soft warning, NOT a blocker
  *        (the LLM should AskUserQuestion, which is cheap).
  *   Q4 — Is context usage sustainable? (probe `peaks code context-now
- *        --json`). ratio ≥ 0.95 → blocker (red-line); ≥ 0.85 →
- *        blocker (auto-compact-now).
+ *        --json`). ratio ≥ 0.95 → WARNING (red-line, ask-and-wait);
+ *        ≥ 0.85 → WARNING (pre-compact band). Never a blocker — see the
+ *        comment on the Q4 branch in `buildOrchestratorCanDoResult`, and
+ *        `evaluateCompactTrigger`, which is the face this one must agree with.
  *
  * Decision rule:
  *   canDoInSession === (blockers.length === 0)
@@ -153,6 +155,7 @@ export async function probeSubAgentAvailable(projectRoot, peaksBin = DEFAULT_PEA
         await execFileAsync(command, [...args, 'sub-agent', 'dispatch', '--role', 'rd', '--help'], {
             cwd: projectRoot,
             timeout: 5000,
+            windowsHide: true,
         });
         return true;
     }
@@ -171,6 +174,7 @@ export async function probeContextRatio(projectRoot, peaksBin = DEFAULT_PEAKS_BI
         const { stdout } = await execFileAsync(command, [...args, 'code', 'context-now', '--project', projectRoot, '--json'], {
             cwd: projectRoot,
             timeout: 10000,
+            windowsHide: true,
         });
         const parsed = JSON.parse(stdout);
         const ratio = typeof parsed.data?.ratio === 'number' ? parsed.data.ratio : 0;
@@ -205,13 +209,41 @@ export function buildOrchestratorCanDoResult(input, signals) {
         blockers.push('sub-agent dispatch unavailable (peaks sub-agent dispatch --help failed)');
         suggestions.push('verify peaks CLI is on PATH; check `peaks --version`');
     }
-    // Q4 — context ratio gate. ≥0.95 → red-line; ≥0.85 → pre-compact.
+    // Q4 — context ratio. ≥0.95 → red-line; ≥0.85 → pre-compact. A WARNING, not
+    // a blocker, and the difference is deliberate (E3, rid 2026-09-13-defects-e).
+    //
+    // Why this is not a blocker any more, and why it is not an oversight:
+    //
+    //   The peak this answers is "can this slice run in the current session".
+    //   Context ratio cannot answer "no" to it. The reason is the one the
+    //   T3 slice (2026-09-13-auto-compact-trigger-ownership) landed on the
+    //   OTHER face of this same threshold: peaks-loop has no executor for a
+    //   running session, so it cannot compact its way out of a high ratio —
+    //   `evaluateCompactTrigger` therefore says of the red line "peaks-loop has
+    //   asked the harness to compact and is WAITING for it — sub-agent dispatch
+    //   is NOT blocked; carry on and re-probe". A probe that returned
+    //   `canDoInSession: false` here would contradict that sentence for the same
+    //   0.95 on the same number, and its only programmatic consumer
+    //   (`code-orchestrator-can-do.ts`) turns the false into exit code 1 — i.e.
+    //   it would re-open, at the CLI layer, exactly the deadlock T3 deleted.
+    //
+    //   Nor does the pre-compact zone (0.85–0.95) earn a blocker: the trigger's
+    //   message there is "peaks-loop already fired the auto-compact pathway; the
+    //   LLM does not need to act", which is the opposite of "you may not proceed".
+    //
+    //   What a blocker would still need to be true: THE ORCHESTRATOR itself
+    //   cannot continue. It can — the slice's edits are delegated to a sub-agent
+    //   (Q1), and the orchestrator's own context is only spent co-ordinating.
+    //
+    //   So the ratio is reported, warned about, and given a next action; the
+    //   verdict is left to the blockers that really are un-survivable (a
+    //   hard-blocked path family, an unreachable sub-agent dispatcher).
     if (signals.q4ContextRatio >= ORCHESTRATOR_REDLINE_RATIO) {
-        blockers.push(`context red-line (ratio=${signals.q4ContextRatio.toFixed(2)} ≥ ${ORCHESTRATOR_REDLINE_RATIO}); auto-compact now or push to next session`);
+        warnings.push(`context red-line (ratio=${signals.q4ContextRatio.toFixed(2)} ≥ ${ORCHESTRATOR_REDLINE_RATIO}): peaks-loop has asked the harness to compact and is waiting for it; dispatch is NOT blocked — carry on and re-probe with \`peaks code context-now\``);
         suggestions.push('peaks code auto-compact');
     }
     else if (signals.q4ContextRatio >= ORCHESTRATOR_PRECOMPACT_RATIO) {
-        blockers.push(`context near limit (ratio=${signals.q4ContextRatio.toFixed(2)} ≥ ${ORCHESTRATOR_PRECOMPACT_RATIO}); auto-compact or push to next session`);
+        warnings.push(`context near limit (ratio=${signals.q4ContextRatio.toFixed(2)} ≥ ${ORCHESTRATOR_PRECOMPACT_RATIO}): in the pre-compact band; peaks-loop fires the auto-compact pathway itself and dispatch is NOT blocked`);
         suggestions.push('peaks code auto-compact');
     }
     // Q3 — user-decision keywords → soft warning, NOT a blocker. The

package/dist/services/codegraph/codegraph-exclude-reconciler.js

@@ -176,7 +176,8 @@ export const CODEGRAPH_CONFIG_FILENAME = 'config.json';
 export function readTrackedFiles(projectRoot) {
     const stdout = execFileSync('git', ['-C', projectRoot, 'ls-files'], {
         encoding: 'utf8',
-        maxBuffer: 64 * 1024 * 1024
+        maxBuffer: 64 * 1024 * 1024,
+        windowsHide: true
     });
     return stdout
         .split('\n')

package/dist/services/codegraph/codegraph-process-runner.js

@@ -27,7 +27,7 @@ function terminateCodegraphProcess(childProcess) {
     }
     if (process.platform === 'win32') {
         if (process.env.SystemRoot) {
-            spawn(join(process.env.SystemRoot, 'System32', 'taskkill.exe'), ['/pid', String(childProcess.pid), '/T', '/F'], { shell: false, stdio: 'ignore' });
+            spawn(join(process.env.SystemRoot, 'System32', 'taskkill.exe'), ['/pid', String(childProcess.pid), '/T', '/F'], { shell: false, stdio: 'ignore', windowsHide: true });
         }
         else {
             childProcess.kill();
@@ -47,7 +47,8 @@ export function defaultCodegraphProcessRunner(invocation) {
             cwd: invocation.cwd,
             detached: process.platform !== 'win32',
             env: createCodegraphEnvironment(),
-            shell: false
+            shell: false,
+            windowsHide: true
         });
         const timeout = setTimeout(() => {
             terminateCodegraphProcess(childProcess);

package/dist/services/compact/request-transition-hook.js

@@ -15,8 +15,11 @@
  *
  * The hook is INVOKED from `src/cli/commands/request-commands.ts`
  * (RD→QA boundary) and from any future QA→final-review boundary. The
- * 0.95 red line is NOT changed: the existing auto-compact
- * orchestrator continues to refuse dispatch at ratio ≥ 0.95.
+ * 0.95 red line is unchanged in THRESHOLD but not in behaviour: the
+ * auto-compact orchestrator asks the harness to compact and reports that
+ * it is waiting. It does not refuse sub-agent dispatch — peaks-loop has no
+ * executor for a running session, so a refusal gated nothing and deadlocked
+ * the runner (slice 2026-09-13-auto-compact-trigger-ownership).
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';

package/dist/services/compact-history/compact-history-service.d.ts

@@ -10,7 +10,68 @@ export interface CompactHistoryEvent {
     readonly ok: boolean;
     readonly checkpointPath: string;
     readonly dispatchMessage: string;
+    /**
+     * Slice 2026-09-13-auto-compact-trigger-ownership (T4): the window this
+     * dispatch divided by. `beforeRatio * windowTokens` is the token point
+     * peaks-loop asked the harness to compact at.
+     */
+    readonly windowTokens?: number | null;
+    /** Which layer produced `windowTokens` (env-override | harness-env | config | model-heuristic | default). */
+    readonly windowSource?: string | null;
+    /**
+     * `dispatch` — peaks-loop asked for a compact (every row written before
+     * this slice is implicitly one of these). `observed` — a later probe
+     * MEASURED the ratio after a dispatched compact, proving one landed.
+     */
+    readonly kind?: 'dispatch' | 'observed';
+    /** `observed` rows only: the measured post-compact ratio. */
+    readonly afterRatio?: number;
 }
+/**
+ * One dispatch paired with the measurement that followed it — the
+ * intent-vs-observed record for the harness auto-compact window.
+ *
+ * Why a pair and not a number: the slice that owns this instrument could not
+ * run a real Claude Code session, and the harness's own documentation gives
+ * the env var as a WINDOW, not a trigger point, so "a window of X makes the
+ * harness fire at Y%" has no documented answer. Fabricating Y would be worse
+ * than not having it. Recording the intent (`requested*`) next to whatever
+ * the next real session actually measures (`observed*`) is the honest
+ * substitute: after one real session the gap becomes a measured fact.
+ */
+export interface WindowCalibrationPair {
+    readonly dispatchedAt: string;
+    readonly windowTokens: number | null;
+    readonly windowSource: string | null;
+    /** The ratio at which peaks-loop asked. */
+    readonly requestedRatio: number;
+    /** `requestedRatio * windowTokens` — token point asked for; null with no window. */
+    readonly requestedTokens: number | null;
+    /** Measured ratio of the first `observed` row after this dispatch. */
+    readonly observedRatio: number | null;
+    readonly observedTokens: number | null;
+    /**
+     * `observedTokens - requestedTokens`. Negative = the harness compacted
+     * BEFORE the point peaks-loop asked for (which is the harness's own
+     * trigger firing early). Null while unmeasured.
+     */
+    readonly driftTokens: number | null;
+    readonly measured: boolean;
+}
+export interface WindowCalibration {
+    readonly pairs: ReadonlyArray<WindowCalibrationPair>;
+    /** Dispatches with no following measurement yet. */
+    readonly unmeasured: number;
+    /** The window in force on the most recent dispatch, for a one-line read. */
+    readonly lastWindowTokens: number | null;
+}
+/**
+ * Pair each dispatched compact with the measurement that followed it. Pure;
+ * tolerates a file written by an earlier release (no `windowTokens`, no
+ * `kind`) — those rows produce a pair with a null window rather than an
+ * error, because the history file is append-only and never rewritten.
+ */
+export declare function computeWindowCalibration(events: ReadonlyArray<CompactHistoryEvent>): WindowCalibration;
 export type CompactHistoryReadResult = {
     readonly kind: 'file-missing';
     readonly path: string;