peaks-loop 4.0.16 → 4.0.18

package/dist/services/skills/hooks-settings-service.js

@@ -4,7 +4,7 @@ import { resolve } from 'node:path';
 import { assertSafeSettingsFile } from '../ide/shared/safe-path.js';
 import { atomicWriteJson, readJsonObjectFile } from '../ide/shared/atomic-json.js';
 import { getAdapter } from '../ide/ide-registry.js';
-import { HOOK_OUTER_CACHE_COMMAND, HOOK_OUTER_CACHE_EVENT, HOOK_OUTER_CACHE_SENTINEL } from './outer-cache-hook-constants.js';
+import { HOOK_OUTER_CACHE_COMMAND, HOOK_OUTER_CACHE_EVENT, HOOK_OUTER_CACHE_SENTINEL, HOOK_WORKSPACE_INIT_COMMAND, HOOK_WORKSPACE_INIT_EVENT, HOOK_WORKSPACE_INIT_SENTINEL } from './session-start-hook-constants.js';
 // --- Module-level defaults (claude-code) -----------------------------------
 // These exports remain for backward compat — tests and downstream callers
 // that only care about Claude Code can keep importing them. The per-IDE
@@ -187,6 +187,18 @@ export function readInstalledEntriesFromSettings(settings, ide) {
  * entry is appended for Claude Code only (SessionStart is a Claude-Code-
  * specific event key today).
  */
+/**
+ * Slice 2026-08-06-codegate-vendor-neutral — code-gate hook entry.
+ * Vendor-neutral command (`peaks code-gate --json`); the CLI adapter
+ * lives in `src/cli/commands/code-gate-command.ts` and the decision
+ * logic lives in `src/services/hooks/pre-tool-code-gate.ts`. The
+ * shell-script sibling (`src/services/hooks/pre-tool-code-gate.sh`)
+ * encodes the same logic for non-Node harnesses.
+ */
+export const HOOK_CODE_GATE_SENTINEL = 'peaks code-gate';
+export const HOOK_CODE_GATE_MATCHER = 'Edit|Write|MultiEdit';
+export const HOOK_CODE_GATE_EVENT = 'PreToolUse';
+export const HOOK_CODE_GATE_COMMAND = `peaks code-gate --json`;
 function resolveHookEntries(ide, _skipProgress = false) {
     const spec = resolveHookSpec(ide);
     const entries = [
@@ -199,6 +211,31 @@ function resolveHookEntries(ide, _skipProgress = false) {
             command: HOOK_OUTER_CACHE_COMMAND,
             event: HOOK_OUTER_CACHE_EVENT
         });
+        // Slice rid-statusline-stale-ux AC-2: SessionStart outer-cache
+        // write is followed by `peaks session primer` entry so that
+        // rotation + presence cleanup fire BEFORE the first statusline
+        // render of a fresh session. The new subcommand is idempotent
+        // and short-circuits when the binding already matches — safe to
+        // call on every SessionStart. Order matters conceptually:
+        // outer-cache write must come first (the primer's
+        // ensureSessionWithRotation reads the current outer session id).
+        entries.push({
+            sentinel: HOOK_WORKSPACE_INIT_SENTINEL,
+            matcher: '',
+            command: HOOK_WORKSPACE_INIT_COMMAND,
+            event: HOOK_WORKSPACE_INIT_EVENT
+        });
+        // Slice 2026-08-06-codegate-vendor-neutral: code-gate entry on
+        // Edit|Write|MultiEdit matcher. Vendor-neutral command
+        // (`peaks code-gate --json`); the CLI adapter lives in
+        // `src/cli/commands/code-gate-command.ts` and the underlying
+        // decision logic is in `src/services/hooks/pre-tool-code-gate.ts`.
+        entries.push({
+            sentinel: HOOK_CODE_GATE_SENTINEL,
+            matcher: HOOK_CODE_GATE_MATCHER,
+            command: HOOK_CODE_GATE_COMMAND,
+            event: HOOK_CODE_GATE_EVENT
+        });
     }
     return entries;
 }
