peaks-loop 4.0.33 → 4.0.35

package/dist/services/memory/project-memory-service/parsers/frontmatter.js

@@ -12,22 +12,18 @@
 //      are stored as standard YAML frontmatter (name / description /
 //      metadata.type / metadata.sourceArtifact) followed by the body.
 //
-// Both parsers share the 8-kind `VALID_MEMORY_KINDS` allow-list and the
+// Both parsers share the `VALID_MEMORY_KINDS` allow-list (derived from the
+// canonical `PROJECT_MEMORY_KINDS` tuple in `../types.ts`) and the
 // `slugify` helper used to derive filenames from titles.
 // ---------------------------------------------------------------------------
-export const VALID_MEMORY_KINDS = new Set([
-    'project',
-    'rule',
-    'decision',
-    'reference',
-    'feedback',
-    'convention',
-    'module',
-    'lesson'
-]);
-/** Exported for guard tests + tooling that needs to enumerate the valid
- *  set without duplicating the literal. Single source of truth. */
-export const VALID_PROJECT_MEMORY_KINDS = Array.from(VALID_MEMORY_KINDS);
+import { basename } from 'node:path';
+import { PROJECT_MEMORY_KINDS } from '../types.js';
+/** Accepted-kind set, derived from the canonical `PROJECT_MEMORY_KINDS`
+ *  tuple so the parser cannot drift from the union type / tier map. */
+export const VALID_MEMORY_KINDS = new Set(PROJECT_MEMORY_KINDS);
+/** Exported for guard tests + tooling that needs to enumerate the accepted
+ *  set (CLI help text, `--kind` validation) without duplicating the literal. */
+export const VALID_PROJECT_MEMORY_KINDS = PROJECT_MEMORY_KINDS;
 export function slugify(title) {
     const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
     return slug.length > 0 ? slug : 'project-memory';
@@ -69,36 +65,129 @@ export function renderMemoryFile(memory) {
         ''
     ].join('\n');
 }
