peaks-loop 4.0.54 → 4.1.0

package/dist/services/compact/suggest-types.js

@@ -0,0 +1,10 @@
+/** Default tool-call threshold before first suggestion. */
+export const DEFAULT_TOOL_CALL_THRESHOLD = 50;
+/** Default additional tool calls before the suggestion repeats. */
+export const TOOL_CALL_REMIND_STEP = 25;
+/** Default context-size threshold on a 200k window. */
+export const DEFAULT_CONTEXT_THRESHOLD_200K = 160_000;
+/** Default context-size threshold on a 1M window. */
+export const DEFAULT_CONTEXT_THRESHOLD_1M = 250_000;
+/** Default re-remind interval for context size. */
+export const DEFAULT_CONTEXT_INTERVAL = 60_000;

package/dist/services/compact-history/compact-history-service.js

@@ -96,7 +96,7 @@ export function summarizeCompactHistory(events) {
             lastBeforeRatio: null,
             lastRedLine: false,
             redLineCount: 0,
-            failedCount: 0,
+            failedCount: 0
         };
     }
     const last = events[events.length - 1];
@@ -106,6 +106,6 @@ export function summarizeCompactHistory(events) {
         lastBeforeRatio: last.beforeRatio,
         lastRedLine: last.redLine,
         redLineCount: events.filter((e) => e.redLine).length,
-        failedCount: events.filter((e) => !e.ok).length,
+        failedCount: events.filter((e) => !e.ok).length
     };
 }

package/dist/services/compact-statusline/compact-lifecycle-store.d.ts

@@ -1,35 +1,5 @@
-export type CompactLifecycleStage = 'queued' | 'preparing' | 'compacting'
-/**
- * Slice 2026-09-12-compact-band-policy: a compact trigger was
- * REGISTERED but no compaction has started — e.g. claude-code's
- * `ide-native` pathway only installs the PreToolUse hook, which
- * compacts in-band at ratio ≥ 0.95. In the 0.80–0.95 band nothing
- * is in flight, so claiming `compacting` was a false heartbeat.
- */
- | 'armed' | 'verifying' | 'completed' | 'failed';
-export interface CompactLifecycleRecord {
-    readonly schemaVersion: 1;
-    readonly runId: string;
-    readonly stage: CompactLifecycleStage;
-    readonly updatedAt: string;
-    readonly triggerRatio: number;
-    readonly afterRatio?: number;
-    readonly redLine: boolean;
-    readonly failedAt?: Exclude<CompactLifecycleStage, 'failed' | 'completed'>;
-    readonly errorSummary?: string;
-}
-export type CompactLifecycleRead = {
-    readonly kind: 'missing';
-} | {
-    readonly kind: 'valid';
-    readonly record: CompactLifecycleRecord;
-} | {
-    readonly kind: 'invalid';
-    readonly reason: string;
-} | {
-    readonly kind: 'stalled';
-    readonly record: CompactLifecycleRecord;
-};
+import type { CompactLifecycleRead, CompactLifecycleRecord, CompactLifecycleStage } from './compact-lifecycle-types.js';
+export type { CompactLifecycleRead, CompactLifecycleRecord, CompactLifecycleStage };
 /**
  * Atomically write a compact lifecycle record. Uses a temp file in
  * the same directory plus `renameSync`, so a crash mid-write never

package/dist/services/compact-statusline/compact-lifecycle-store.js

@@ -40,12 +40,7 @@ const ERROR_SUMMARY_MAX = 160;
  * `armed` is deliberately NOT here — see the header. It is a resting
  * state, not a heartbeat.
  */