@@ -214,9 +251,17 @@ function resolveLegacySentinels(ide) {
     }
     // Slice 2026-08-06-session-outer-cache: include the SessionStart outer-cache
     // sentinel so uninstall strips it alongside the gate-enforce entry.
-    const base = [HOOK_ENFORCE_SENTINEL, LEGACY_PROGRESS_START_SENTINEL];
+    // Slice 2026-08-06-codegate-vendor-neutral: also include the code-gate
+    // sentinel so uninstall strips the Edit|Write|MultiEdit entry alongside
+    // the rest of the peaks-managed entries.
+    const base = [HOOK_ENFORCE_SENTINEL, LEGACY_PROGRESS_START_SENTINEL, HOOK_CODE_GATE_SENTINEL];
     if (ide === 'claude-code') {
-        return [...base, HOOK_OUTER_CACHE_SENTINEL];
+        // Slice rid-statusline-stale-ux AC-2: include the SessionStart
+        // workspace-init primer sentinel so uninstall strips it alongside
+        // the gate-enforce entry, and so hand-added entries matching this
+        // sentinel are recognized as peaks-managed (not stripped as
+        // non-Peaks).
+        return [...base, HOOK_OUTER_CACHE_SENTINEL, HOOK_WORKSPACE_INIT_SENTINEL];
     }
     return base;
 }

package/dist/services/skills/{outer-cache-hook-constants.d.ts → session-start-hook-constants.d.ts}

@@ -15,6 +15,13 @@
  * Only Claude Code supports SessionStart today; future adapters opt
  * in by extending `resolveHookEntries` and adding an adapter-driven
  * substitution for the `${...}` project-dir placeholder.
+ *
+ * Slice rid-statusline-stale-ux AC-2: renamed from
+ * `outer-cache-hook-constants.ts` (per RD §10 M-3) and extended with
+ * the SessionStart workspace-init primer constants. The primer fires
+ * `peaks session primer --project <path>` immediately after the
+ * outer-cache write so rotation + presence cleanup run BEFORE the
+ * first statusline render of a fresh session.
  */
 /** Sentinel substring identifying a SessionStart outer-cache hook entry. */
 export declare const HOOK_OUTER_CACHE_SENTINEL = "peaks outer-cache write";
@@ -22,3 +29,16 @@ export declare const HOOK_OUTER_CACHE_SENTINEL = "peaks outer-cache write";
 export declare const HOOK_OUTER_CACHE_COMMAND = "peaks outer-cache write --project \"${CLAUDE_PROJECT_DIR}\"";
 /** SessionStart hook event key for Claude Code. */
 export declare const HOOK_OUTER_CACHE_EVENT = "SessionStart";
+/**
+ * Slice rid-statusline-stale-ux AC-2: SessionStart workspace-init
+ * primer sentinel. Identifies the SessionStart entry that runs
+ * `peaks session primer --project <path>` so rotation + presence
+ * cleanup fire on every fresh session, before the first statusline
+ * render of that session. The primer is idempotent and short-
+ * circuits when the binding already matches.
+ */
+export declare const HOOK_WORKSPACE_INIT_SENTINEL = "peaks session primer";
+/** SessionStart hook command for the primer. */
+export declare const HOOK_WORKSPACE_INIT_COMMAND = "peaks session primer --project \"${CLAUDE_PROJECT_DIR}\"";
+/** SessionStart hook event key (same as outer-cache). */
+export declare const HOOK_WORKSPACE_INIT_EVENT = "SessionStart";

package/dist/services/skills/{outer-cache-hook-constants.js → session-start-hook-constants.js}

@@ -15,6 +15,13 @@
  * Only Claude Code supports SessionStart today; future adapters opt
  * in by extending `resolveHookEntries` and adding an adapter-driven
  * substitution for the `${...}` project-dir placeholder.
+ *
+ * Slice rid-statusline-stale-ux AC-2: renamed from
+ * `outer-cache-hook-constants.ts` (per RD §10 M-3) and extended with
+ * the SessionStart workspace-init primer constants. The primer fires
+ * `peaks session primer --project <path>` immediately after the
+ * outer-cache write so rotation + presence cleanup run BEFORE the
+ * first statusline render of a fresh session.
  */
 /** Sentinel substring identifying a SessionStart outer-cache hook entry. */
 export const HOOK_OUTER_CACHE_SENTINEL = 'peaks outer-cache write';
