peaks-loop 4.0.46 → 4.0.47

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

@@ -214,28 +214,34 @@ export function summarizeLifecycleError(error) {
  *     `afterRatio: 0` there would publish a fabricated number;
  *   - the ratio is still at or above the auto-fire threshold — the
  *     compact has not landed, so the run stays open.
+ *
+ * Returns the settled record, or `null` when nothing settled. Slice
+ * 2026-09-13-auto-compact-trigger-ownership: the caller needs the settled
+ * `afterRatio` to append the "observed compaction point" row that makes the
+ * intent-vs-observed gap readable after a real session. The return value is
+ * telemetry only — callers that ignore it are unaffected.
  */
 export function settleOpenLifecycleRun(input) {
     // A `conservative-fallback` probe means no signal was available at
     // all. Its `ratio: 0` is the absence of a measurement, so it can
     // never be evidence that the context shrank.
     if (input.source === 'conservative-fallback')
-        return;
+        return null;
     if (input.measuredRatio >= input.autoFireThreshold)
-        return;
+        return null;
     const prior = readOpenCompactLifecycle({
         projectRoot: input.projectRoot,
         sessionId: input.sessionId
     });
     if (prior === null)
-        return;
+        return null;
     // Only a run that was actually dispatched can be completed by a
     // post-compact measurement. Both `compacting` (the in-band trigger is
     // satisfied) and `armed` (a trigger was registered and could fire at
     // any time) qualify: the measured drop is proof that SOME compact
     // landed, and this is the only open run to attribute it to.
     if (prior.stage !== 'compacting' && prior.stage !== 'armed')
-        return;
+        return null;
     const emit = (stage, withAfterRatio) => {
         const record = {
             schemaVersion: 1,
@@ -267,4 +273,5 @@ export function settleOpenLifecycleRun(input) {
     emit('verifying', false);
     // `completed` = the measurement confirms the drop; publish it.
     emit('completed', true);
+    return { runId: prior.runId, triggerRatio: prior.triggerRatio, afterRatio: input.measuredRatio };
 }

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

@@ -31,7 +31,21 @@ export interface AutoCompactInput {
      * autonomously at 0.85+ with zero human / zero LLM intervention.
      */
     readonly force?: boolean | undefined;
-    /** Skip the 95% red-line gate (test seam — never true in production). */
+    /**
+     * INERT — nothing reads this. It is threaded from the CLI's
+     * `--bypass-red-line` (a published flag, kept for backward compatibility;
+     * see the option's own note) down to `evaluateAutoCompactDecision`, where the
+     * red-line branch ignores it.
+     *
+     * Why nothing reads it any more: it used to skip a gate that refused to
+     * dispatch below 0.85. That gate was removed (slice
+     * 2026-09-13-auto-compact-trigger-ownership, T3/A1) — peaks-loop cannot
+     * compact a running session, so the refusal could not shorten the wait it
+     * was waiting for, and it deadlocked the runner at the worst moment. With the
+     * gate gone, the red line still ASKS the harness to compact (when it always
+     * did) and no longer needs a bypass. Kept as a field so the published
+     * signature does not change under callers that pass it.
+     */
     readonly bypassRedLine?: boolean | undefined;
     /** Current session id (default = resolve via session-id-service). */
     readonly sessionId?: string | undefined;
@@ -93,7 +107,7 @@ export interface AutoCompactTestHooks {
  *
  *   - 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
@@ -109,8 +123,13 @@ export declare function evaluateCompactTrigger(ratio: number, mode?: AutoCompact
  *   - 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 declare function evaluateAutoCompactDecision(input: {
     ratio: number;
@@ -129,6 +148,7 @@ export declare function evaluateAutoCompactDecision(input: {
      */
     inflightBatch?: boolean | InFlightBatchProbe | undefined;
     force?: boolean | undefined;
+    /** Accepted and ignored — see `AutoCompactInput.bypassRedLine`. */
     bypassRedLine?: boolean | undefined;
     mode?: AutoCompactMode | undefined;
     /**
@@ -170,13 +190,14 @@ export declare function buildConvergencePlan(input: {
  *   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 declare function runAutoCompact(input: AutoCompactInput): Promise<AutoCompactResult>;
 /** Re-export for callers that need to surface the trigger shape. */
@@ -200,6 +221,29 @@ export interface CompactHistoryEvent {
     readonly ok: boolean;
     readonly checkpointPath: string;
     readonly dispatchMessage: string;
+    /**
+     * Slice 2026-09-13-auto-compact-trigger-ownership (T4): the calibration
+     * instrument. `windowTokens` is the denominator peaks-loop divided by
+     * (`probe.capacityTokens`), so `beforeRatio * windowTokens` is the exact
+     * TOKEN POINT peaks-loop asked the harness to compact at. That number is
+     * the deliverable — NOT a hand-picked threshold: this slice could not run a
+     * real Claude Code session, so the real trigger point of
+     * `CLAUDE_CODE_AUTO_COMPACT_WINDOW` (documented as a window, observed to
+     * fire near the window's end) has no measured answer yet. Recording the
+     * intent lets the first real session produce one.
+     */
+    readonly windowTokens?: number | null;
+    /** Which layer produced `windowTokens` (see `ContextWindowSource`). */
+    readonly windowSource?: string | null;
+    /**
+     * `dispatch` (default, and the only kind earlier releases wrote) or
+     * `observed` — a row appended when a later probe MEASURED the ratio after
+     * a dispatched compact, proving one landed. The pair is what yields the
+     * intent-vs-observed delta.
+     */
+    readonly kind?: 'dispatch' | 'observed';
+    /** `observed` rows only: the measured post-compact ratio. */
+    readonly afterRatio?: number;
 }
 export declare function appendCompactHistoryEvent(input: {
     readonly projectRoot: string;

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,15 +29,17 @@
  * 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, resolveDispatchedStage, settleOpenLifecycleRun, summarizeLifecycleError } from './auto-compact-lifecycle.js';
@@ -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
             }
         };
     }
@@ -474,7 +573,10 @@ export async function runAutoCompact(input) {
                 convergencePlan: plan,
                 target,
                 mode,
-                redLineGated: isRedLine
+                redLineRequested: isRedLine,
+                redLineGated: isRedLine,
+                deprecatedFields: DEPRECATED_ENVELOPE_FIELDS,
+                harnessWindow
             }
         };
     }
@@ -506,6 +608,7 @@ export async function runAutoCompact(input) {
             sessionId,
             event: {
                 schemaVersion: 1,
+                kind: 'dispatch',
                 ts: now.toISOString(),
                 target,
                 mode,
@@ -516,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,
             },
         });
     }
@@ -527,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: {
@@ -539,7 +646,10 @@ export async function runAutoCompact(input) {
             dispatch,
             target,
             mode,
-            redLineGated: isRedLine
+            redLineRequested: isRedLine,
+            redLineGated: isRedLine,
+            deprecatedFields: DEPRECATED_ENVELOPE_FIELDS,
+            harnessWindow
         }
     };
 }
@@ -550,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';