peaks-loop 4.0.32 → 4.0.34

package/dist/services/hooks/auto-compact-hook-install.d.ts

@@ -37,7 +37,7 @@
  */
 export declare const AUTO_COMPACT_HOOK_MATCHER = "Bash|Task";
 /**
- * Stable command the hook fires. Wraps `peaks compact auto` so the
+ * Stable command the hook fires. Wraps `peaks code auto-compact` so the
  * heavy lifting (ratio probe + in-band `claude --compact` spawn)
  * lives in the CLI surface, not inlined into the hook.
  *
@@ -46,7 +46,7 @@ export declare const AUTO_COMPACT_HOOK_MATCHER = "Bash|Task";
  * so the unqualified command works in the same shell the runner
  * is using.
  */
-export declare const AUTO_COMPACT_HOOK_COMMAND = "peaks compact auto";
+export declare const AUTO_COMPACT_HOOK_COMMAND = "peaks code auto-compact";
 /**
  * Magic comment marker that fences the auto-compatchook block.
  * Both install (writes the marker) and remove (matches on it) use

package/dist/services/hooks/auto-compact-hook-install.js

@@ -39,7 +39,7 @@ import { dirname, join } from 'node:path';
  */
 export const AUTO_COMPACT_HOOK_MATCHER = 'Bash|Task';
 /**
- * Stable command the hook fires. Wraps `peaks compact auto` so the
+ * Stable command the hook fires. Wraps `peaks code auto-compact` so the
  * heavy lifting (ratio probe + in-band `claude --compact` spawn)
  * lives in the CLI surface, not inlined into the hook.
  *
@@ -48,7 +48,7 @@ export const AUTO_COMPACT_HOOK_MATCHER = 'Bash|Task';
  * so the unqualified command works in the same shell the runner
  * is using.
  */
-export const AUTO_COMPACT_HOOK_COMMAND = 'peaks compact auto';
+export const AUTO_COMPACT_HOOK_COMMAND = 'peaks code auto-compact';
 /**
  * Magic comment marker that fences the auto-compatchook block.
  * Both install (writes the marker) and remove (matches on it) use

package/dist/services/ide/adapters/claude-code-adapter.d.ts

@@ -20,6 +20,57 @@ export declare function resolveClaudeModelFromEnv(env: NodeJS.ProcessEnv | undef
  * Callers MAY additionally infer ≥1M from the observed token count: if
  * `contextTokens > DEFAULT_CONTEXT_WINDOW_TOKENS`, the model cannot be a
  * 200K model and must be ≥1M (see `readClaudeTranscriptEstimate`).
+ *
+ * This is the HEURISTIC layer only. Explicit user overrides sit ABOVE it —
+ * see `resolveContextWindow`, which is what the probe actually calls.
  */
 export declare function modelContextWindowTokens(model: string): number;
+/**
+ * Slice 2026-09-09-context-window-override: vendor-neutral escape hatch for
+ * the context-window size in tokens. Third-party / proxied models whose id
+ * carries no `[1M]` suffix (and is absent from the hardcoded allowlist) are
+ * otherwise stuck at the 200K default, which inflates `ratio` up to 5×.
+ * Same spirit as `PEAKS_CALLER_ID`: an env var the user can export, plus a
+ * machine-wide `peaks config set --key context.windowTokens` twin.
+ */
+export declare const CONTEXT_WINDOW_TOKENS_ENV_VAR = "PEAKS_CONTEXT_WINDOW_TOKENS";
+/**
+ * Which layer produced a resolved context window:
+ *   - `env-override`     — `PEAKS_CONTEXT_WINDOW_TOKENS`
+ *   - `config`           — `context.windowTokens` (`peaks config set`)
+ *   - `model-heuristic`  — `[1M]` suffix / `ONE_MILLION_CONTEXT_MODELS`
+ *   - `default`          — 200K safe default
+ */
+export type ContextWindowSource = 'env-override' | 'config' | 'model-heuristic' | 'default';
+export interface ContextWindowResolution {
+    readonly tokens: number;
+    readonly source: ContextWindowSource;
+}
+/** Explicit override inputs (both optional; env wins over config). */
+export interface ContextWindowOverrides {
+    readonly env?: NodeJS.ProcessEnv | undefined;
+    /** Raw `context.windowTokens` value (unvalidated — validated here). */
+    readonly configWindowTokens?: unknown;
+    /** Warning sink for an invalid override (defaults to `console.warn`). */
+    readonly onInvalidOverride?: ((message: string) => void) | undefined;
+}
+/**
+ * Parse an explicit context-window override. Accepts a positive finite
+ * integer only (number, or a numeric string so an env var works); anything
+ * else — `0`, negative, `NaN`, `Infinity`, `1.5`, `'abc'`, `''` — returns
+ * null so the caller can ignore it and fall through to the next layer.
+ */
+export declare function parseContextWindowOverride(raw: unknown): number | null;
+/**
+ * Resolve the context window in tokens AND report which layer won
+ * (first hit wins):
+ *   1. env `PEAKS_CONTEXT_WINDOW_TOKENS`
+ *   2. config `context.windowTokens`
+ *   3. model-name heuristic (`modelContextWindowTokens`)
+ *   4. `DEFAULT_CONTEXT_WINDOW_TOKENS` (200_000)
+ *
+ * An invalid explicit override is ignored with a warning and falls through
+ * to the next layer — a typo must never crash or silently win the probe.
+ */
+export declare function resolveContextWindow(model: string, overrides?: ContextWindowOverrides): ContextWindowResolution;
 export declare const CLAUDE_CODE_ADAPTER: IdeAdapter;