@@ -22,3 +29,16 @@ export const HOOK_OUTER_CACHE_SENTINEL = 'peaks outer-cache write';
 export const HOOK_OUTER_CACHE_COMMAND = `peaks outer-cache write --project "\${CLAUDE_PROJECT_DIR}"`;
 /** SessionStart hook event key for Claude Code. */
 export const HOOK_OUTER_CACHE_EVENT = 'SessionStart';
+/**
+ * Slice rid-statusline-stale-ux AC-2: SessionStart workspace-init
+ * primer sentinel. Identifies the SessionStart entry that runs
+ * `peaks session primer --project <path>` so rotation + presence
+ * cleanup fire on every fresh session, before the first statusline
+ * render of that session. The primer is idempotent and short-
+ * circuits when the binding already matches.
+ */
+export const HOOK_WORKSPACE_INIT_SENTINEL = 'peaks session primer';
+/** SessionStart hook command for the primer. */
+export const HOOK_WORKSPACE_INIT_COMMAND = `peaks session primer --project "\${CLAUDE_PROJECT_DIR}"`;
+/** SessionStart hook event key (same as outer-cache). */
+export const HOOK_WORKSPACE_INIT_EVENT = 'SessionStart';

package/dist/services/skills/skill-statusline-renderer.d.ts

@@ -1,4 +1,4 @@
-import type { StatusLineModel } from './skill-statusline-service.js';
+import type { StatusLineModel, TwentyFourHourOverlay } from './skill-statusline-service.js';
 import { computeRootSuffix as computeRootSuffixImpl } from './skill-statusline-sid-suffix.js';
 export { formatShortSid } from './skill-statusline-sid-suffix.js';
 export declare const computeRootSuffix: typeof computeRootSuffixImpl;
@@ -17,6 +17,55 @@ export type StatusLineCapability = 'ansi-unicode' | 'unicode' | 'ascii';
 export interface StatusLineRenderOptions {
     readonly capability: StatusLineCapability;
 }