-export function parseStoredMemoryFile(content, filePath) {
+/**
+ * Resolve the peaks memory kind from a stored memory file's frontmatter.
+ *
+ * Resolution order (first *valid* kind wins):
+ *   1. nested `metadata.type`   — the canonical peaks contract
+ *   2. top-level `kind:`        — the legacy alias (was silently dropped before)
+ *   3. top-level `type:`        — tolerated by the pre-existing trim-based reader
+ *   4. `none`                   — reported as unclassified; never invented
+ *
+ * Slice 2026-09-09-memory-system-overhaul (B): before this helper, files
+ * using a top-level `kind:` were silently dropped by the reader (defect
+ * #2). Falling through to `kind:` / `type:` is a strict superset of the
+ * old behaviour — no previously-indexed file changes kind.
+ */
+export function resolveMemoryKind(content) {
+    const parsed = parseMemoryFrontmatter(content);
+    return parsed.kind;
+}
+/**
+ * Single parse surface for stored memory frontmatter. Both
+ * `parseStoredMemoryFile` (read path) and the reindex / ingest / doctor
+ * classifiers consume this so there is exactly one kind-resolution rule
+ * in the codebase.
+ */
+export function parseMemoryFrontmatter(content) {
     const normalized = content.replace(/\r\n/g, '\n');
-    if (!normalized.startsWith('---\n'))
-        return null;
+    if (!normalized.startsWith('---\n')) {
+        return { hasFrontmatter: false, kind: { kind: null, source: 'none', rawKind: null }, frontmatter: '', body: normalized.trim() };
+    }
     const endIndex = normalized.indexOf('\n---\n', 4);
-    if (endIndex < 0)
-        return null;
+    if (endIndex < 0) {
+        return { hasFrontmatter: false, kind: { kind: null, source: 'none', rawKind: null }, frontmatter: '', body: normalized.trim() };
+    }
     const frontmatter = normalized.slice(4, endIndex);
     const body = normalized.slice(endIndex + '\n---\n'.length).trim();
     let name;
+    let titleField;
     let description;
-    let kind;
     let sourceArtifact;
+    let nestedType;
+    let topType;
+    let kindField;
+    let inMetadata = false;
     for (const rawLine of frontmatter.split('\n')) {
+        const indented = /^\s/.test(rawLine);
         const line = rawLine.trim();
+        if (!indented) {
+            inMetadata = line === 'metadata:';
+        }
         if (line.startsWith('name:'))
             name = line.slice('name:'.length).trim();
+        else if (line.startsWith('title:')) {
+            if (!indented)
+                titleField = line.slice('title:'.length).trim();
+        }
         else if (line.startsWith('description:'))
             description = line.slice('description:'.length).trim();
-        else if (line.startsWith('type:'))
-            kind = line.slice('type:'.length).trim();
+        else if (line.startsWith('type:')) {
+            const value = line.slice('type:'.length).trim();
+            if (indented || inMetadata)
+                nestedType ??= value;
+            else
+                topType ??= value;
+        }
+        else if (line.startsWith('kind:'))
+            kindField ??= line.slice('kind:'.length).trim();
         else if (line.startsWith('sourceArtifact:'))
             sourceArtifact = line.slice('sourceArtifact:'.length).trim();
     }
-    if (!name || !kind || !VALID_MEMORY_KINDS.has(kind) || body.length === 0)
+    const candidates = [
+        ['metadata.type', nestedType],
+        ['kind', kindField],
+        ['type', topType]
+    ];
+    let kind = { kind: null, source: 'none', rawKind: null };
+    for (const [source, raw] of candidates) {
+        if (raw === undefined || raw === '')
+            continue;
+        if (kind.rawKind === null)
+            kind = { kind: null, source: 'none', rawKind: raw };
+        if (VALID_MEMORY_KINDS.has(raw)) {
+            kind = { kind: raw, source, rawKind: raw };
+            break;
+        }
+    }
+    return { hasFrontmatter: true, frontmatter, ...(name !== undefined ? { name } : {}), ...(titleField !== undefined ? { title: titleField } : {}), ...(description !== undefined ? { description } : {}), ...(sourceArtifact !== undefined ? { sourceArtifact } : {}), kind, body };
+}
+/**
+ * Deterministic name fallback chain for the read path:
+ *
+ *   1. `name:`            — the canonical field written by `renderMemoryFile`
+ *   2. `title:`           — hand-written / legacy files (the 5 on-disk files
+ *                           this slice fixes carried only `title:` + `kind:`)
+ *   3. filename stem      — last resort, so a well-formed memory with a valid
+ *                           kind is never dropped just for missing a name
+ *
+ * Empty values are skipped rather than accepted: a `name:` of `''` still
+ * falls through, and a file whose stem is also empty resolves to null so the
+ * caller's validation is preserved (never invents a name).
+ */
+export function resolveMemoryName(parsed, filePath) {
+    if (parsed.name !== undefined && parsed.name.length > 0)
+        return { name: parsed.name, source: 'name' };
+    if (parsed.title !== undefined && parsed.title.length > 0)
+        return { name: parsed.title, source: 'title' };
+    const stem = basename(filePath, '.md');
+    if (stem.length > 0)
+        return { name: stem, source: 'stem' };
+    return { name: null, source: 'none' };
+}
+export function parseStoredMemoryFile(content, filePath) {
+    const parsed = parseMemoryFrontmatter(content);
+    if (!parsed.hasFrontmatter)
+        return null;
+    const { description, sourceArtifact, body } = parsed;
+    const kind = parsed.kind.kind;
+    const { name } = resolveMemoryName(parsed, filePath);
+    if (name === null || kind === null || body.length === 0)
         return null;
     return {
         name,
         title: description ?? name,
-        kind: kind,
+        kind,
         sourceArtifact: sourceArtifact && sourceArtifact !== 'undefined' ? sourceArtifact : null,
         body,
         filePath

package/dist/services/memory/project-memory-service/types.d.ts

@@ -1,4 +1,34 @@
-export type ProjectMemoryKind = 'project' | 'rule' | 'decision' | 'reference' | 'feedback' | 'convention' | 'module' | 'lesson';
+/**
+ * Canonical memory-kind vocabulary — the single source of truth.
+ *
+ * The union type, the accepted-kind set in the frontmatter parser, the
+ * hot/warm tier map below, `KIND_ORDER` in the reindex view, and the CLI
+ * `--kind` help text all derive from this tuple. Adding a kind here is the
+ * only edit required; TypeScript then forces `MEMORY_KIND_TIER` to cover it.
+ *
+ * Slice 2026-09-10-memory-vocab-and-rotate (E): the original 8 kinds are
+ * unchanged. The 13 appended kinds were observed on disk with real values
+ * that the index schema rejected (`peaks memory reindex` reported them as
+ * `unrecognized kind value`). Accepting them moves those files into the
+ * index; files with no kind field at all stay reported as unclassified.
+ */
+export declare const PROJECT_MEMORY_KINDS: readonly ["project", "rule", "decision", "reference", "feedback", "convention", "module", "lesson", "bug", "investigation", "technical-pattern", "project-rule", "design", "handoff", "session-handoff", "project-todo", "publish-closure", "project-closure", "slice-closure", "slice-pilot-findings", "sediment"];
+export type ProjectMemoryKind = (typeof PROJECT_MEMORY_KINDS)[number];
+/** Hot kinds keep their body in the always-available index; warm kinds are
+ *  indexed with the same entry shape but read on demand. */
+export type MemoryKindTier = 'hot' | 'warm';
+/**
+ * Hot/warm tier per kind. Insertion order IS the deterministic section order
+ * used by the generated `MEMORY.md` (`KIND_ORDER` in `index/reindex.ts`),
+ * so this object's key order is load-bearing — append new kinds at the end
+ * of their tier block rather than reshuffling existing entries.
+ *
+ * The `Record<ProjectMemoryKind, MemoryKindTier>` annotation makes a missing
+ * tier a compile error whenever `PROJECT_MEMORY_KINDS` grows.
+ */
+export declare const MEMORY_KIND_TIER: Record<ProjectMemoryKind, MemoryKindTier>;
+export declare const HOT_MEMORY_KINDS: readonly ProjectMemoryKind[];
+export declare const WARM_MEMORY_KINDS: readonly ProjectMemoryKind[];
 export type ExtractedProjectMemory = {
     title: string;
     kind: ProjectMemoryKind;

package/dist/services/memory/project-memory-service/types.js

@@ -6,4 +6,79 @@
 // from here, and the top-level `index.ts` re-exports them for back-compat
 // with downstream callers (CLI commands, audit writers, presence service).
 // ---------------------------------------------------------------------------
-export {};
+/**
+ * Canonical memory-kind vocabulary — the single source of truth.
+ *
+ * The union type, the accepted-kind set in the frontmatter parser, the
+ * hot/warm tier map below, `KIND_ORDER` in the reindex view, and the CLI
+ * `--kind` help text all derive from this tuple. Adding a kind here is the
+ * only edit required; TypeScript then forces `MEMORY_KIND_TIER` to cover it.
+ *
+ * Slice 2026-09-10-memory-vocab-and-rotate (E): the original 8 kinds are
+ * unchanged. The 13 appended kinds were observed on disk with real values
+ * that the index schema rejected (`peaks memory reindex` reported them as
+ * `unrecognized kind value`). Accepting them moves those files into the
+ * index; files with no kind field at all stay reported as unclassified.
+ */
+export const PROJECT_MEMORY_KINDS = [
+    // Original 8 (pre-2026-09-10).
+    'project',
+    'rule',
+    'decision',
+    'reference',
+    'feedback',
+    'convention',
+    'module',
+    'lesson',
+    // Slice E expansion — observed on-disk values, hot tier.
+    'bug',
+    'investigation',
+    'technical-pattern',
+    'project-rule',
+    // Slice E expansion — observed on-disk values, warm tier.
+    'design',
+    'handoff',
+    'session-handoff',
+    'project-todo',
+    'publish-closure',
+    'project-closure',
+    'slice-closure',
+    'slice-pilot-findings',
+    'sediment'
+];
+/**
+ * Hot/warm tier per kind. Insertion order IS the deterministic section order
+ * used by the generated `MEMORY.md` (`KIND_ORDER` in `index/reindex.ts`),
+ * so this object's key order is load-bearing — append new kinds at the end
+ * of their tier block rather than reshuffling existing entries.
+ *
+ * The `Record<ProjectMemoryKind, MemoryKindTier>` annotation makes a missing
+ * tier a compile error whenever `PROJECT_MEMORY_KINDS` grows.
+ */
+export const MEMORY_KIND_TIER = {
+    // hot — full body kept in the index
+    feedback: 'hot',
+    decision: 'hot',
+    rule: 'hot',
+    convention: 'hot',
+    module: 'hot',
+    lesson: 'hot',
+    bug: 'hot',
+    investigation: 'hot',
+    'technical-pattern': 'hot',
+    'project-rule': 'hot',
+    // warm — same entry shape, read on demand
+    project: 'warm',
+    reference: 'warm',
+    design: 'warm',
+    handoff: 'warm',
+    'session-handoff': 'warm',
+    'project-todo': 'warm',
+    'publish-closure': 'warm',
+    'project-closure': 'warm',
+    'slice-closure': 'warm',
+    'slice-pilot-findings': 'warm',
+    sediment: 'warm'
+};
+export const HOT_MEMORY_KINDS = PROJECT_MEMORY_KINDS.filter((kind) => MEMORY_KIND_TIER[kind] === 'hot');
+export const WARM_MEMORY_KINDS = PROJECT_MEMORY_KINDS.filter((kind) => MEMORY_KIND_TIER[kind] === 'warm');

package/dist/services/mode/mode-enforcement.d.ts

@@ -8,7 +8,10 @@ export type ConfirmationOptions = {
     forceConfirm?: boolean | undefined;
 };
 export declare class ConfirmationRequiredError extends Error {
-    constructor(transitionKey: TransitionKey);
+    readonly transitionKey: TransitionKey;
+    readonly mode: SkillPresenceMode;
+    readonly nextActions: readonly string[];
+    constructor(transitionKey: TransitionKey, mode: SkillPresenceMode);
 }
 export declare function requireUserConfirmation(options: ConfirmationOptions): Promise<void>;
 export {};

package/dist/services/mode/mode-enforcement.js

@@ -1,4 +1,3 @@
-import * as readline from 'node:readline';
 import { getSkillPresence } from '../skills/skill-presence-service.js';
 const ASSISTED_CONFIRM_TRANSITIONS = new Set([
     'prd:confirmed-by-user',
@@ -6,7 +5,9 @@ const ASSISTED_CONFIRM_TRANSITIONS = new Set([
     'qa:verdict-issued'
 ]);
 export function requiresConfirmation(mode, transitionKey) {
-    if (mode === 'full-auto' || mode === 'swarm') {
+    // Slice 2026-09-09-mode-consolidation: `swarm` removed as a mode; the
+    // two auto-proceed peers are `full-auto` and `24h`.
+    if (mode === 'full-auto' || mode === '24h') {
         return false;
     }
     if (mode === 'strict') {
@@ -22,12 +23,23 @@ function describeTransition(transitionKey) {
     return `Transition ${role.toUpperCase()} → ${state}`;
 }
 export class ConfirmationRequiredError extends Error {
-    constructor(transitionKey) {
+    transitionKey;
+    mode;
+    nextActions;
+    constructor(transitionKey, mode) {
         const description = describeTransition(transitionKey);
-        super(`Confirmation required for: ${description}\n` +
-            'Add --confirm to proceed non-interactively, or run in an interactive terminal.\n' +
-            'In assisted/strict mode, major workflow boundaries require explicit user approval.');
+        const nextActions = [
+            `Ask the user via AskUserQuestion whether to proceed with ${description} in ${mode} mode.`,
+            'If the user approves, re-run the same command with --confirm.'
+        ];
+        super(`Confirmation required for: ${description} (mode: ${mode})\n` +
+            `${nextActions[0]}\n` +
+            `${nextActions[1]}\n` +
+            'No terminal prompt is available: this gate never reads stdin.');
         this.name = 'ConfirmationRequiredError';
+        this.transitionKey = transitionKey;
+        this.mode = mode;
+        this.nextActions = nextActions;
     }
 }
 export async function requireUserConfirmation(options) {
@@ -40,11 +52,11 @@ export async function requireUserConfirmation(options) {
     if (!requiresConfirmation(mode, options.transitionKey)) {
         return;
     }
-    // --confirm flag bypasses interactive prompt
+    // --confirm flag bypasses the gate
     if (options.confirmed) {
         return;
     }
-    // PEAKS_AUTO_CONFIRM=1 only works for full-auto/swarm (already returned above)
+    // PEAKS_AUTO_CONFIRM=1 only works for full-auto/24h (already returned above)
     // For assisted/strict, env var is ignored unless --force-confirm is also set
     if (process.env.PEAKS_AUTO_CONFIRM === '1') {
         if (options.forceConfirm) {
@@ -53,7 +65,7 @@ export async function requireUserConfirmation(options) {
                 'This bypasses user confirmation. Use with caution.');
             return;
         }
-        throw new ConfirmationRequiredError(options.transitionKey);
+        throw new ConfirmationRequiredError(options.transitionKey, mode);
     }
     // --force-confirm without env var
     if (options.forceConfirm) {
@@ -62,23 +74,9 @@ export async function requireUserConfirmation(options) {
             'This bypasses user confirmation. Use with caution.');
         return;
     }
-    // Interactive prompt
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stderr
-    });
-    return new Promise((resolve, reject) => {
-        const description = describeTransition(options.transitionKey);
-        const prompt = `\n[CONFIRM] ${description}\nProceed? (y/N) `;
-        rl.question(prompt, (answer) => {
-            rl.close();
-            const normalized = answer.trim().toLowerCase();
-            if (normalized === 'y' || normalized === 'yes') {
-                resolve();
-            }
-            else {
-                reject(new ConfirmationRequiredError(options.transitionKey));
-            }
-        });
-    });
+    // No bypass flag: refuse immediately. Never read stdin — in an LLM-driven
+    // session there is no TTY, so a prompt would hang forever, and a `y/N`
+    // terminal prompt would also violate the Human-NL-Choice-Only rule (the
+    // user answers via AskUserQuestion, never by typing into a shell).
+    throw new ConfirmationRequiredError(options.transitionKey, mode);
 }

package/dist/services/mode/mode-status-service.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice D): one read for the whole
+ * stacked mode picture.
+ *
+ * The autonomy model has two layers that used to be read by nothing in
+ * common:
+ *
+ *   - MODE  — `SkillPresenceMode` on the presence lease: the autonomy
+ *     level (`full-auto | assisted | strict | 24h`).
+ *   - STATE — `.peaks/_runtime/<sid>/24h-state.json`, the 6-state
+ *     machine (`IDLE / BRAINSTORM / USER_CONFIRM / 24H_ACTIVE /
+ *     WAITING_USER / HANDOFF`): the long-run PHASE *inside* the `24h`
+ *     mode.
+ *
+ * This module is the single place that reads both, plus the Job-mode
+ * decision and the resolved auto-compact profile, so `peaks code mode
+ * status` (and any future consumer) does not re-derive the stack.
+ *
+ * Read-only + fail-soft: every sub-read is wrapped so a missing or
+ * malformed artifact degrades to `null` / `false` rather than throwing.
+ */
+import { type SkillPresenceMode } from '../skills/skill-presence-service.js';
+import type { State24hSnapshot } from '../24h-mode/state.js';
+import { type AutoCompactMode } from '../code/auto-compact-modes.js';
+export interface ResolvedPresenceMode {
+    readonly mode: SkillPresenceMode | null;
+    readonly skill: string | null;
+    readonly source: 'canonical' | 'file' | 'env' | 'none';
+}
+export interface ModeStatus {
+    /** Autonomy level from the presence lease; `null` when no lease / no mode recorded. */
+    readonly mode: SkillPresenceMode | null;
+    /** Active skill name from the same lease read (display aid). */
+    readonly skill: string | null;
+    /** Where the mode came from. */
+    readonly modeSource: 'canonical' | 'file' | 'env' | 'none';
+    /** `true` when the resolved mode is `24h`. */
+    readonly is24h: boolean;
+    /**
+     * The 24h internal state machine snapshot. Populated only when
+     * `is24h` is true (the phase is meaningless outside the 24h mode);
+     * `null` when the mode is not `24h` or the snapshot is unreadable.
+     */
+    readonly h24State: State24hSnapshot | null;
+    /** Job-mode flag from `job-shape.json` (`false` when undecided / unreadable). */
+    readonly jobMode: boolean;
+    /** Resolved auto-compact profile: `partial` iff the mode is `24h`. */
+    readonly autoCompactProfile: AutoCompactMode;
+    /** Thresholds backing `autoCompactProfile` (display aid). */
+    readonly autoCompactThresholds: {
+        readonly autoFire: number;
+        readonly preCompact: number;
+        readonly redLine: number;
+    };
+}
+/**
+ * Read the active presence mode via the canonical lease projection.
+ * Never throws.
+ */
+export declare function resolvePresenceMode(projectRoot: string): ResolvedPresenceMode;
+/**
+ * Resolve the auto-compact profile from the MODE, not from the 24h
+ * state machine. `24h` mode → `partial` (earlier thresholds for
+ * long-run sessions); every other mode → `standard`.
+ *
+ * Slice 2026-09-09-mode-consolidation: this replaced the previous
+ * `24h-state.state === '24H_ACTIVE'` mapping. The state machine is the
+ * long-run *phase*; the mode is the autonomy level the user (or the
+ * T3/T4 auto-engage) selected. Keying off the mode means a `24h`
+ * session keeps the partial profile even while it is in
+ * `WAITING_USER`, which is the correct long-run behaviour.
+ */
+export declare function resolveAutoCompactProfile(projectRoot: string): AutoCompactMode;
+/**
+ * Assemble the full stacked status. `sessionId` defaults to the
+ * canonical binding when omitted.
+ */
+export declare function resolveModeStatus(input: {
+    projectRoot: string;
+    sessionId?: string | null | undefined;
+}): ModeStatus;

package/dist/services/mode/mode-status-service.js

@@ -0,0 +1,108 @@
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice D): one read for the whole
+ * stacked mode picture.
+ *
+ * The autonomy model has two layers that used to be read by nothing in
+ * common:
+ *
+ *   - MODE  — `SkillPresenceMode` on the presence lease: the autonomy
+ *     level (`full-auto | assisted | strict | 24h`).
+ *   - STATE — `.peaks/_runtime/<sid>/24h-state.json`, the 6-state
+ *     machine (`IDLE / BRAINSTORM / USER_CONFIRM / 24H_ACTIVE /
+ *     WAITING_USER / HANDOFF`): the long-run PHASE *inside* the `24h`
+ *     mode.
+ *
+ * This module is the single place that reads both, plus the Job-mode
+ * decision and the resolved auto-compact profile, so `peaks code mode
+ * status` (and any future consumer) does not re-derive the stack.
+ *
+ * Read-only + fail-soft: every sub-read is wrapped so a missing or
+ * malformed artifact degrades to `null` / `false` rather than throwing.
+ */
+import { resolveActiveSkillForCaller } from '../audit/enforcers/active-skill-resolver.js';
+import { getCurrentSessionId } from '../skills/skill-presence-service.js';
+// Import the 24h store directly (NOT the `24h-mode/index.js` barrel) —
+// the barrel re-exports `decider.ts`, which imports this module, and
+// that would form an import cycle.
+import { read24hState } from '../24h-mode/store.js';
+import { readJobShapeDecision } from '../code/job-shape-decision.js';
+import { AUTO_COMPACT_THRESHOLDS } from '../code/auto-compact-modes.js';
+/**
+ * Read the active presence mode via the canonical lease projection.
+ * Never throws.
+ */
+export function resolvePresenceMode(projectRoot) {
+    try {
+        const resolved = resolveActiveSkillForCaller(projectRoot);
+        const mode = resolved.mode;
+        return {
+            mode: mode === null ? null : mode,
+            skill: resolved.skill,
+            source: resolved.source
+        };
+    }
+    catch {
+        return { mode: null, skill: null, source: 'none' };
+    }
+}
+/**
+ * Resolve the auto-compact profile from the MODE, not from the 24h
+ * state machine. `24h` mode → `partial` (earlier thresholds for
+ * long-run sessions); every other mode → `standard`.
+ *
+ * Slice 2026-09-09-mode-consolidation: this replaced the previous
+ * `24h-state.state === '24H_ACTIVE'` mapping. The state machine is the
+ * long-run *phase*; the mode is the autonomy level the user (or the
+ * T3/T4 auto-engage) selected. Keying off the mode means a `24h`
+ * session keeps the partial profile even while it is in
+ * `WAITING_USER`, which is the correct long-run behaviour.
+ */
+export function resolveAutoCompactProfile(projectRoot) {
+    return resolvePresenceMode(projectRoot).mode === '24h' ? 'partial' : 'standard';
+}
+/**
+ * Assemble the full stacked status. `sessionId` defaults to the
+ * canonical binding when omitted.
+ */
+export function resolveModeStatus(input) {
+    const { projectRoot } = input;
+    const presence = resolvePresenceMode(projectRoot);
+    const is24h = presence.mode === '24h';
+    let sessionId = input.sessionId ?? null;
+    if (sessionId === null) {
+        try {
+            sessionId = getCurrentSessionId(projectRoot);
+        }
+        catch {
+            sessionId = null;
+        }
+    }
+    let h24State = null;
+    if (is24h && sessionId !== null) {
+        try {
+            h24State = read24hState(projectRoot, sessionId);
+        }
+        catch {
+            h24State = null;
+        }
+    }
+    let jobMode = false;
+    if (sessionId !== null) {
+        try {
+            jobMode = readJobShapeDecision(projectRoot, sessionId).decision.isJob;
+        }
+        catch {
+            jobMode = false;
+        }
+    }
+    return {
+        mode: presence.mode,
+        skill: presence.skill,
+        modeSource: presence.source,
+        is24h,
+        h24State,
+        jobMode,
+        autoCompactProfile: is24h ? 'partial' : 'standard',
+        autoCompactThresholds: AUTO_COMPACT_THRESHOLDS[is24h ? 'partial' : 'standard']
+    };
+}

package/dist/services/preferences/preferences-types.d.ts

@@ -127,9 +127,23 @@ export interface ProjectPreferences {
      */
     readonly memoryPreflight?: {
         readonly enabled?: boolean;
+        /** Back-compat token cap; converted to bytes as `maxTokens * 4`. */
         readonly maxTokens?: number;
+        /** Back-compat hot item cap; `hotItemCap` overrides it when set. */
         readonly listCap?: number;
         readonly contentCacheBytes?: number;
+        /** Slice 2026-09-09-memory-retrieval: hard byte cap on the block. */
+        readonly maxBytes?: number;
+        /** Slice 2026-09-09-memory-retrieval: max hot items (default 10). */
+        readonly hotItemCap?: number;
+        /** Slice 2026-09-09-memory-retrieval: max warm items (default 4; 0 disables). */
+        readonly warmItemCap?: number;
+        /** Slice 2026-09-09-memory-retrieval: min task-token hits for warm eligibility. */
+        readonly warmMinTokenHits?: number;
+        /** Slice 2026-09-09-memory-retrieval: soft selection wall-clock budget (ms). */
+        readonly selectionTimeBudgetMs?: number;
+        /** Slice 2026-09-09-memory-retrieval: inline memo bodies (default false). */
+        readonly includeBodies?: boolean;
     };
 }
 export type FanoutMode = 'fan-out';

package/dist/services/preferences/preferences-types.js

@@ -48,5 +48,13 @@ export const DEFAULT_PREFERENCES = {
         maxTokens: 1200,
         listCap: 12,
         contentCacheBytes: 6000,
+        // Slice 2026-09-09-memory-retrieval tiered budget (see
+        // memory-preflight-config.ts::DEFAULTS).
+        maxBytes: 4800,
+        hotItemCap: 10,
+        warmItemCap: 4,
+        warmMinTokenHits: 1,
+        selectionTimeBudgetMs: 200,
+        includeBodies: false,
     },
 };

package/dist/services/share/run-state-contract.d.ts

@@ -64,8 +64,8 @@ export declare const RunStateContractSchema: z.ZodObject<{
     status: z.ZodEnum<{
         blocked: "blocked";
         failed: "failed";
-        running: "running";
         done: "done";
+        running: "running";
         paused: "paused";
     }>;
     current_step: z.ZodString;

package/dist/services/skills/presence-lease-service.d.ts

@@ -66,6 +66,27 @@ export interface GcPresenceLeasesInput {
     readonly trigger?: 'manual' | 'workspace-init' | 'presence-set';
 }
 export declare function setPresenceLease(input: SetPresenceLeaseInput): SetPresenceLeaseResult;
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice B): stamp `mode` onto every
+ * in-flight lease of the bound session, in place.
+ *
+ * Used by the 24h auto-engage path (T3/T4, `peaks code run --24h`,
+ * `peaks session 24h-mode transition --state 24H_ACTIVE`) to record the
+ * autonomy level without re-creating the lease (a fresh `setPresenceLease`
+ * would reset `startedAt` / `status`). `lastHeartbeat` is intentionally
+ * NOT touched — stamping a mode is not a liveness signal.
+ *
+ * Returns the number of leases updated; 0 when there is nothing in flight.
+ * Callers are responsible for the "only `24h` may be auto-set" guard.
+ */
+export declare function stampPresenceLeaseMode(input: {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly mode: string;
+}): {
+    updated: number;
+    leasePaths: string[];
+};
 export declare function readPresenceLease(input: ReadPresenceLeaseInput): PresenceProjection;
 export declare function markPresenceLost(input: MarkPresenceLostInput): SkillPresenceLease;
 export declare function gcStalePresenceLeases(input: GcPresenceLeasesInput): GcResult;