peaks-loop 4.0.45 → 4.0.47

package/dist/services/capability-guard-runner/contracts/J02.js

@@ -6,10 +6,10 @@ const STATES = ['spec-locked', 'implemented', 'qa-handoff', 'handed-off'];
 export async function runJ02Contract(ctx, projectRoot = ctx.projectRoot) {
     const bin = join(ctx.projectRoot, 'bin', 'peaks.js');
     const tmp = mkdtempSync(join(tmpdir(), 'cbl-J02-'));
-    const ws = execFileSync('node', [bin, 'workspace', 'init', '--project', tmp, '--json'], { cwd: tmp }).toString('utf8');
+    const ws = execFileSync('node', [bin, 'workspace', 'init', '--project', tmp, '--json'], { cwd: tmp, windowsHide: true }).toString('utf8');
     const { data: { sessionId } } = JSON.parse(ws);
     const rid = '2026-08-03-j02-fixture';
-    const initOut = execFileSync('node', [bin, 'request', 'init', '--role', 'rd', '--id', rid, '--project', tmp, '--session-id', sessionId, '--apply', '--json'], { cwd: tmp }).toString('utf8');
+    const initOut = execFileSync('node', [bin, 'request', 'init', '--role', 'rd', '--id', rid, '--project', tmp, '--session-id', sessionId, '--apply', '--json'], { cwd: tmp, windowsHide: true }).toString('utf8');
     const initEnv = JSON.parse(initOut);
     // `request init` writes the file as `NNN-<id-slug>.md`. The transition CLI accepts
     // the file's basename (without .md) as the requestId. Derive it from data.path.
@@ -19,7 +19,7 @@ export async function runJ02Contract(ctx, projectRoot = ctx.projectRoot) {
     for (const s of STATES) {
         const out = execFileSync('node', [bin, 'request', 'transition', requestId, '--role', 'rd', '--state', s,
             '--project', tmp, '--session-id', sessionId, '--confirm', '--allow-incomplete',
-            '--reason', 'J02 contract fixture', '--json'], { cwd: tmp }).toString('utf8');
+            '--reason', 'J02 contract fixture', '--json'], { cwd: tmp, windowsHide: true }).toString('utf8');
         const env = JSON.parse(out);
         last = env.data.state;
     }

package/dist/services/capability-guard-runner/contracts/J04.js