package/dist/services/ide/adapters/claude-code-adapter.js

@@ -161,6 +161,9 @@ export function resolveClaudeModelFromEnv(env) {
  * Callers MAY additionally infer ≥1M from the observed token count: if
  * `contextTokens > DEFAULT_CONTEXT_WINDOW_TOKENS`, the model cannot be a
  * 200K model and must be ≥1M (see `readClaudeTranscriptEstimate`).
+ *
+ * This is the HEURISTIC layer only. Explicit user overrides sit ABOVE it —
+ * see `resolveContextWindow`, which is what the probe actually calls.
  */
 export function modelContextWindowTokens(model) {
     const m = model.trim().toLowerCase();
@@ -174,6 +177,60 @@ export function modelContextWindowTokens(model) {
     }
     return DEFAULT_CONTEXT_WINDOW_TOKENS;
 }
+/**
+ * Slice 2026-09-09-context-window-override: vendor-neutral escape hatch for
+ * the context-window size in tokens. Third-party / proxied models whose id
+ * carries no `[1M]` suffix (and is absent from the hardcoded allowlist) are
+ * otherwise stuck at the 200K default, which inflates `ratio` up to 5×.
+ * Same spirit as `PEAKS_CALLER_ID`: an env var the user can export, plus a
+ * machine-wide `peaks config set --key context.windowTokens` twin.
+ */
+export const CONTEXT_WINDOW_TOKENS_ENV_VAR = 'PEAKS_CONTEXT_WINDOW_TOKENS';
+/**
+ * Parse an explicit context-window override. Accepts a positive finite
+ * integer only (number, or a numeric string so an env var works); anything
+ * else — `0`, negative, `NaN`, `Infinity`, `1.5`, `'abc'`, `''` — returns
+ * null so the caller can ignore it and fall through to the next layer.
+ */
+export function parseContextWindowOverride(raw) {
+    if (typeof raw !== 'number' && typeof raw !== 'string')
+        return null;
+    if (typeof raw === 'string' && raw.trim().length === 0)
+        return null;
+    const parsed = typeof raw === 'number' ? raw : Number(raw.trim());
+    return Number.isFinite(parsed) && Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+/**
+ * Resolve the context window in tokens AND report which layer won
+ * (first hit wins):
+ *   1. env `PEAKS_CONTEXT_WINDOW_TOKENS`
+ *   2. config `context.windowTokens`
+ *   3. model-name heuristic (`modelContextWindowTokens`)
+ *   4. `DEFAULT_CONTEXT_WINDOW_TOKENS` (200_000)
+ *
+ * An invalid explicit override is ignored with a warning and falls through
+ * to the next layer — a typo must never crash or silently win the probe.
+ */
+export function resolveContextWindow(model, overrides = {}) {
+    const warn = overrides.onInvalidOverride ?? ((message) => console.warn(message));
+    const envRaw = overrides.env?.[CONTEXT_WINDOW_TOKENS_ENV_VAR];
+    if (envRaw !== undefined) {
+        const parsed = parseContextWindowOverride(envRaw);
+        if (parsed !== null)
+            return { tokens: parsed, source: 'env-override' };
+        warn(`[peaks] ${CONTEXT_WINDOW_TOKENS_ENV_VAR}="${String(envRaw)}" is not a positive integer — ignoring the override`);
+    }
+    if (overrides.configWindowTokens !== undefined) {
+        const parsed = parseContextWindowOverride(overrides.configWindowTokens);
+        if (parsed !== null)
+            return { tokens: parsed, source: 'config' };
+        warn(`[peaks] config context.windowTokens=${JSON.stringify(overrides.configWindowTokens)} is not a positive integer — ignoring the override`);
+    }
+    const heuristic = modelContextWindowTokens(model);
+    return heuristic === DEFAULT_CONTEXT_WINDOW_TOKENS
+        ? { tokens: heuristic, source: 'default' }
+        : { tokens: heuristic, source: 'model-heuristic' };
+}
 /** A non-negative finite number, or null when the value is not numeric. */
 function numericTokenCount(value) {
     if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
@@ -277,14 +334,20 @@ function findLatestTranscriptUsage(filePath) {
     }
 }
 /**
- * Resolve the context window for a transcript usage entry. Prefers the
- * explicit `modelContextWindowTokens(model)` mapping; when the observed token
- * count contradicts it (tokens exceed the mapped window), the model must be
- * ≥1M, so bump to the 1M window.
+ * Resolve the context window for a transcript usage entry. Explicit user
+ * overrides (`resolveContextWindow`) win outright — the user pinned the
+ * number, so nothing else may contradict it. Without an explicit override,
+ * when the observed token count contradicts the heuristic window (tokens
+ * exceed it), the model must be ≥1M, so bump to the 1M window (the late
+ * rescue; it keeps the heuristic source tag, only the tokens change).
  */
-function resolveContextWindowTokens(model, contextTokens) {
-    const window = modelContextWindowTokens(model);
-    return contextTokens > window ? ONE_MILLION_CONTEXT_TOKENS : window;
+function resolveContextWindowTokens(model, contextTokens, overrides = {}) {
+    const resolved = resolveContextWindow(model, overrides);
+    if (resolved.source === 'env-override' || resolved.source === 'config')
+        return resolved;
+    return contextTokens > resolved.tokens
+        ? { tokens: ONE_MILLION_CONTEXT_TOKENS, source: resolved.source }
+        : resolved;
 }
 /**
  * Conservative transcript-estimate fallback. Recursively searches
@@ -298,9 +361,11 @@ function resolveContextWindowTokens(model, contextTokens) {
  *
  * Window model resolution is env-first: when `envModel` is present, its id
  * (which Claude Code stamps with the `[1M]` / `[200K]` suffix) drives the
- * window; otherwise the transcript `message.model` is used.
+ * window; otherwise the transcript `message.model` is used. Explicit
+ * overrides (env `PEAKS_CONTEXT_WINDOW_TOKENS` / config `context.windowTokens`)
+ * sit above both and are reported via `capacitySource`.
  */
-function readClaudeTranscriptEstimate(outerSessionId, envModel) {
+function readClaudeTranscriptEstimate(outerSessionId, envModel, overrides = {}) {
     const projectsDir = join(homedir(), '.claude', 'projects');
     const path = findTranscriptJsonl(projectsDir, outerSessionId);
     if (path === null)
@@ -309,9 +374,10 @@ function readClaudeTranscriptEstimate(outerSessionId, envModel) {
     if (latest === null)
         return null;
     const model = envModel !== undefined && envModel.trim().length > 0 ? envModel : latest.model;
-    const contextWindowTokens = resolveContextWindowTokens(model, latest.contextTokens);
+    const resolved = resolveContextWindowTokens(model, latest.contextTokens, overrides);
+    const contextWindowTokens = resolved.tokens;
     const ratio = Math.min(1, latest.contextTokens / contextWindowTokens);
-    return { ratio, contextTokens: latest.contextTokens, contextWindowTokens };
+    return { ratio, contextTokens: latest.contextTokens, contextWindowTokens, capacitySource: resolved.source };
 }
 /**
  * Claude Code's vendor-specific context-percent fallback, exposed as
@@ -344,13 +410,17 @@ function readContextPercentFallback(input) {
     }
     if (typeof input.outerSessionId === 'string' && input.outerSessionId.length > 0) {
         const envModel = resolveClaudeModelFromEnv(input.env);
-        const estimate = readClaudeTranscriptEstimate(input.outerSessionId, envModel);
+        const estimate = readClaudeTranscriptEstimate(input.outerSessionId, envModel, {
+            env: input.env,
+            configWindowTokens: input.configWindowTokens
+        });
         if (estimate !== null) {
             return {
                 ratio: estimate.ratio,
                 source: 'transcript-estimate',
                 rawTokens: estimate.contextTokens,
                 capacityTokens: estimate.contextWindowTokens,
+                capacitySource: estimate.capacitySource,
                 ide,
                 capturedAt
             };
@@ -401,7 +471,7 @@ export const CLAUDE_CODE_ADAPTER = {
     // Pathway = 'ide-native' (not 'shell-exec') so the dispatcher
     // routes main-session compacts through the PreToolUse hook in
     // `.claude/settings.local.json`. The hook fires
-    // `peaks compact auto` on the NEXT Bash/Task tool
+    // `peaks code auto-compact` on the NEXT Bash/Task tool
     // call from the runner, which in-band spawns `claude --compact`
     // against the CURRENT runner — not a child process (the
     // shell-exec spawn-new-claude bug documented in
@@ -412,7 +482,7 @@ export const CLAUDE_CODE_ADAPTER = {
         envVarForContextPercent: 'CLAUDE_CONTEXT_USAGE_PERCENT',
         compactCommand: 'claude --compact',
         compactPathway: 'ide-native',
-        postCompactDetectCommand: 'peaks compact auto --json',
+        postCompactDetectCommand: 'peaks code auto-compact --json',
         readContextPercentFallback
     },
     // Slice #011: standards profile. Claude Code reads its constitution at

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

@@ -197,7 +197,7 @@ export interface IdeCompactProfile {
     readonly compactPathway: 'shell-exec' | 'ide-native' | 'llm-self-compress' | 'noop';
     /**
      * Optional command the runner invokes post-compact to confirm
-     * ratio dropped (e.g. `peaks compact auto --json`). When omitted,
+     * ratio dropped (e.g. `peaks code auto-compact --json`). When omitted,
      * the orchestrator polls `envVarForContextPercent` directly.
      */
     readonly postCompactDetectCommand?: string;
@@ -239,6 +239,15 @@ export interface ContextPercentFallbackInput {
     readonly outerSessionId?: string | undefined;
     /** Injectable env (defaults to process.env in the reader). */
     readonly env?: NodeJS.ProcessEnv | undefined;
+    /**
+     * Raw `context.windowTokens` value from the merged config (project layer
+     * over user layer), read by the generic reader so the adapter stays free
+     * of config-path knowledge. UNVALIDATED — the adapter validates it via
+     * `parseContextWindowOverride` and warns on a bad value.
+     *
+     * Slice 2026-09-09-context-window-override.
+     */
+    readonly configWindowTokens?: unknown;
 }
 /**
  * Per-IDE standards-file location + format profile. Used by the

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

@@ -76,7 +76,16 @@ export interface ProjectPreferences {
      * dispatch *shape* (worker graph vs flat dispatch).
      */
     readonly swarmMode: boolean;
+    /**
+     * Legacy UA opt-in prompt decision. The UA knowledge-graph surface was
+     * removed in 2026-09-09 (project analysis is codegraph-first); the field
+     * is retained only so legacy `.peaks/preferences.json` files keep parsing.
+     */
     readonly uaPrompt: UaPromptDecision;
+    /**
+     * Legacy AgentShield opt-in prompt decision. The ECC AgentShield
+     * subprocess was removed in 4.0.0-beta.11; retained for legacy parse.
+     */
     readonly agentShieldPrompt: UaPromptDecision;
     readonly classifyConservatism: ClassifyConservatism;
     readonly classifyRules: ClassifyRuleOverrides;
@@ -84,15 +93,15 @@ export interface ProjectPreferences {
     /** Loop Autonomous (L4 14.5) toggle. Default: false — never auto-enable. */
     readonly loopAutonomousEnabled: boolean;
     /**
-     * L2.3 P2-a: ECC AgentShield subprocess toggle. Default: false.
+     * L2.3 P2-a: ECC AgentShield subprocess toggle — **frozen, no-op**.
      *
-     * When true, `peaks audit static` spawns `npx ecc-agentshield scan --json`
-     * and merges its findings into the audit report. When false (default),
-     * the audit runs peaks-loop-only and the subprocess is never spawned.
+     * Slice 3 of 4.0.0-beta.11 removed the ECC AgentShield subprocess
+     * entirely (upstream ships no `ecc-agentshield` binary). The field is
+     * retained only so legacy `.peaks/preferences.json` files still parse
+     * (`static-service.ts` calls `loadPreferences` for back-compat and
+     * ignores the value). Setting it to `true` has no effect.
      *
-     * The preference is independent of whether ECC is installed — i.e.
-     * `agentShieldEnabled: true` with ECC missing surfaces a soft
-     * "ECC not installed" warning and the audit still completes.
+     * Default: false.
      */
     readonly agentShieldEnabled: boolean;
     /**

package/dist/services/recommendations/capability-seed-items.js

@@ -98,7 +98,6 @@ export const seedCapabilityItems = [
     capability('gitnexus.repo-intelligence', 'gitnexus', 'GitNexus Repository Intelligence', 'cli', 'repo-intelligence', ['engineer'], 'medium', 'local-repo-scan', 'Use local project scanning through Peaks RD.', 'Repository Intelligence', '仓库智能分析', 'Repository intelligence should be proxied through Peaks before use.', '仓库智能分析应先通过 Peaks 代理边界再使用。'),
     capability('claude-code-best-practice.workflow-guidance', 'claude-code-best-practice', 'Claude Code Best Practice', 'doc', 'workflow-guidance', ['engineer'], 'low', 'peaks-built-in-rules', 'Use Peaks built-in workflow and review rules.', 'Claude Code Best Practice', 'Claude Code 最佳实践', 'Guidance for Claude Code engineering workflows.', 'Claude Code 工程工作流指导。'),
     capability('superpowers.workflow-methodology', 'superpowers', 'Superpowers Methodology', 'workflow', 'workflow-methodology', ['product', 'engineer'], 'low', 'peaks-workflow-route', 'Use Peaks route/autonomous plans.', 'Superpowers Methodology', 'Superpowers 方法论', 'Workflow and artifact methodology reference.', '工作流与 artifact 方法论参考。'),
-    capability('understand-anything.knowledge-graph', 'understand-anything', 'Understand Anything Knowledge Graph', 'skill', 'project-analysis', ['engineer', 'product', 'qa'], 'low', 'peaks-codegraph-or-rd-scan', 'Use peaks codegraph or peaks RD project scan when Understand Anything is not installed. Optionally suggest installing it via Claude Code: /plugin marketplace add Lum1104/Understand-Anything then /plugin install understand-anything.', 'Understand Anything Knowledge Graph', 'Understand Anything 知识图谱', 'Multi-agent project knowledge graph that Peaks reads from .understand-anything/knowledge-graph.json when it has been generated by the Understand Anything plugin in Claude Code.', '通过 Claude Code 的 Understand Anything 插件生成的多 agent 知识图谱，Peaks 在 .understand-anything/knowledge-graph.json 存在时读取它作为项目分析证据。'),
     capability('penpot.design-source', 'penpot', 'Penpot Design Source', 'doc', 'design-source', ['designer', 'engineer'], 'medium', 'manual-design-input', 'Ask for exported design notes or screenshots.', 'Penpot Design Source', 'Penpot 设计来源', 'Design-source reference for UI planning.', '用于 UI 规划的设计来源参考。'),
     capability('gstack.product-stack-guidance', 'gstack', 'Product Stack Guidance', 'doc', 'product-guidance', ['product'], 'low', 'peaks-prd', 'Use peaks-prd for product goals and non-goals.', 'Product Stack Guidance', '产品栈指导', 'Product and startup stack guidance reference.', '产品与创业栈指导参考。'),
     capability('awesome-design-md.design-reference', 'awesome-design-md', 'Design Markdown Reference', 'doc', 'design-reference', ['designer', 'engineer'], 'low', 'peaks-ui-visual-direction', 'Use peaks-ui to define visual direction and interaction constraints.', 'Design Reference', '设计参考', 'Design markdown examples and inspiration.', '设计 markdown 示例与灵感。'),