peaks-loop 4.0.54 → 4.1.1

package/dist/services/comments/repo-path-probe.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Is a path required to exist in a checkout at all?
+ *
+ * The dominant false positive on `dead-reference` was never a stale comment: it
+ * was a correct reference to a file git is told not to track. Ranked over this
+ * repository, the top twelve "dead" citations were `.claude/settings.local.json`,
+ * `.peaks/_runtime/session.json`, `.peaks/.session.json`,
+ * `.peaks/_runtime/active-skill.json`, `.codegraph/config.json`,
+ * `.peaks/preferences.json` and friends — all generated state, all named
+ * correctly by the code that writes them.
+ *
+ * So the probe answers "exists OR ignored", and the ignore reading is deliberately
+ * bounded: trailing-slash prefixes, whole-path entries, and bare-basename entries.
+ * That limit has a direction, and the direction is the safe one — a rule
+ * `.gitignore` expresses fancily (negation, `**`, character classes) is NOT read
+ * here, so such a path stays reported. A missed exemption is a finding a human
+ * reads and dismisses; a phantom exemption is a silent false green in a gate that
+ * exists to catch claims that outlived their referent.
+ */
+type IgnoreRules = {
+    /** Directory rules: match the path and everything below it. */
+    readonly prefixes: readonly string[];
+    /** File rules written with a slash: match that exact repo-relative path. */
+    readonly exact: ReadonlySet<string>;
+    /** Basename rules: match that name in any directory. */
+    readonly basenames: ReadonlySet<string>;
+};
+/** True when `.gitignore` says this repo-relative path need not be on disk. */
+export declare function isIgnoredPath(relPath: string, rules: IgnoreRules): boolean;
+/**
+ * Build the existence probe a scan should use: a real filesystem lookup, widened
+ * by the repository's own ignore list read from its root.
+ *
+ * The second export below is the deliberate exception. "Is this an installed
+ * package name?" must NOT be widened by the ignore list, because `node_modules` is
+ * itself ignored — an ignore-aware probe answers yes for every first segment, and
+ * the whole `dead-reference` count collapses to zero while looking perfectly
+ * healthy.
+ */
+export declare function createRepoProbe(repoRoot: string): (relPath: string) => boolean;
+/** Filesystem-only existence, for questions where "git ignores it" is no answer. */
+export declare function createFsProbe(repoRoot: string): (relPath: string) => boolean;
+export {};

package/dist/services/comments/repo-path-probe.js