+/**
+ * Glyph palette per capability. Status glyphs (active / idle / warning),
+ * separators (· / › / ▸ / ASCII variants), and the diagnostic marker
+ * (`presence unreadable`). Unicode glyphs use widely-supported characters;
+ * ASCII keeps byte-identical shape across encodings.
+ *
+ * Compact glyphs are the unicode quadrant marks ◐◑◒◓, the check ✓, and the
+ * ballot ✕. ASCII uses bracket/plus/star/x. Bar characters are █/░ in
+ * unicode and #/- in ASCII. Ratios are joined with `·` (` . ` for ASCII)
+ * and the before→after arrow is `→` (-> for ASCII).
+ */
+interface StatusPalette {
+    readonly active: string;
+    readonly idleStale: string;
+    readonly idle: string;
+    readonly warning: string;
+    readonly inlineSeparator: string;
+    readonly trailSeparator: string;
+    readonly idleLabel: string;
+    readonly invalidMessage: string;
+    readonly compact: CompactPalette;
+    readonly barFilled: string;
+    readonly barEmpty: string;
+    readonly ratioArrow: string;
+}
+interface CompactPalette {
+    readonly queued: string;
+    readonly preparing: string;
+    readonly compacting: string;
+    readonly verifying: string;
+    readonly completed: string;
+    readonly failed: string;
+}
+export declare function formatHumanAge(ageMs: number | null): string;
+/**
+ * Slice rid-statusline-24h-overlay (2026-08-10): format the 24h-mode
+ * overlay suffix appended after the existing `<baseMode>` token in
+ * the ACTIVE state. Returns `''` when the overlay is `null` (missing
+ * file / corrupt file / wrong shape — see `read24hOverlay`).
+ *
+ * Output shape (ASCII palette): ` . [24h-<lowercase-state>]`
+ * Output shape (unicode palette): ` · [24h-<lowercase-state>]`
+ *
+ * en-US only; i18n deferred to a future slice (PRD §Non-goals.5).
+ * The `[24h-...]` prefix is a deliberate marker so the user can
+ * visually distinguish a 24h-mode substate from a base-mode token
+ * like `[full-auto]`.
+ */
+export declare function format24hSuffix(overlay: TwentyFourHourOverlay | null, palette: StatusPalette, capability: StatusLineCapability, noColor: boolean): string;
 export declare function resolveStatusLineCapability(input: {
     readonly env: NodeJS.ProcessEnv;
     readonly isTTY: boolean;

package/dist/services/skills/skill-statusline-renderer.js

@@ -108,6 +108,12 @@ function buildPalette(capability, noColor) {
         return {
             active: '*',
             idle: 'o',
+            // Slice rid-statusline-stale-ux AC-1: stale residue uses the same
+            // glyph as `idle` (`o`) but stays static (no slow-blink — the user
+            // is reading a *previous* session's residue, not a live idle state).
+            // The neutral copy `(previous session · N days ago)` is the
+            // decisive signal; the glyph is auxiliary.
+            idleStale: 'o',
             warning,
             inlineSeparator: ' . ',
             trailSeparator: ' -> ',
@@ -125,6 +131,11 @@ function buildPalette(capability, noColor) {
     return {
         active: brandGlyph('●'),
         idle: blinkBrand('○'),
+        // Slice rid-statusline-stale-ux AC-1: muted slate (`#AAAAC8` dim)
+        // — slow-blink OFF, distinct from `idle` (slow-blink brand) and
+        // `warning` (yellow invalid-presence). The stale branch is
+        // semantically "previous-session residue" (neutral), NOT an error.
+        idleStale: dimBrand('○'),
         warning,
         inlineSeparator: brand(' · '),
         trailSeparator: brand(' → '),
@@ -181,6 +192,10 @@ function paletteFor(capability, noColor) {
     return buildPalette(capability ?? DEFAULT_CAPABILITY, noColor);
 }
 function formatAge(ageMs) {
+    // Slice rid-statusline-stale-ux AC-1: this legacy `stale <N>h/m`
+    // token is NO LONGER used by renderStale. Kept exported / defined
+    // for any downstream caller / test that still asserts against the
+    // `stale` substring. The active renderer path uses `formatHumanAge`.
     if (ageMs === null)
         return '';
     const hours = Math.round(ageMs / (60 * 60 * 1000));
@@ -189,11 +204,69 @@ function formatAge(ageMs) {
     const minutes = Math.max(1, Math.round(ageMs / (60 * 1000)));
     return `stale ${minutes}m`;
 }
+// Slice rid-statusline-stale-ux AC-1 + perf H2: human-friendly neutral
+// age label for the stale branch. en-US strings per RD §5 R1 (codebase
+// consistency); zh-CN deferred to a future i18n slice. Backed by a
+// bounded Map cache (parity with `formatShortSid` memoization at
+// `skill-statusline-sid-suffix.ts`).
+const HUMAN_AGE_CACHE = new Map();
+const HUMAN_AGE_CACHE_LIMIT = 16;
+export function formatHumanAge(ageMs) {
+    if (ageMs === null)
+        return 'unknown';
+    const cached = HUMAN_AGE_CACHE.get(ageMs);
+    if (cached !== undefined)
+        return cached;
+    let result;
+    if (ageMs < 5 * 60 * 1000) {
+        result = 'just now';
+    }
+    else {
+        const minutes = Math.round(ageMs / (60 * 1000));
+        if (minutes < 60) {
+            result = `${minutes} minute${minutes === 1 ? '' : 's'} ago`;
+        }
+        else {
+            const hours = Math.round(ageMs / (60 * 60 * 1000));
+            if (hours < 24) {
+                result = `${hours} hour${hours === 1 ? '' : 's'} ago`;
+            }
+            else {
+                const days = Math.round(ageMs / (24 * 60 * 60 * 1000));
+                result = `${days} day${days === 1 ? '' : 's'} ago`;
+            }
+        }
+    }
+    if (HUMAN_AGE_CACHE.size >= HUMAN_AGE_CACHE_LIMIT)
+        HUMAN_AGE_CACHE.clear();
+    HUMAN_AGE_CACHE.set(ageMs, result);
+    return result;
+}
 function rootLabel(projectRoot) {
     if (!projectRoot)
         return '';
     return basename(projectRoot);
 }
+/**
+ * Slice rid-statusline-24h-overlay (2026-08-10): format the 24h-mode
+ * overlay suffix appended after the existing `<baseMode>` token in
+ * the ACTIVE state. Returns `''` when the overlay is `null` (missing
+ * file / corrupt file / wrong shape — see `read24hOverlay`).
+ *
+ * Output shape (ASCII palette): ` . [24h-<lowercase-state>]`
+ * Output shape (unicode palette): ` · [24h-<lowercase-state>]`
+ *
+ * en-US only; i18n deferred to a future slice (PRD §Non-goals.5).
+ * The `[24h-...]` prefix is a deliberate marker so the user can
+ * visually distinguish a 24h-mode substate from a base-mode token
+ * like `[full-auto]`.
+ */
+export function format24hSuffix(overlay, palette, capability, noColor) {
+    if (!overlay)
+        return '';
+    const label = `[24h-${overlay.state.toLowerCase()}]`;
+    return `${palette.inlineSeparator}${brandRun(label, noColor, capability)}`;
+}
 /**
  * `formatShortSid` + `computeRootSuffix` were extracted to
  * `./skill-statusline-sid-suffix.ts` in the slice
@@ -223,14 +296,19 @@ function rootLabel(projectRoot) {
  * forced every bee role to render with a `↑<parent>` marker was removed
  * in this slice; the dual-skill layout above replaces it.
  */
-function renderActive(presence, palette, nowMs, capability, noColor, activeLeaf) {
+function renderActive(presence, palette, nowMs, capability, noColor, activeLeaf, twentyFourHourState) {
     if (!presence) {
         return `${palette.idle} ${palette.idleLabel}`;
     }
+    // Slice rid-statusline-24h-overlay (2026-08-10): the 24h suffix
+    // is appended on every active-return branch that carries a skill
+    // token. The `!presence` branch (idle mark, no skill token) is
+    // intentionally NOT modified — 24h overlays are active-only.
+    const suffix = format24hSuffix(twentyFourHourState, palette, capability, noColor);
     const attentionLabel = isAttentionGate(presence.gate);
     if (attentionLabel !== null) {
         // Attention gate — surface the warning glyph + human-readable label.
-        return `${palette.warning} ${brandRun(presence.skill, noColor, capability)}${palette.inlineSeparator}${brandRun(attentionLabel, noColor, capability)}`;
+        return `${palette.warning} ${brandRun(presence.skill, noColor, capability)}${palette.inlineSeparator}${brandRun(attentionLabel, noColor, capability)}${suffix}`;
     }
     const skill = presence.skill;
     const dot = renderActiveDot(capability, nowMs, noColor);
@@ -244,15 +322,25 @@ function renderActive(presence, palette, nowMs, capability, noColor, activeLeaf)
             ? ` ${brandRun(`(+${activeLeaf.pendingCount - 1})`, noColor, capability)}`
             : '';
         const sep = brandRun(' | ', noColor, capability);
-        return `${dot} ${leaf}${tail}${sep}${brandRun(skill, noColor, capability)}${modeToken}`;
+        return `${dot} ${leaf}${tail}${sep}${brandRun(skill, noColor, capability)}${modeToken}${suffix}`;
     }
-    return `${dot} ${brandRun(skill, noColor, capability)}${modeToken}`;
+    return `${dot} ${brandRun(skill, noColor, capability)}${modeToken}${suffix}`;
 }
 function renderStale(presence, ageMs, palette, capability, noColor) {
+    // Slice rid-statusline-stale-ux AC-1: stale presence belongs to a
+    // *previous* session (outer-session-mismatch). Line still emits the
+    // recorded skill name (per C-1 — `expect(out).toContain('peaks-code')`
+    // must keep passing), but uses `palette.idleStale` (new muted palette,
+    // distinct from idle and warning) and neutral
+    // `(previous session · <human age>)` suffix instead of legacy
+    // `stale <Nh>` token. ASCII capability replaces the `·` middle dot
+    // with `-` so byte-identical shape holds across encodings.
     const skill = presence?.skill ?? 'unknown';
-    const age = formatAge(ageMs);
-    const ageSuffix = age ? `${palette.inlineSeparator}${brandRun(age, noColor, capability)}` : '';
-    return `${palette.warning} ${brandRun(skill, noColor, capability)}${ageSuffix}`;
+    const age = formatHumanAge(ageMs);
+    const sep = capability === 'ascii' ? '-' : '·';
+    const label = age ? `(previous session ${sep} ${age})` : '(previous session)';
+    const ageSuffix = `${palette.inlineSeparator}${brandRun(label, noColor, capability)}`;
+    return `${palette.idleStale} ${brandRun(skill, noColor, capability)}${ageSuffix}`;
 }
 function renderInvalid(palette) {
     return `${palette.warning} ${palette.invalidMessage}`;
@@ -623,7 +711,7 @@ export function renderStatusLine(model, options, env) {
     else {
         switch (model.state) {
             case 'active':
-                line = `${brand} ${renderActive(model.presence, palette, nowMs, capability, noColor, model.activeLeaf)}${rootSuffix}`;
+                line = `${brand} ${renderActive(model.presence, palette, nowMs, capability, noColor, model.activeLeaf, model.twentyFourHourState)}${rootSuffix}`;
                 break;
             case 'stale':
                 line = `${brand} ${renderStale(model.presence, model.ageMs, palette, capability, noColor)}${rootSuffix}`;

package/dist/services/skills/skill-statusline-service.d.ts

@@ -41,6 +41,47 @@ export type StatusLineModel = {
      * existent root.
      */
     sessionId: string | null;
+    /**
+     * Slice rid-statusline-24h-overlay (2026-08-10): the 24h-mode
+     * overlay snapshot read from `.peaks/_runtime/<sid>/24h-state.json`,
+     * or `null` when no file exists / file is corrupt / file has wrong
+     * shape. The renderer reads this to append `[24h-<state>]` after
+     * the existing `<baseMode>` token in the ACTIVE state only.
+     *
+     * Always present (never undefined). `null` means "no overlay" —
+     * the renderer skips the suffix without re-reading disk.
+     */
+    twentyFourHourState: TwentyFourHourOverlay | null;
+};
+/**
+ * Slice rid-statusline-24h-overlay (2026-08-10): minimal overlay
+ * type returned by `read24hOverlay`. The renderer only consumes
+ * `state` (to format `[24h-<state.toLowerCase()>]`). The canonical
+ * schema at `src/services/24h-mode/state.ts:55-66` carries additional
+ * fields (`attempts: Record<DecisionKey, number>`, `enteredAt`,
+ * `checkpoints`, etc.) but the overlay is deliberately MINIMAL —
+ * it tolerates forward compatibility with new states the writer
+ * may add, and it never throws on malformed shapes (PRD AC-3:
+ * graceful null on any invalid input).
+ */
+export type TwentyFourHourOverlay = {
+    state: string;
 };
+/**
+ * Slice rid-statusline-24h-overlay (2026-08-10): name-distinct from
+ * the canonical `read24hState` in `src/services/24h-mode/store.ts:108`.
+ * The canonical reader calls `coerceSnapshot` (which throws on
+ * malformed shapes via `24H_STATE_INVALID`); this overlay reader
+ * returns `null` for ANY malformed shape (per PRD AC-3 — never
+ * throw across the statusline boundary).
+ *
+ * Returns null when:
+ *   - `projectRoot` or `sessionId` is empty
+ *   - the file does not exist (ENOENT)
+ *   - JSON.parse fails (corrupt file)
+ *   - root is not a non-array object
+ *   - `state` is missing, non-string, or empty string
+ */
+export declare function read24hOverlay(projectRoot: string, sessionId: string): TwentyFourHourOverlay | null;
 export declare function parseStatusLineStdin(raw: string): StatusLineStdin | null;
 export declare function buildStatusLineModel(stdin: StatusLineStdin | null, nowMs: number): StatusLineModel;

package/dist/services/skills/skill-statusline-service.js

@@ -1,4 +1,5 @@
-import { resolve } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { findProjectRoot } from '../config/config-safety.js';
 import { decideCompactStatusline } from '../compact-statusline/compact-statusline-service.js';
 import { getSessionIdCanonical } from '../session/session-manager.js';
@@ -30,6 +31,48 @@ import { readActiveDispatchIndex } from '../dispatch/dispatch-record-writer.js';
  * documented back-compat path.
  */
 const STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+/**
+ * Slice rid-statusline-24h-overlay (2026-08-10): name-distinct from
+ * the canonical `read24hState` in `src/services/24h-mode/store.ts:108`.
+ * The canonical reader calls `coerceSnapshot` (which throws on
+ * malformed shapes via `24H_STATE_INVALID`); this overlay reader
+ * returns `null` for ANY malformed shape (per PRD AC-3 — never
+ * throw across the statusline boundary).
+ *
+ * Returns null when:
+ *   - `projectRoot` or `sessionId` is empty
+ *   - the file does not exist (ENOENT)
+ *   - JSON.parse fails (corrupt file)
+ *   - root is not a non-array object
+ *   - `state` is missing, non-string, or empty string
+ */
+export function read24hOverlay(projectRoot, sessionId) {
+    if (!projectRoot || !sessionId)
+        return null;
+    const path = join(projectRoot, '.peaks', '_runtime', sessionId, '24h-state.json');
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        // ENOENT, EACCES, EISDIR — all treated as "no overlay"
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        // corrupt JSON — graceful null (PRD AC-3)
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const obj = parsed;
+    if (typeof obj['state'] !== 'string' || obj['state'].length === 0)
+        return null;
+    return { state: obj['state'] };
+}
 function resolveCwdFromStdin(stdin) {
     const fromWorkspace = stdin?.workspace?.current_dir ?? stdin?.workspace?.project_dir;
     if (typeof fromWorkspace === 'string' && fromWorkspace.length > 0) {
@@ -234,16 +277,16 @@ export function buildStatusLineModel(stdin, nowMs) {
         }
     }
     if (projectRoot === null) {
-        return { state: 'idle', projectRoot: null, presence: null, ageMs: null, compact, activeLeaf: null, sessionId: null };
+        return { state: 'idle', projectRoot: null, presence: null, ageMs: null, compact, activeLeaf: null, sessionId: null, twentyFourHourState: null };
     }
     // callerId resolves the read-side isolation; back-compat is `null`.
     const callerId = resolveCallerId(stdin);
     const { presence, invalid } = readPresenceReadOnly(projectRoot, callerId);
     if (invalid) {
-        return { state: 'invalid-presence', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId };
+        return { state: 'invalid-presence', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId, twentyFourHourState: null };
     }
     if (presence === null) {
-        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId };
+        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId, twentyFourHourState: null };
     }
     // Session binding: when the presence was stamped with a Claude session id and
     // the live session (from stdin) is a different one, the recorded skill belongs
@@ -252,7 +295,7 @@ export function buildStatusLineModel(stdin, nowMs) {
     // fall back to the time-based behavior below for backward compatibility.
     const liveSessionId = typeof stdin?.session_id === 'string' && stdin.session_id.length > 0 ? stdin.session_id : null;
     if (presence.claudeSessionId && liveSessionId && presence.claudeSessionId !== liveSessionId) {
-        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId };
+        return { state: 'idle', projectRoot, presence: null, ageMs: null, compact, activeLeaf: null, sessionId, twentyFourHourState: null };
     }
     const setAtMs = presence.setAt ? Date.parse(presence.setAt) : Number.NaN;
     const ageMs = Number.isNaN(setAtMs) ? null : nowMs - setAtMs;
@@ -268,7 +311,14 @@ export function buildStatusLineModel(stdin, nowMs) {
     catch {
         activeLeaf = null;
     }
-    return { state, projectRoot, presence, ageMs, compact, activeLeaf, sessionId };
+    // Slice rid-statusline-24h-overlay (2026-08-10): read the 24h-mode
+    // overlay snapshot ONLY when state === 'active'. Stale / idle /
+    // invalid-presence / idle-via-outer-mismatch never carry the suffix
+    // (per PRD §Non-goals.6 — "不在 idle / stale / invalid-presence
+    // 状态下 overlay 24h suffix"). When projectRoot or sessionId is
+    // missing, return null without re-reading disk.
+    const twentyFourHourState = state === 'active' ? read24hOverlay(projectRoot, sessionId ?? '') : null;
+    return { state, projectRoot, presence, ageMs, compact, activeLeaf, sessionId, twentyFourHourState };
 }
 /**
  * Read-only compact state resolver. Resolves the canonical session id for the

package/dist/services/slice/calibration-store.js

@@ -22,6 +22,19 @@
  * codegraph v0.7.10 does not emit it; v2 can re-enable once
  * `.codegraph/codegraph.db` is read directly.
  */
+/**
+ * PRD-002b slice 2 — calibration heuristic coefficients + thresholds
+ * extracted into named constants so the no-magic-numbers rule stops
+ * flagging the weight+threshold math. Values are bytewise-identical to
+ * the original literals.
+ */
+const LOC_WEIGHT_PER_LINE = 0.25;
+const TEST_WEIGHT_PER_FILE = 0.5;
+const COMPLEXITY_WEIGHT_PER_NODE = 0.1;
+const P90_P50_RATIO = 1.6;
+const HIGH_CONFIDENCE_MIN_SAMPLES = 5;
+const MEDIUM_CONFIDENCE_MIN_SAMPLES = 1;
+const OUTPUT_PRECISION_DECIMALS = 10;
 /**
  * Compute a work-estimate envelope.
  *
@@ -48,20 +61,20 @@ export function calibrate(complexitySum, testCount, locSum, sampleSize) {
     if (!Number.isInteger(sampleSize) || sampleSize < 0) {
         throw new RangeError(`calibrate: sampleSize must be a non-negative integer, got ${sampleSize}`);
     }
-    const minutesP50 = 0.25 * locSum + 0.5 * testCount + 0.1 * complexitySum;
-    const minutesP90 = minutesP50 * 1.6;
-    const confidence = sampleSize >= 5 ? 'high' : sampleSize >= 1 ? 'medium' : 'low';
+    const minutesP50 = LOC_WEIGHT_PER_LINE * locSum + TEST_WEIGHT_PER_FILE * testCount + COMPLEXITY_WEIGHT_PER_NODE * complexitySum;
+    const minutesP90 = minutesP50 * P90_P50_RATIO;
+    const confidence = sampleSize >= HIGH_CONFIDENCE_MIN_SAMPLES ? 'high' : sampleSize >= MEDIUM_CONFIDENCE_MIN_SAMPLES ? 'medium' : 'low';
     const rationale = sampleSize === 0
-        ? 'v1 heuristic: 0.25 min/LoC + 0.5 min/test + 0.1 min/complexity; confidence low because no historical sample'
-        : sampleSize < 5
-            ? `v1 heuristic: ${sampleSize} historical sample(s) available; will switch to percentile lookup at sampleSize >= 5`
+        ? `v1 heuristic: ${LOC_WEIGHT_PER_LINE} min/LoC + ${TEST_WEIGHT_PER_FILE} min/test + ${COMPLEXITY_WEIGHT_PER_NODE} min/complexity; confidence low because no historical sample`
+        : sampleSize < HIGH_CONFIDENCE_MIN_SAMPLES
+            ? `v1 heuristic: ${sampleSize} historical sample(s) available; will switch to percentile lookup at sampleSize >= ${HIGH_CONFIDENCE_MIN_SAMPLES}`
             : `v1 heuristic with sampleSize ${sampleSize}; v1.1 will switch to percentile lookup`;
     return {
         complexitySum,
         testCount,
         locSum,
-        minutesP50: Math.round(minutesP50 * 10) / 10,
-        minutesP90: Math.round(minutesP90 * 10) / 10,
+        minutesP50: Math.round(minutesP50 * OUTPUT_PRECISION_DECIMALS) / OUTPUT_PRECISION_DECIMALS,
+        minutesP90: Math.round(minutesP90 * OUTPUT_PRECISION_DECIMALS) / OUTPUT_PRECISION_DECIMALS,
         confidence,
         rationale
     };