-const ACTIVE_STAGES = [
-    'queued',
-    'preparing',
-    'compacting',
-    'verifying',
-];
+const ACTIVE_STAGES = ['queued', 'preparing', 'compacting', 'verifying'];
 const ALL_STAGES = [
     'queued',
     'preparing',
@@ -53,7 +48,7 @@ const ALL_STAGES = [
     'armed',
     'verifying',
     'completed',
-    'failed',
+    'failed'
 ];
 function lifecyclePath(projectRoot, sessionId) {
     return join(getSessionDir(projectRoot, sessionId), LIFECYCLE_FILENAME);
@@ -114,7 +109,7 @@ function coerceRecord(raw) {
             redLine: raw['redLine'],
             failedAt: failedAt,
             ...(raw['afterRatio'] !== undefined ? { afterRatio: raw['afterRatio'] } : {}),
-            ...(errorSummary !== undefined ? { errorSummary: errorSummary } : {}),
+            ...(errorSummary !== undefined ? { errorSummary: errorSummary } : {})
         };
     }
     // Non-failed records must NOT carry a failedAt or errorSummary.
@@ -131,7 +126,7 @@ function coerceRecord(raw) {
         updatedAt: raw['updatedAt'],
         triggerRatio: raw['triggerRatio'],
         redLine: raw['redLine'],
-        ...(raw['afterRatio'] !== undefined ? { afterRatio: raw['afterRatio'] } : {}),
+        ...(raw['afterRatio'] !== undefined ? { afterRatio: raw['afterRatio'] } : {})
     };
 }
 function clampErrorSummary(value) {
@@ -163,7 +158,7 @@ export function writeCompactLifecycle(input) {
     // (Re-coercing also catches cases where the caller bypassed TypeScript.)
     const validated = coerceRecord({
         ...input.record,
-        errorSummary: clampErrorSummary(input.record.errorSummary),
+        errorSummary: clampErrorSummary(input.record.errorSummary)
     });
     const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
     try {
@@ -210,7 +205,7 @@ export function readCompactLifecycle(input) {
     catch (error) {
         return {
             kind: 'invalid',
-            reason: `compact-lifecycle: unable to read record file: ${error.message}`,
+            reason: `compact-lifecycle: unable to read record file: ${error.message}`
         };
     }
     let parsed;
@@ -220,7 +215,7 @@ export function readCompactLifecycle(input) {
     catch (error) {
         return {
             kind: 'invalid',
-            reason: `compact-lifecycle: malformed JSON (${error.message})`,
+            reason: `compact-lifecycle: malformed JSON (${error.message})`
         };
     }
     let record;

package/dist/services/compact-statusline/compact-lifecycle-types.d.ts

@@ -0,0 +1,32 @@
+export type CompactLifecycleStage = 'queued' | 'preparing' | 'compacting'
+/**
+ * Slice 2026-09-12-compact-band-policy: a compact trigger was
+ * REGISTERED but no compaction has started — e.g. claude-code's
+ * `ide-native` pathway only installs the PreToolUse hook, which
+ * compacts in-band at ratio ≥ 0.95. In the 0.80–0.95 band nothing
+ * is in flight, so claiming `compacting` was a false heartbeat.
+ */
+ | 'armed' | 'verifying' | 'completed' | 'failed';
+export interface CompactLifecycleRecord {
+    readonly schemaVersion: 1;
+    readonly runId: string;
+    readonly stage: CompactLifecycleStage;
+    readonly updatedAt: string;
+    readonly triggerRatio: number;
+    readonly afterRatio?: number;
+    readonly redLine: boolean;
+    readonly failedAt?: Exclude<CompactLifecycleStage, 'failed' | 'completed'>;
+    readonly errorSummary?: string;
+}
+export type CompactLifecycleRead = {
+    readonly kind: 'missing';
+} | {
+    readonly kind: 'valid';
+    readonly record: CompactLifecycleRecord;
+} | {
+    readonly kind: 'invalid';
+    readonly reason: string;
+} | {
+    readonly kind: 'stalled';
+    readonly record: CompactLifecycleRecord;
+};

package/dist/services/compact-statusline/compact-lifecycle-types.js

@@ -0,0 +1,8 @@
+// src/services/compact-statusline/compact-lifecycle-types.ts
+//
+// The record shape for the runtime compact-lifecycle store
+// (`compact-lifecycle-store.ts`), split out to keep the store under the
+// 300-raw-line file cap. Types only — no behaviour lives here. The store
+// re-exports every name below, so importers keep using
+// `compact-lifecycle-store.js` unchanged.
+export {};

package/dist/services/compact-statusline/compact-statusline-cell-table.d.ts

@@ -0,0 +1,42 @@
+import type { CompactLifecycleStage } from './compact-lifecycle-store.js';
+export type CompactDisplayKind = 'none' | 'queued' | 'preparing' | 'compacting' | 'verifying' | 'completed' | 'failed' | 'stalled' | 'invalid' | 'armed';
+export interface CompactStatuslineState {
+    readonly kind: CompactDisplayKind;
+    readonly filledCells: 0 | 2 | 4 | 6 | 8;
+    readonly triggerRatio?: number;
+    readonly afterRatio?: number;
+    readonly redLine?: boolean;
+    readonly failedAt?: CompactLifecycleStage;
+    readonly detail?: string;
+}
+/**
+ * Concrete first-version stale timeout. Adjustable after real timing
+ * evidence from the auto-compact orchestrator (it currently writes a
+ * heartbeat on every state transition; 120 s is the longest realistic
+ * gap between a heartbeat and an actual stall).
+ */
+export declare const DEFAULT_STALE_AFTER_MS = 120000;
+/**
+ * 10-second completed-window expiry. The brief (Task 6 design requirement)
+ * calls out: once a compact lifecycle reaches `completed`, the primary
+ * statusline should surface the success indicator for at most 10 seconds,
+ * then fall back to the C1 baseline so the consumer (the IDE) does not
+ * keep a green ✓ pinned on the status bar indefinitely. The narrow window
+ * is sufficient for the human to see "we just compacted" and long enough
+ * to not flap on subsequent reads. Adjustable after real timing feedback.
+ */
+export declare const COMPLETED_EXPIRY_MS = 10000;
+/**
+ * How recently the last history row must itself have been written for the
+ * legacy path to report it as "just compacted". Measured against the row's own
+ * `ts` — the fact — rather than the file's mtime, which is only a proxy for it
+ * and is also moved by rows that record no compaction (repair R9).
+ */
+export declare const LEGACY_JUST_COMPACTED_WINDOW_MS = 30000;
+export declare const STAGE_CELL_COMPACTING = 4;
+export declare const STAGE_CELL_VERIFYING = 6;
+export declare const STAGE_CELL_COMPLETED = 8;
+export declare const CELL_BY_STAGE: ReadonlyMap<CompactLifecycleStage, 0 | 2 | 4 | 6 | 8>;
+export declare const NO_AFTER_RATIO_HINT = "after-ratio not recorded";
+export declare function renderBar(filledCells: 0 | 2 | 4 | 6 | 8): string;
+export declare function renderLegacyBar(filledCells: 0 | 2 | 4 | 6 | 8): string;

package/dist/services/compact-statusline/compact-statusline-cell-table.js

@@ -0,0 +1,63 @@
+// src/services/compact-statusline/compact-statusline-cell-table.ts
+//
+// Wave-5 class-A hoist (rid 2026-10-01-wave5-w5-3-compact-release): the
+// display-state types, timing windows, and frozen cell-table render
+// primitives moved VERBATIM out of `compact-statusline-service.ts` (:51-135
+// at the split) for the 300-raw-line cap. The
+// `/* eslint-disable no-magic-numbers */ ... /* eslint-enable */` pair is
+// relocated WHOLE with the region it suppresses — no chunk arrives here
+// without its suppression. The parent re-exports `CompactDisplayKind`,
+// `CompactStatuslineState` and `COMPLETED_EXPIRY_MS` so existing import
+// paths keep working.
+/**
+ * Concrete first-version stale timeout. Adjustable after real timing
+ * evidence from the auto-compact orchestrator (it currently writes a
+ * heartbeat on every state transition; 120 s is the longest realistic
+ * gap between a heartbeat and an actual stall).
+ */
+export const DEFAULT_STALE_AFTER_MS = 120_000;
+/**
+ * 10-second completed-window expiry. The brief (Task 6 design requirement)
+ * calls out: once a compact lifecycle reaches `completed`, the primary
+ * statusline should surface the success indicator for at most 10 seconds,
+ * then fall back to the C1 baseline so the consumer (the IDE) does not
+ * keep a green ✓ pinned on the status bar indefinitely. The narrow window
+ * is sufficient for the human to see "we just compacted" and long enough
+ * to not flap on subsequent reads. Adjustable after real timing feedback.
+ */
+export const COMPLETED_EXPIRY_MS = 10_000;
+/**
+ * How recently the last history row must itself have been written for the
+ * legacy path to report it as "just compacted". Measured against the row's own
+ * `ts` — the fact — rather than the file's mtime, which is only a proxy for it
+ * and is also moved by rows that record no compaction (repair R9).
+ */
+export const LEGACY_JUST_COMPACTED_WINDOW_MS = 30_000;
+// PRD-002b slice 2 — extract cell-table magic numbers (4/6/8) into named
+// consts so the no-magic-numbers lint rule stops flagging the typed
+// literal-union cell-table values. Values match the documented contract.
+export const STAGE_CELL_COMPACTING = 4;
+export const STAGE_CELL_VERIFYING = 6;
+export const STAGE_CELL_COMPLETED = 8;
+/* eslint-disable no-magic-numbers -- cell-table contract uses literal-type unions (`0 | 2 | 4 | 6 | 8`); these are type-position discriminators, not runtime values. Magic-number extraction is done at the runtime call sites via STAGE_CELL_* constants above. */
+export const CELL_BY_STAGE = new Map([
+    ['queued', 0],
+    ['preparing', 2],
+    ['compacting', STAGE_CELL_COMPACTING],
+    ['verifying', STAGE_CELL_VERIFYING],
+    ['completed', STAGE_CELL_COMPLETED],
+    ['failed', STAGE_CELL_COMPACTING]
+    // `armed` is not in the cell table: it renders WITHOUT a bar (see
+    // renderCompactStatusline). Lookups therefore miss and fall back to 0.
+]);
+const FILLED = '█';
+const EMPTY = '░';
+const BAR_WIDTH = STAGE_CELL_COMPLETED;
+export const NO_AFTER_RATIO_HINT = 'after-ratio not recorded';
+export function renderBar(filledCells) {
+    return `[${FILLED.repeat(filledCells)}${EMPTY.repeat(BAR_WIDTH - filledCells)}]`;
+}
+export function renderLegacyBar(filledCells) {
+    return renderBar(filledCells);
+}
+/* eslint-enable no-magic-numbers */

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

@@ -1,24 +1,7 @@
-import { type CompactLifecycleStage } from './compact-lifecycle-store.js';
-export type CompactDisplayKind = 'none' | 'queued' | 'preparing' | 'compacting' | 'verifying' | 'completed' | 'failed' | 'stalled' | 'invalid' | 'armed';
-export interface CompactStatuslineState {
-    readonly kind: CompactDisplayKind;
-    readonly filledCells: 0 | 2 | 4 | 6 | 8;
-    readonly triggerRatio?: number;
-    readonly afterRatio?: number;
-    readonly redLine?: boolean;
-    readonly failedAt?: CompactLifecycleStage;
-    readonly detail?: string;
-}
-/**
- * 10-second completed-window expiry. The brief (Task 6 design requirement)
- * calls out: once a compact lifecycle reaches `completed`, the primary
- * statusline should surface the success indicator for at most 10 seconds,
- * then fall back to the C1 baseline so the consumer (the IDE) does not
- * keep a green ✓ pinned on the status bar indefinitely. The narrow window
- * is sufficient for the human to see "we just compacted" and long enough
- * to not flap on subsequent reads. Adjustable after real timing feedback.
- */
-export declare const COMPLETED_EXPIRY_MS = 10000;
+import { type CompactStatuslineState } from './compact-statusline-cell-table.js';
+export type { CompactDisplayKind } from './compact-statusline-cell-table.js';
+export type { CompactStatuslineState } from './compact-statusline-cell-table.js';
+export { COMPLETED_EXPIRY_MS } from './compact-statusline-cell-table.js';
 export declare function decideCompactStatusline(input: {
     readonly projectRoot: string;
     readonly sessionId: string | null;

package/dist/services/compact-statusline/compact-statusline-service.js

@@ -41,59 +41,10 @@ import { existsSync, readFileSync } from 'node:fs';
 import { getSessionDir } from '../session/getSessionDir.js';
 import { AUTO_COMPACT_RED_LINE_RATIO } from '../context/auto-compact-types.js';
 import { readCompactHistory } from '../compact-history/compact-history-service.js';
-import { readCompactLifecycle, } from './compact-lifecycle-store.js';
-/**
- * Concrete first-version stale timeout. Adjustable after real timing
- * evidence from the auto-compact orchestrator (it currently writes a
- * heartbeat on every state transition; 120 s is the longest realistic
- * gap between a heartbeat and an actual stall).
- */
-const DEFAULT_STALE_AFTER_MS = 120_000;
-/**
- * 10-second completed-window expiry. The brief (Task 6 design requirement)
- * calls out: once a compact lifecycle reaches `completed`, the primary
- * statusline should surface the success indicator for at most 10 seconds,
- * then fall back to the C1 baseline so the consumer (the IDE) does not
- * keep a green ✓ pinned on the status bar indefinitely. The narrow window
- * is sufficient for the human to see "we just compacted" and long enough
- * to not flap on subsequent reads. Adjustable after real timing feedback.
- */
-export const COMPLETED_EXPIRY_MS = 10_000;
-/**
- * How recently the last history row must itself have been written for the
- * legacy path to report it as "just compacted". Measured against the row's own
- * `ts` — the fact — rather than the file's mtime, which is only a proxy for it
- * and is also moved by rows that record no compaction (repair R9).
- */
-const LEGACY_JUST_COMPACTED_WINDOW_MS = 30_000;
-// PRD-002b slice 2 — extract cell-table magic numbers (4/6/8) into named
-// consts so the no-magic-numbers lint rule stops flagging the typed
-// literal-union cell-table values. Values match the documented contract.
-const STAGE_CELL_COMPACTING = 4;
-const STAGE_CELL_VERIFYING = 6;
-const STAGE_CELL_COMPLETED = 8;
-/* eslint-disable no-magic-numbers -- cell-table contract uses literal-type unions (`0 | 2 | 4 | 6 | 8`); these are type-position discriminators, not runtime values. Magic-number extraction is done at the runtime call sites via STAGE_CELL_* constants above. */
-const CELL_BY_STAGE = new Map([
-    ['queued', 0],
-    ['preparing', 2],
-    ['compacting', STAGE_CELL_COMPACTING],
-    ['verifying', STAGE_CELL_VERIFYING],
-    ['completed', STAGE_CELL_COMPLETED],
-    ['failed', STAGE_CELL_COMPACTING],
-    // `armed` is not in the cell table: it renders WITHOUT a bar (see
-    // renderCompactStatusline). Lookups therefore miss and fall back to 0.
-]);
-const FILLED = '█';
-const EMPTY = '░';
-const BAR_WIDTH = STAGE_CELL_COMPLETED;
-const NO_AFTER_RATIO_HINT = 'after-ratio not recorded';
-function renderBar(filledCells) {
-    return `[${FILLED.repeat(filledCells)}${EMPTY.repeat(BAR_WIDTH - filledCells)}]`;
-}
-function renderLegacyBar(filledCells) {
-    return renderBar(filledCells);
-}
-/* eslint-enable no-magic-numbers */
+import { readCompactLifecycle } from './compact-lifecycle-store.js';
+import { CELL_BY_STAGE, COMPLETED_EXPIRY_MS, DEFAULT_STALE_AFTER_MS, LEGACY_JUST_COMPACTED_WINDOW_MS, NO_AFTER_RATIO_HINT, renderBar, renderLegacyBar, STAGE_CELL_COMPACTING, STAGE_CELL_VERIFYING, STAGE_CELL_COMPLETED } from './compact-statusline-cell-table.js';
+import { stateFromLifecycle, stateFromStalled } from './compact-statusline-state.js';
+export { COMPLETED_EXPIRY_MS } from './compact-statusline-cell-table.js';
 export function decideCompactStatusline(input) {
     const staleAfterMs = input.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
     const completedExpiryMs = input.completedExpiryMs ?? COMPLETED_EXPIRY_MS;
@@ -107,7 +58,7 @@ export function decideCompactStatusline(input) {
         projectRoot: input.projectRoot,
         sessionId: input.sessionId,
         nowMs: input.now,
-        staleAfterMs,
+        staleAfterMs
     });
     if (lifecycle.kind === 'valid') {
         // 10-second completed-expiry: once a compact lifecycle reaches
@@ -142,7 +93,7 @@ export function decideCompactStatusline(input) {
         return {
             kind: 'invalid',
             filledCells: 0,
-            detail: lifecycle.reason,
+            detail: lifecycle.reason
         };
     }
     // lifecycle.kind === 'missing' → fall back to legacy files.
@@ -150,52 +101,9 @@ export function decideCompactStatusline(input) {
         projectRoot: input.projectRoot,
         sessionId: input.sessionId,
         sessionDir,
-        now: input.now,
+        now: input.now
     });
 }
-function stateFromLifecycle(record) {
-    if (record.stage === 'failed') {
-        const failedAt = record.failedAt ?? 'compacting';
-        const state = {
-            kind: 'failed',
-            filledCells: CELL_BY_STAGE.get(failedAt) ?? STAGE_CELL_COMPACTING,
-            triggerRatio: record.triggerRatio,
-            redLine: record.redLine,
-            failedAt,
-        };
-        if (record.errorSummary !== undefined) {
-            return { ...state, detail: record.errorSummary };
-        }
-        return state;
-    }
-    const filledCells = CELL_BY_STAGE.get(record.stage) ?? 0;
-    const base = {
-        kind: record.stage,
-        filledCells,
-        triggerRatio: record.triggerRatio,
-        redLine: record.redLine,
-    };
-    if (record.stage === 'completed' && typeof record.afterRatio === 'number') {
-        return { ...base, afterRatio: record.afterRatio };
-    }
-    return base;
-}
-function stateFromStalled(record) {
-    const filledCells = CELL_BY_STAGE.get(record.stage) ?? STAGE_CELL_COMPACTING;
-    const detailText = record.stage === 'failed'
-        ? record.errorSummary
-        : `no heartbeat for ${record.stage} stage`;
-    const state = {
-        kind: 'stalled',
-        filledCells,
-        triggerRatio: record.triggerRatio,
-        redLine: record.redLine,
-    };
-    if (detailText !== undefined) {
-        return { ...state, detail: detailText };
-    }
-    return state;
-}
 function decideLegacyFallback(input) {
     const { sessionDir, now } = input;
     const pendingPath = `${sessionDir}/txt/auto-compact-pending.json`;
@@ -211,7 +119,7 @@ function decideLegacyFallback(input) {
                     filledCells: 0,
                     ...(typeof parsed.ratio === 'number' ? { triggerRatio: parsed.ratio } : {}),
                     ...(parsed.redLine === true ? { redLine: true } : {}),
-                    detail: pendingPath,
+                    detail: pendingPath
                 };
             }
         }
@@ -259,7 +167,7 @@ function decideLegacyFallback(input) {
             return {
                 kind: 'completed',
                 filledCells: 8,
-                detail: historyPath,
+                detail: historyPath
             };
         }
     }

package/dist/services/compact-statusline/compact-statusline-state.d.ts

@@ -0,0 +1,4 @@
+import type { CompactLifecycleRecord } from './compact-lifecycle-store.js';
+import { type CompactStatuslineState } from './compact-statusline-cell-table.js';
+export declare function stateFromLifecycle(record: CompactLifecycleRecord): CompactStatuslineState;
+export declare function stateFromStalled(record: CompactLifecycleRecord): CompactStatuslineState;

package/dist/services/compact-statusline/compact-statusline-state.js

@@ -0,0 +1,50 @@
+// src/services/compact-statusline/compact-statusline-state.ts
+//
+// Wave-5 class-A hoist (rid 2026-10-01-wave5-w5-3-compact-release): the two
+// lifecycle-state readers `stateFromLifecycle` and `stateFromStalled` moved
+// VERBATIM out of `compact-statusline-service.ts` (:210-252 at the split)
+// for the 300-raw-line cap. They are module-internal helpers of the parent
+// decision layer; nothing outside imports them. One-directional imports
+// only: this module reads the cell table, the parent reads both.
+import { CELL_BY_STAGE, STAGE_CELL_COMPACTING } from './compact-statusline-cell-table.js';
+export function stateFromLifecycle(record) {
+    if (record.stage === 'failed') {
+        const failedAt = record.failedAt ?? 'compacting';
+        const state = {
+            kind: 'failed',
+            filledCells: CELL_BY_STAGE.get(failedAt) ?? STAGE_CELL_COMPACTING,
+            triggerRatio: record.triggerRatio,
+            redLine: record.redLine,
+            failedAt
+        };
+        if (record.errorSummary !== undefined) {
+            return { ...state, detail: record.errorSummary };
+        }
+        return state;
+    }
+    const filledCells = CELL_BY_STAGE.get(record.stage) ?? 0;
+    const base = {
+        kind: record.stage,
+        filledCells,
+        triggerRatio: record.triggerRatio,
+        redLine: record.redLine
+    };
+    if (record.stage === 'completed' && typeof record.afterRatio === 'number') {
+        return { ...base, afterRatio: record.afterRatio };
+    }
+    return base;
+}
+export function stateFromStalled(record) {
+    const filledCells = CELL_BY_STAGE.get(record.stage) ?? STAGE_CELL_COMPACTING;
+    const detailText = record.stage === 'failed' ? record.errorSummary : `no heartbeat for ${record.stage} stage`;
+    const state = {
+        kind: 'stalled',
+        filledCells,
+        triggerRatio: record.triggerRatio,
+        redLine: record.redLine
+    };
+    if (detailText !== undefined) {
+        return { ...state, detail: detailText };
+    }
+    return state;
+}

package/dist/services/config/config-migration.js

@@ -55,14 +55,14 @@ export function planMigration(opts) {
             alreadyAtV2: true,
             detectedSchemaVersion,
             newConfigSchemaVersion: CONFIG_SCHEMA_VERSION_V2,
-            willMigrateFields: [],
+            willMigrateFields: []
         };
     }
     return {
         alreadyAtV2: false,
         detectedSchemaVersion,
         newConfigSchemaVersion: CONFIG_SCHEMA_VERSION_V2,
-        willMigrateFields,
+        willMigrateFields
     };
 }
 export function executeMigration(opts) {

package/dist/services/config/config-restore.js

@@ -71,7 +71,7 @@ export function restoreField(opts) {
         field: opts.field,
         value: bak[opts.field],
         source: 'config.json.1.x.bak',
-        restoredAt: new Date().toISOString(),
+        restoredAt: new Date().toISOString()
     };
     writeFileSync(sidecar, JSON.stringify(payload, null, 2) + '\n', 'utf8');
     return { available: true, field: opts.field, applied: true, sidecarPath: sidecar };

package/dist/services/config/config-rollback.js

@@ -9,7 +9,7 @@ export function planRollback() {
     return {
         available: true,
         detectedVersion: raw.version ?? null,
-        backupPath: backup,
+        backupPath: backup
     };
 }
 export function executeRollback(opts) {

package/dist/services/config/config-safety.js

@@ -43,10 +43,14 @@ function normalizeBoundaryPath(path) {
     catch {
         realPath = resolved;
     }
-    return process.platform === 'win32' || process.platform === 'darwin' ? realPath.toLowerCase() : realPath;
+    return process.platform === 'win32' || process.platform === 'darwin'
+        ? realPath.toLowerCase()
+        : realPath;
 }
 function getHomeBoundaryPaths() {
-    return new Set([homedir(), process.env.HOME, process.env.USERPROFILE].filter((path) => typeof path === 'string' && path.length > 0).map(normalizeBoundaryPath));
+    return new Set([homedir(), process.env.HOME, process.env.USERPROFILE]
+        .filter((path) => typeof path === 'string' && path.length > 0)
+        .map(normalizeBoundaryPath));
 }
 export function findProjectRoot(startPath) {
     const homeBoundaryPaths = getHomeBoundaryPaths();
@@ -54,7 +58,8 @@ export function findProjectRoot(startPath) {
     let parent = dirname(current);
     let pkgRoot = null;
     while (current !== parent && !homeBoundaryPaths.has(normalizeBoundaryPath(current))) {
-        if (existsSync(resolve(current, '.peaks', 'config.json')) && isSafeProjectConfigMarker(current)) {
+        if (existsSync(resolve(current, '.peaks', 'config.json')) &&
+            isSafeProjectConfigMarker(current)) {
             return current;
         }
         // .git is the definitive project root — return immediately
@@ -77,7 +82,8 @@ export function resolveProjectRootForConfig(startPath) {
     let parent = dirname(current);
     let pkgRoot = null;
     while (current !== parent && !homeBoundaryPaths.has(normalizeBoundaryPath(current))) {
-        if (existsSync(resolve(current, '.peaks', 'config.json')) && isSafeProjectConfigMarker(current)) {
+        if (existsSync(resolve(current, '.peaks', 'config.json')) &&
+            isSafeProjectConfigMarker(current)) {
             return current;
         }
         if (existsSync(resolve(current, '.git'))) {
@@ -213,7 +219,8 @@ function resolveProjectRootFromGit(startPath) {
             return null;
         rawRoot = resolve(trimmed);
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         // git not on PATH, startPath is not in a repo, or some other
         // benign failure — fall through to the heuristic.
         return null;
@@ -327,7 +334,9 @@ function validateProjectBootstrapConfigPath(projectRootPath, peaksPath, configPa
     const projectRootReal = realpathSync(projectRootPath);
     const peaksStats = lstatSync(peaksPath);
     const peaksReal = realpathSync(peaksPath);
-    if (!peaksStats.isDirectory() || peaksStats.isSymbolicLink() || peaksReal !== resolve(projectRootReal, '.peaks')) {
+    if (!peaksStats.isDirectory() ||
+        peaksStats.isSymbolicLink() ||
+        peaksReal !== resolve(projectRootReal, '.peaks')) {
         throw new Error('Project config path must stay inside the project root');
     }
     try {
@@ -359,7 +368,9 @@ export function validateUserConfigPathForWrite(configPath) {
     const userRootReal = realpathSync(userRoot);
     const peaksStats = lstatSync(peaksPath);
     const peaksReal = realpathSync(peaksPath);
-    if (!peaksStats.isDirectory() || peaksStats.isSymbolicLink() || peaksReal !== resolve(userRootReal, '.peaks')) {
+    if (!peaksStats.isDirectory() ||
+        peaksStats.isSymbolicLink() ||
+        peaksReal !== resolve(userRootReal, '.peaks')) {
         throw new Error('User config path must stay inside the user root');
     }
     try {
@@ -395,7 +406,9 @@ export function validateArtifactWorkspaceMarkerPath(artifactRoot, peaksPath, mar
     const artifactRootReal = realpathSync(artifactRoot);
     const peaksStats = lstatSync(peaksPath);
     const peaksReal = realpathSync(peaksPath);
-    if (!peaksStats.isDirectory() || peaksStats.isSymbolicLink() || peaksReal !== resolve(artifactRootReal, '.peaks')) {
+    if (!peaksStats.isDirectory() ||
+        peaksStats.isSymbolicLink() ||
+        peaksReal !== resolve(artifactRootReal, '.peaks')) {
         throw new Error('Artifact workspace marker must stay inside the artifact workspace');
     }
     try {
@@ -420,7 +433,10 @@ export function validateArtifactWorkspaceMarkerPath(artifactRoot, peaksPath, mar
 function validateOpenConfigFile(fd, tempPath, errorMessage) {
     const fdStats = fstatSync(fd);
     const pathStats = lstatSync(tempPath);
-    if (!fdStats.isFile() || !pathStats.isFile() || fdStats.dev !== pathStats.dev || fdStats.ino !== pathStats.ino) {
+    if (!fdStats.isFile() ||
+        !pathStats.isFile() ||
+        fdStats.dev !== pathStats.dev ||
+        fdStats.ino !== pathStats.ino) {
         throw new Error(errorMessage);
     }
     if (fdStats.nlink !== 1 || pathStats.nlink !== 1) {
@@ -432,7 +448,9 @@ function getSafeTempOpenFlags() {
     return typeof constants.O_NOFOLLOW === 'number' ? baseFlags | constants.O_NOFOLLOW : baseFlags;
 }
 function getSafeReadOpenFlags() {
-    return typeof constants.O_NOFOLLOW === 'number' ? constants.O_RDONLY | constants.O_NOFOLLOW : constants.O_RDONLY;
+    return typeof constants.O_NOFOLLOW === 'number'
+        ? constants.O_RDONLY | constants.O_NOFOLLOW
+        : constants.O_RDONLY;
 }
 export function readConfigFileSafely(configPath, errorMessage) {
     const fd = openSync(configPath, getSafeReadOpenFlags());