@@ -0,0 +1,78 @@
+/**
+ * Is a path required to exist in a checkout at all?
+ *
+ * The dominant false positive on `dead-reference` was never a stale comment: it
+ * was a correct reference to a file git is told not to track. Ranked over this
+ * repository, the top twelve "dead" citations were `.claude/settings.local.json`,
+ * `.peaks/_runtime/session.json`, `.peaks/.session.json`,
+ * `.peaks/_runtime/active-skill.json`, `.codegraph/config.json`,
+ * `.peaks/preferences.json` and friends — all generated state, all named
+ * correctly by the code that writes them.
+ *
+ * So the probe answers "exists OR ignored", and the ignore reading is deliberately
+ * bounded: trailing-slash prefixes, whole-path entries, and bare-basename entries.
+ * That limit has a direction, and the direction is the safe one — a rule
+ * `.gitignore` expresses fancily (negation, `**`, character classes) is NOT read
+ * here, so such a path stays reported. A missed exemption is a finding a human
+ * reads and dismisses; a phantom exemption is a silent false green in a gate that
+ * exists to catch claims that outlived their referent.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+function parseGitignore(source) {
+    const prefixes = [];
+    const exact = new Set();
+    const basenames = new Set();
+    for (const raw of source.split(/\r?\n/)) {
+        const rule = raw.trim();
+        if (rule.length === 0 || rule.startsWith('#') || rule.startsWith('!'))
+            continue;
+        const cleaned = rule.replace(/^\//, '').replace(/\/$/, '');
+        if (cleaned.length === 0)
+            continue;
+        if (!cleaned.includes('/')) {
+            basenames.add(cleaned);
+            continue;
+        }
+        // A rule with a slash is registered both ways rather than guessed: `.peaks/_runtime/`
+        // is a directory, `.claude/settings.local.json` is one file, and a rule that
+        // matched only `path/` silently failed every single-file ignore in the
+        // repository. Registering both costs nothing — an over-broad directory prefix
+        // here can only ever name the path it was written for and things under it.
+        prefixes.push(`${cleaned}/`);
+        exact.add(cleaned);
+    }
+    return { prefixes, exact, basenames };
+}
+/** True when `.gitignore` says this repo-relative path need not be on disk. */
+export function isIgnoredPath(relPath, rules) {
+    const posix = relPath.replace(/\\/g, '/');
+    if (rules.exact.has(posix))
+        return true;
+    if (rules.prefixes.some((prefix) => posix.startsWith(prefix)))
+        return true;
+    const segments = posix.split('/');
+    return segments.some((segment) => rules.basenames.has(segment));
+}
+/**
+ * Build the existence probe a scan should use: a real filesystem lookup, widened
+ * by the repository's own ignore list read from its root.
+ *
+ * The second export below is the deliberate exception. "Is this an installed
+ * package name?" must NOT be widened by the ignore list, because `node_modules` is
+ * itself ignored — an ignore-aware probe answers yes for every first segment, and
+ * the whole `dead-reference` count collapses to zero while looking perfectly
+ * healthy.
+ */
+export function createRepoProbe(repoRoot) {
+    let rules = { prefixes: [], exact: new Set(), basenames: new Set() };
+    const ignorePath = join(repoRoot, '.gitignore');
+    if (existsSync(ignorePath)) {
+        rules = parseGitignore(readFileSync(ignorePath, 'utf8'));
+    }
+    return (relPath) => existsSync(join(repoRoot, relPath)) || isIgnoredPath(relPath, rules);
+}
+/** Filesystem-only existence, for questions where "git ignores it" is no answer. */
+export function createFsProbe(repoRoot) {
+    return (relPath) => existsSync(join(repoRoot, relPath));
+}

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

@@ -43,7 +43,8 @@ function readLatestUsageRow(projectRoot, sessionId) {
             return null;
         return JSON.parse(last);
     }
-    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)
         return null;
     }
 }

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

@@ -1,66 +1,6 @@
 import { type Phase, type Severity } from './decision-tables.js';
-/** Token window sizes supported by the suggest service. */
-export type WindowKind = '200k' | '1m';
-export interface SuggestOptions {
-    readonly projectRoot: string;
-    readonly sessionId: string | null;
-    readonly env?: NodeJS.ProcessEnv;
-}
-export interface SuggestResult {
-    readonly shouldSuggest: boolean;
-    readonly reason: string;
-    readonly ratio: number;
-    readonly windowKind: WindowKind;
-    readonly tokensUsed: number;
-    readonly toolCalls: number;
-    readonly thresholds: {
-        readonly contextTokens: number;
-        readonly contextInterval: number;
-        readonly toolCalls: number;
-    };
-    readonly dataUnavailable: boolean;
-    readonly source: 'usage-jsonl' | 'env-vars' | 'none';
-}
-/** Default tool-call threshold before first suggestion. */
-export declare const DEFAULT_TOOL_CALL_THRESHOLD = 50;
-/** Default additional tool calls before the suggestion repeats. */
-export declare const TOOL_CALL_REMIND_STEP = 25;
-/** Default context-size threshold on a 200k window. */
-export declare const DEFAULT_CONTEXT_THRESHOLD_200K = 160000;
-/** Default context-size threshold on a 1M window. */
-export declare const DEFAULT_CONTEXT_THRESHOLD_1M = 250000;
-/** Default re-remind interval for context size. */
-export declare const DEFAULT_CONTEXT_INTERVAL = 60000;
+import { type SuggestOptions, type SuggestResult, type DryRunOptions, type DryRunResult } from './suggest-types.js';
 export declare function suggestCompact(options: SuggestOptions): SuggestResult;
