peaks-loop 4.0.17 → 4.0.19

package/dist/services/dispatch/dispatch-record-writer.d.ts

@@ -34,16 +34,13 @@ export interface DispatchRecord {
      * defaulted to `null` on read so v3 records upgrade cleanly.
      */
     /**
-     * Slice 2026-07-29-rid-prose-only-sweep Part 34: schema v3.1
-     * is the explicit minor bump that records the
-     * `isolationStartedAt` (Part 7) and `leaseId` (Part 3.A.1 +
-     * Part 4.C) fields as part of the canonical schema. v3
-     * records on disk upgrade transparently — see `upgradeRecord`
-     * in this file. The literal type ('3.1') is the source of
-     * truth for "this record is v3.1-form"; readers check
-     * `version === '3.1'` for forward-compatible dispatching.
+     * Phase A Task 8: schema bumped to v4.1.0 (additive). The bump
+     * is purely additive — new fields (`mode`, `vendor`,
+     * `autoCompactEvents`, `tokenUsage`) all default safely on
+     * read for legacy v4.0.0 / v3.2 / v3.1 / v3 / v2 / v1 records.
+     * No existing field semantics changed.
      */
-    readonly version: '4.0.0';
+    readonly version: '4.1.0';
     readonly createdAt: string;
     readonly completedAt: string | null;
     readonly outcome: DispatchOutcome;
@@ -136,6 +133,49 @@ export interface DispatchRecord {
     readonly workflowId: string | null;
     readonly graphNodeId: string | null;
     readonly graphRef: string | null;
+    /**
+     * Phase A Task 8: dispatch execution mode. `in-process` is the
+     * current behavior (LLM-side runner, no separate OS process).
+     * `detached` is the new path: `peaks sub-agent dispatch --mode
+     * detached` spawns a real child OS process running a different
+     * LLM vendor (claude / codex / copilot) and reports back via
+     * the dispatch record. v4.1.0 is the additive bump; legacy v4.0.0
+     * records upgrade to `in-process` on read.
+     */
+    readonly mode: 'in-process' | 'detached';
+    /**
+     * Phase A Task 8: vendor id when `mode='detached'`. `null` when
+     * the dispatch is in-process. Reserved for future use; current
+     * detached sub-agents use `claude` but the schema also accepts
+     * `codex` and `copilot` for the vendor-neutral adapter layer.
+     */
+    readonly vendor: 'claude' | 'codex' | 'copilot' | null;
+    /**
+     * Phase A Task 8: G8 autoCompact events accumulated by the child
+     * LLM during a detached run. Each event records the threshold
+     * that fired (0.85 = first warning, 0.95 = second warning) plus
+     * token counts before/after. Empty for in-process dispatches
+     * and for legacy records upgraded on read.
+     */
+    readonly autoCompactEvents: ReadonlyArray<{
+        readonly at: number;
+        readonly threshold: '0.85' | '0.95';
+        readonly tokensBefore: number;
+        readonly tokensAfter: number;
+        readonly scratchFile?: string;
+    }>;
+    /**
+     * Phase A Task 8: G8 token-usage accounting for detached sub-agents.
+     * Detached runs have "unlimited spend but recorded" semantics —
+     * the cost is recorded for audit but not enforced. `null` when
+     * the dispatch is in-process (no detached accounting) or for
+     * legacy records upgraded on read.
+     */
+    readonly tokenUsage: {
+        readonly promptTokens: number;
+        readonly completionTokens: number;
+        readonly totalCostUsd?: number;
+    } | null;
 }
 /** Input for the initial write. */
 export type WriteInitialDispatchInput = {
@@ -172,6 +212,43 @@ export type WriteInitialDispatchInput = {
     workflowId?: string | null;
     graphNodeId?: string | null;
     graphRef?: string | null;
+    /**
+     * Phase A Task 8: dispatch execution mode. Default `'in-process'`
+     * preserves the current LLM-side runner behavior. `'detached'`
+     * triggers the new real-OS-process path via
+     * `peaks sub-agent dispatch --mode detached`.
+     */
+    mode?: 'in-process' | 'detached';
+    /**
+     * Phase A Task 8: vendor id when `mode='detached'`. Required by
+     * the adapter layer to know which CLI / runtime to spawn. The
+     * schema accepts the three vendors peaks-loop has adapters for
+     * (claude / codex / copilot). Ignored when `mode='in-process'`.
+     */
+    vendor?: 'claude' | 'codex' | 'copilot';
+    /**
+     * Phase A Task 8: G8 autoCompact events accumulated by the child
+     * LLM. Optional on input — most dispatches start with an empty
+     * array and the detached runner appends events as they fire.
+     */
+    autoCompactEvents?: Array<{
+        at: number;
+        threshold: '0.85' | '0.95';
+        tokensBefore: number;
+        tokensAfter: number;
+        scratchFile?: string;
+    }>;
+    /**
+     * Phase A Task 8: G8 token-usage accounting. Detached runs
+     * record spend for audit (unlimited, but persisted). Optional
+     * on input; the detached runner fills this in as it streams
+     * usage from the vendor API.
+     */
+    tokenUsage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalCostUsd?: number;
+    };
 };
 /** Heartbeat write input. */
 export type AppendHeartbeatInput = {

package/dist/services/dispatch/dispatch-record-writer.js

@@ -86,7 +86,7 @@ export function writeInitialDispatchRecord(input) {
 function buildInitialDispatchRecord(input, now) {
     const { role, requestId, sessionId, prompt, toolCall, batchId } = input;
     return {
-        version: '4.0.0',
+        version: '4.1.0',
         createdAt: now().toISOString(),
         completedAt: null,
         outcome: 'no-execution',
@@ -141,6 +141,22 @@ function buildInitialDispatchRecord(input, now) {
         workflowId: typeof input.workflowId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(input.workflowId) ? input.workflowId : null,
         graphNodeId: typeof input.graphNodeId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(input.graphNodeId) ? input.graphNodeId : null,
         graphRef: typeof input.graphRef === 'string' && input.graphRef.length > 0 ? input.graphRef : null,
+        // Phase A Task 8: detached sub-agent mode (default in-process).
+        mode: input.mode === 'detached' ? 'detached' : 'in-process',
+        vendor: input.vendor === 'claude' || input.vendor === 'codex' || input.vendor === 'copilot' ? input.vendor : null,
+        autoCompactEvents: Array.isArray(input.autoCompactEvents)
+            ? input.autoCompactEvents.filter((e) => typeof e?.at === 'number' &&
+                (e?.threshold === '0.85' || e?.threshold === '0.95') &&
+                typeof e?.tokensBefore === 'number' &&
+                typeof e?.tokensAfter === 'number')
+            : [],
+        tokenUsage: typeof input.tokenUsage === 'object' && input.tokenUsage !== null && typeof input.tokenUsage.promptTokens === 'number' && typeof input.tokenUsage.completionTokens === 'number'
+            ? {
+                promptTokens: input.tokenUsage.promptTokens,
+                completionTokens: input.tokenUsage.completionTokens,
+                ...(typeof input.tokenUsage.totalCostUsd === 'number' ? { totalCostUsd: input.tokenUsage.totalCostUsd } : {}),
+            }
+            : null,
     };
 }
 function activeDispatchIndexPath(projectRoot, sessionId) {
@@ -663,18 +679,19 @@ function upgradeRecord(parsed) {
         throw new Error('Dispatch record root must be an object');
     }
     const obj = parsed;
-    // Slice 4.0.8: 3.2 → 4.0.0 schema bump. The literal type narrows
-    // to '4.0.0' but legacy v3.2 / v3.1 / 3 / 2 / 1 records are
-    // accepted transparently and upgraded on read.
+    // Slice 4.0.8: 3.2 → 4.0.0 schema bump. Phase A Task 8: 4.0.0 → 4.1.0
+    // (additive). The literal type narrows to '4.1.0' but legacy v4.0.0 /
+    // v3.2 / v3.1 / 3 / 2 / 1 records are accepted transparently and
+    // upgraded on read.
     const rawVersion = obj.version;
-    if (rawVersion !== '4.0.0' && rawVersion !== '3.2' && rawVersion !== '3.1' && rawVersion !== 3 && rawVersion !== 2 && rawVersion !== 1) {
-        throw new Error(`Dispatch record version mismatch: expected '4.0.0', '3.2', '3.1', 3, 2, or 1, got ${JSON.stringify(rawVersion)}. ` +
-            'The v1 → v4.0.0 migration is in-file; records from much older or newer builds must be regenerated.');
+    if (rawVersion !== '4.1.0' && rawVersion !== '4.0.0' && rawVersion !== '3.2' && rawVersion !== '3.1' && rawVersion !== 3 && rawVersion !== 2 && rawVersion !== 1) {
+        throw new Error(`Dispatch record version mismatch: expected '4.1.0', '4.0.0', '3.2', '3.1', 3, 2, or 1, got ${JSON.stringify(rawVersion)}. ` +
+            'The v1 → v4.1.0 migration is in-file; records from much older or newer builds must be regenerated.');
     }
     const legacy = parseUpgradeRecordLegacyFields(obj);
     const migration = parseUpgradeRecordMigrationFields(obj);
     return {
-        version: '4.0.0',
+        version: '4.1.0',
         createdAt: legacy.createdAt,
         completedAt: legacy.completedAt,
         outcome: legacy.outcome,
@@ -697,7 +714,16 @@ function upgradeRecord(parsed) {
         mergeBackAttempts: migration.mergeBackAttempts,
         workflowId: migration.workflowId,
         graphNodeId: migration.graphNodeId,
-        graphRef: migration.graphRef
+        graphRef: migration.graphRef,
+        // Phase A Task 8: detached sub-agent fields. Legacy records
+        // (pre-4.1.0) default mode='in-process', vendor=null,
+        // autoCompactEvents=[], tokenUsage=null. See
+        // parseUpgradeRecordMigrationFields for the per-field
+        // validation rules.
+        mode: migration.mode,
+        vendor: migration.vendor,
+        autoCompactEvents: migration.autoCompactEvents,
+        tokenUsage: migration.tokenUsage
     };
 }
 /**
@@ -812,7 +838,29 @@ function parseUpgradeRecordMigrationFields(obj) {
         // fields to `null` so a legacy record upgrades transparently.
         workflowId: typeof obj.workflowId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(obj.workflowId) ? obj.workflowId : null,
         graphNodeId: typeof obj.graphNodeId === 'string' && /^[a-zA-Z0-9._-]{1,200}$/.test(obj.graphNodeId) ? obj.graphNodeId : null,
-        graphRef: typeof obj.graphRef === 'string' ? obj.graphRef : null
+        graphRef: typeof obj.graphRef === 'string' ? obj.graphRef : null,
+        // Phase A Task 8: 4.0.0 → 4.1.0 migration. Pre-4.1.0 records
+        // have no mode / vendor / autoCompactEvents / tokenUsage
+        // fields. Default to safe in-process / null / [] / null so
+        // legacy records upgrade transparently without breaking
+        // consumers (e.g. the dashboard, the merge-back-runner).
+        mode: obj.mode === 'detached' ? 'detached' : 'in-process',
+        vendor: obj.vendor === 'claude' || obj.vendor === 'codex' || obj.vendor === 'copilot' ? obj.vendor : null,
+        autoCompactEvents: Array.isArray(obj.autoCompactEvents)
+            ? obj.autoCompactEvents.filter((e) => typeof e?.at === 'number' &&
+                (e?.threshold === '0.85' || e?.threshold === '0.95') &&
+                typeof e?.tokensBefore === 'number' &&
+                typeof e?.tokensAfter === 'number')
+            : [],
+        tokenUsage: typeof obj.tokenUsage === 'object' && obj.tokenUsage !== null && typeof obj.tokenUsage.promptTokens === 'number' && typeof obj.tokenUsage.completionTokens === 'number'
+            ? {
+                promptTokens: obj.tokenUsage.promptTokens,
+                completionTokens: obj.tokenUsage.completionTokens,
+                ...(typeof obj.tokenUsage.totalCostUsd === 'number'
+                    ? { totalCostUsd: obj.tokenUsage.totalCostUsd }
+                    : {}),
+            }
+            : null
     };
 }
 function isObject(v) {

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
@@ -211,6 +211,20 @@ 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
@@ -242,7 +256,12 @@ function resolveLegacySentinels(ide) {
     // 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;