@@ -10,7 +10,8 @@ export async function runJ04Contract(ctx) {
     try {
         const stdout = execFileSync('node', [bin, 'audit', 'goal', '--help'], {
             cwd: ctx.projectRoot,
-            env: { ...process.env, PEAKS_CALLER_ID: `guard-J04-${ctx.sessionId}` }
+            env: { ...process.env, PEAKS_CALLER_ID: `guard-J04-${ctx.sessionId}` },
+            windowsHide: true
         }).toString('utf8');
         helpOk = stdout.length > 0 && !stdout.includes('unknown command');
     }
@@ -23,7 +24,8 @@ export async function runJ04Contract(ctx) {
         execFileSync('node', [bin, 'audit', 'goal', '--project', tmp, '--json'], {
             cwd: ctx.projectRoot,
             env: { ...process.env, PEAKS_CALLER_ID: `guard-J04-${ctx.sessionId}` },
-            stdio: ['ignore', 'pipe', 'pipe']
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true
         });
     }
     catch (e) {

package/dist/services/capability-guard-runner/contracts/J07.js

@@ -19,7 +19,8 @@ export async function runJ07Contract(ctx) {
         const out = execFileSync('node', [bin, 'test', '--help'], {
             cwd: ctx.projectRoot,
             env: { ...process.env, PEAKS_CALLER_ID: `guard-J07-${ctx.sessionId}` },
-            stdio: ['ignore', 'pipe', 'pipe']
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true
         }).toString('utf8');
         helpOk = out.length > 0 && !out.includes('unknown command');
     }

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

@@ -16,8 +16,35 @@ import { type CompactLifecycleRecord, type CompactLifecycleStage } from '../comp
  * Stages a compact *attempt* can prove from inside the dispatching
  * process. `verifying` / `completed` are deliberately absent — see
  * `CompactLifecyclePublisher` and `settleOpenLifecycleRun` for why.
+ *
+ * `armed` is the honest resting stage for a dispatch that only
+ * REGISTERED a trigger (slice 2026-09-12-compact-band-policy, defect B)
+ * — see `resolveDispatchedStage`.
+ */
+type ObservableDispatchStage = Extract<CompactLifecycleStage, 'queued' | 'preparing' | 'compacting' | 'armed'>;
+/** Stage a failure is attributed to (mirrors the store's `failedAt` domain). */
+type FailableStage = Exclude<CompactLifecycleStage, 'failed' | 'completed'>;
+/**
+ * Slice 2026-09-12-compact-band-policy (defect B): which stage a
+ * *successful* dispatch can honestly claim.
+ *
+ * A dispatch is only evidence that a compact is IN FLIGHT when the
+ * adapter's own trigger is already satisfied. claude-code's
+ * `ide-native` pathway installs a PreToolUse hook that compacts
+ * in-band at ratio ≥ 0.95 (`AUTO_COMPACT_RED_LINE_RATIO`); at or above
+ * that ratio the very next tool call fires it, so `compacting` (and
+ * therefore `stalled` if it never lands) is the truthful reading.
+ *
+ * Below it — and for every pathway that only writes an intent
+ * (`llm-self-compress`), or whose shell-exec branch is a deprecated
+ * no-op — NOTHING is compacting. The process merely ARMED a trigger.
+ * Recording `compacting` there published a heartbeat nobody would ever
+ * send, which is what pinned the statusline at `stalled` forever.
  */
-type ObservableDispatchStage = Extract<CompactLifecycleStage, 'queued' | 'preparing' | 'compacting'>;
+export declare function resolveDispatchedStage(input: {
+    readonly pathway: string;
+    readonly ratio: number;
+}): Extract<CompactLifecycleStage, 'compacting' | 'armed'>;
 /**
  * One id per compact attempt. Timestamp-prefixed so a human reading
  * the raw record can order runs by eye; the random suffix keeps two
@@ -53,8 +80,17 @@ export declare class CompactLifecyclePublisher {
     });
     /** Publish an active stage the process has proved. */
     advance(stage: ObservableDispatchStage): void;
-    /** Publish the terminal failure, attributed to the last stage reached. */
-    fail(error: unknown): void;
+    /**
+     * Publish the terminal failure, attributed to the last stage reached.
+     *
+     * `at` overrides that attribution for the case where the failure
+     * happened INSIDE a phase that is only named after its outcome
+     * (slice 2026-09-12-compact-band-policy): the dispatch call is the
+     * compacting phase even though the resting stage is now chosen from
+     * the pathway the dispatch returned. `failedAt` names the phase the
+     * attempt died in — it is not a published heartbeat.
+     */
+    fail(error: unknown, at?: FailableStage): void;
     private write;
 }
 /**
@@ -90,6 +126,12 @@ export declare function summarizeLifecycleError(error: unknown): string;
  *     `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 declare function settleOpenLifecycleRun(input: {
     readonly projectRoot: string;
@@ -98,5 +140,9 @@ export declare function settleOpenLifecycleRun(input: {
     readonly source: string;
     readonly autoFireThreshold: number;
     readonly onLifecycleStage?: ((stage: CompactLifecycleStage, record: CompactLifecycleRecord) => void) | undefined;
-}): void;
+}): {
+    readonly runId: string;
+    readonly triggerRatio: number;
+    readonly afterRatio: number;
+} | null;
 export {};

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

@@ -12,6 +12,7 @@
  * returned envelope.
  */
 import { readCompactLifecycle, writeCompactLifecycle } from '../compact-statusline/compact-lifecycle-store.js';
+import { AUTO_COMPACT_RED_LINE_RATIO } from '../context/auto-compact-types.js';
 /**
  * PRD-002b slice 2 — extract the few cross-cutting magic numbers
  * that actually appear at runtime call sites in this orchestrator.
@@ -20,6 +21,28 @@ import { readCompactLifecycle, writeCompactLifecycle } from '../compact-statusli
  * + spec prose references must keep the literal value visible.
  */
 const COLLAPSED_ERROR_MAX_CHARS = 160;
+/**
+ * Slice 2026-09-12-compact-band-policy (defect B): which stage a
+ * *successful* dispatch can honestly claim.
+ *
+ * A dispatch is only evidence that a compact is IN FLIGHT when the
+ * adapter's own trigger is already satisfied. claude-code's
+ * `ide-native` pathway installs a PreToolUse hook that compacts
+ * in-band at ratio ≥ 0.95 (`AUTO_COMPACT_RED_LINE_RATIO`); at or above
+ * that ratio the very next tool call fires it, so `compacting` (and
+ * therefore `stalled` if it never lands) is the truthful reading.
+ *
+ * Below it — and for every pathway that only writes an intent
+ * (`llm-self-compress`), or whose shell-exec branch is a deprecated
+ * no-op — NOTHING is compacting. The process merely ARMED a trigger.
+ * Recording `compacting` there published a heartbeat nobody would ever
+ * send, which is what pinned the statusline at `stalled` forever.
+ */
+export function resolveDispatchedStage(input) {
+    return input.pathway === 'ide-native' && input.ratio >= AUTO_COMPACT_RED_LINE_RATIO
+        ? 'compacting'
+        : 'armed';
+}
 /**
  * One id per compact attempt. Timestamp-prefixed so a human reading
  * the raw record can order runs by eye; the random suffix keeps two
@@ -100,8 +123,17 @@ export class CompactLifecyclePublisher {
             redLine: this.ctx.redLine
         });
     }
-    /** Publish the terminal failure, attributed to the last stage reached. */
-    fail(error) {
+    /**
+     * Publish the terminal failure, attributed to the last stage reached.
+     *
+     * `at` overrides that attribution for the case where the failure
+     * happened INSIDE a phase that is only named after its outcome
+     * (slice 2026-09-12-compact-band-policy): the dispatch call is the
+     * compacting phase even though the resting stage is now chosen from
+     * the pathway the dispatch returned. `failedAt` names the phase the
+     * attempt died in — it is not a published heartbeat.
+     */
+    fail(error, at) {
         this.write({
             schemaVersion: 1,
             runId: this.ctx.runId,
@@ -109,7 +141,7 @@ export class CompactLifecyclePublisher {
             updatedAt: new Date().toISOString(),
             triggerRatio: this.ctx.triggerRatio,
             redLine: this.ctx.redLine,
-            failedAt: this.lastStage,
+            failedAt: at ?? this.lastStage,
             errorSummary: summarizeLifecycleError(error)
         });
     }
@@ -182,25 +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;
-    // Only a run that was actually dispatched (`compacting`) can be
-    // completed by a post-compact measurement.
-    if (prior.stage !== 'compacting')
-        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 null;
     const emit = (stage, withAfterRatio) => {
         const record = {
             schemaVersion: 1,
@@ -232,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;