-/**
- * `peaks compact dry-run` envelope — composed of (a) suggest, (b)
- * recommend, (c) survival. Pure composition over the helpers; no
- * additional I/O. The CLI emits this so the LLM can decide in one
- * tool-call whether to act.
- */
-export interface DryRunOptions {
-    readonly projectRoot: string;
-    readonly sessionId: string | null;
-    readonly from?: Phase;
-    readonly to?: Phase;
-    readonly env?: NodeJS.ProcessEnv;
-}
-export interface DryRunResult {
-    readonly action: 'compact' | 'skip';
-    readonly suggest: SuggestResult;
-    readonly recommend: {
-        readonly from: Phase | null;
-        readonly to: Phase | null;
-        readonly shouldCompact: boolean;
-        readonly severity: Severity | null;
-        readonly rationale: string | null;
-        readonly suggestedMessage: string | null;
-    };
-    readonly survival: {
-        readonly persists: readonly string[];
-        readonly lost: readonly string[];
-    };
-}
 export declare function dryRunCompact(options: DryRunOptions): DryRunResult;
 export declare function buildRecommendEnvelopePure(from: Phase, to: Phase): {
     from: Phase;
@@ -72,3 +12,5 @@ export declare function buildRecommendEnvelopePure(from: Phase, to: Phase): {
 };
 export { PHASE_TRANSITIONS, lookupPhaseTransition, buildSuggestedCompactMessage, PHASES, isPhase, SURVIVAL_TABLE } from './decision-tables.js';
 export type { Phase, Severity } from './decision-tables.js';
+export { DEFAULT_TOOL_CALL_THRESHOLD, TOOL_CALL_REMIND_STEP, DEFAULT_CONTEXT_THRESHOLD_200K, DEFAULT_CONTEXT_THRESHOLD_1M, DEFAULT_CONTEXT_INTERVAL } from './suggest-types.js';
+export type { WindowKind, SuggestOptions, SuggestResult, DryRunOptions, DryRunResult } from './suggest-types.js';

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

@@ -25,19 +25,10 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { lookupPhaseTransition, buildSuggestedCompactMessage, SURVIVAL_TABLE } from './decision-tables.js';
+import { DEFAULT_TOOL_CALL_THRESHOLD, DEFAULT_CONTEXT_THRESHOLD_200K, DEFAULT_CONTEXT_THRESHOLD_1M, DEFAULT_CONTEXT_INTERVAL } from './suggest-types.js';
 /** Snapshot of the survival table for the dry-run envelope. */
 const SURVIVAL_TABLE_PERSISTS = SURVIVAL_TABLE.persists;
 const SURVIVAL_TABLE_LOST = SURVIVAL_TABLE.lost;
-/** 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;
 function readLatestUsageRow(projectRoot, sessionId) {
     const path = join(projectRoot, '.peaks', '_runtime', sessionId, 'usage.jsonl');
     if (!existsSync(path))
@@ -52,7 +43,8 @@ function readLatestUsageRow(projectRoot, sessionId) {
             return null;
         return JSON.parse(last);
     }
-    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)
         return null;
     }
 }
@@ -118,7 +110,9 @@ export function suggestCompact(options) {
     const windowCapacity = windowKind === '1m' ? 1_000_000 : 200_000;
     const effectiveContextThreshold = contextThreshold > 0
         ? contextThreshold
-        : (windowKind === '1m' ? DEFAULT_CONTEXT_THRESHOLD_1M : DEFAULT_CONTEXT_THRESHOLD_200K);
+        : windowKind === '1m'
+            ? DEFAULT_CONTEXT_THRESHOLD_1M
+            : DEFAULT_CONTEXT_THRESHOLD_200K;
     const ratio = windowCapacity > 0 ? tokensUsed / windowCapacity : 0;
     const dataUnavailable = tokensUsed === 0 && toolCalls === 0;
     // Two-signal suggestion. The context signal is primary: the LLM
@@ -201,3 +195,6 @@ export function buildRecommendEnvelopePure(from, to) {
 // to keep the validation path co-located with the recommend envelope
 // builder.
 export { PHASE_TRANSITIONS, lookupPhaseTransition, buildSuggestedCompactMessage, PHASES, isPhase, SURVIVAL_TABLE } from './decision-tables.js';
+// The public types and default thresholds live in suggest-types.ts; they are
+// re-exported here so importers keep using this same path.
+export { DEFAULT_TOOL_CALL_THRESHOLD, TOOL_CALL_REMIND_STEP, DEFAULT_CONTEXT_THRESHOLD_200K, DEFAULT_CONTEXT_THRESHOLD_1M, DEFAULT_CONTEXT_INTERVAL } from './suggest-types.js';

package/dist/services/compact/suggest-types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * `src/services/compact/suggest-types.ts`
+ *
+ * Type declarations and default-threshold constants extracted verbatim
+ * from `suggest-service.ts` (wave 2, file-size cap campaign) so the
+ * service stays under the 300 raw-line cap. Mechanical move only —
+ * `suggest-service.ts` re-exports every public name from this module.
+ */
+import type { Phase, Severity } from './decision-tables.js';
+/** Token window sizes supported by the suggest service. */
+export type WindowKind = '200k' | '1m';
+export interface SuggestOptions {
+    readonly projectRoot: string;
+    readonly sessionId: string | null;
+    readonly env?: NodeJS.ProcessEnv;
+}
+export interface SuggestResult {
+    readonly shouldSuggest: boolean;
+    readonly reason: string;
+    readonly ratio: number;
+    readonly windowKind: WindowKind;
+    readonly tokensUsed: number;
+    readonly toolCalls: number;
+    readonly thresholds: {
+        readonly contextTokens: number;
+        readonly contextInterval: number;
+        readonly toolCalls: number;
+    };
+    readonly dataUnavailable: boolean;
+    readonly source: 'usage-jsonl' | 'env-vars' | 'none';
+}
+/** Default tool-call threshold before first suggestion. */
+export declare const DEFAULT_TOOL_CALL_THRESHOLD = 50;
+/** Default additional tool calls before the suggestion repeats. */
+export declare const TOOL_CALL_REMIND_STEP = 25;
+/** Default context-size threshold on a 200k window. */
+export declare const DEFAULT_CONTEXT_THRESHOLD_200K = 160000;
+/** Default context-size threshold on a 1M window. */
+export declare const DEFAULT_CONTEXT_THRESHOLD_1M = 250000;
+/** Default re-remind interval for context size. */
+export declare const DEFAULT_CONTEXT_INTERVAL = 60000;
+export interface UsageRow {
+    ts?: string;
+    tokens?: number;
+    toolCalls?: number;
+    modelKind?: '200k' | '1m';
+}
+/**
+ * `peaks compact dry-run` envelope — composed of (a) suggest, (b)
+ * recommend, (c) survival. Pure composition over the helpers; no
+ * additional I/O. The CLI emits this so the LLM can decide in one
+ * tool-call whether to act.
+ */
+export interface DryRunOptions {
+    readonly projectRoot: string;
+    readonly sessionId: string | null;
+    readonly from?: Phase;
+    readonly to?: Phase;
+    readonly env?: NodeJS.ProcessEnv;
+}
+export interface DryRunResult {
+    readonly action: 'compact' | 'skip';
+    readonly suggest: SuggestResult;
+    readonly recommend: {
+        readonly from: Phase | null;
+        readonly to: Phase | null;
+        readonly shouldCompact: boolean;
+        readonly severity: Severity | null;
+        readonly rationale: string | null;
+        readonly suggestedMessage: string | null;
+    };
+    readonly survival: {
+        readonly persists: readonly string[];
+        readonly lost: readonly string[];
+    };
+}

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;