peaks-loop 4.0.33 → 4.0.34

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 4.0.34 — 2026-09-09 (mode 模型收敛 + auto-compact 死命令 + 上下文窗口覆盖 + 确认门去 TTY)
+
+**Highlights**:
+
+1. **mode 模型收敛（用户设计）** — 此前 `SkillPresenceMode` 与 24h 状态机是两个互不相识的自主性开关。
+
+   - `SkillPresenceMode = full-auto | assisted | strict | 24h`（四选一，并列）。
+   - `swarm` 从"模式"降级为**所有 mode 的默认执行策略**（与"fan-out 强制、不可退回串行"一致）。
+   - 24h 的 6 状态机保留为 **24h mode 的内部状态**；24h 是**唯一可自动开启**的 mode（T1–T5），其余 mode 仍需用户选。
+   - 新增 `peaks code mode status`：一条命令输出 presence mode / 24h 状态 / job mode / auto-compact profile。
+   - **顺带修好一个严重 bug**：`getSkillPresence()` 一直在丢掉 `mode` 字段，导致所有读 `presence.mode` 的守卫（mode-enforcement、assisted/strict 边界、post-compact-detector）**全是死代码**——用户选的 mode 从未真正生效。
+
+2. **auto-compact 契约指向不存在的命令（根因）** — `peaks compact auto --execute` 在 `skills/` + `src/` 出现 **49 次**（含 CLI 自己返回的 `next`），实际执行是 `COMMAND_NOT_FOUND`。真命令是 `peaks code auto-compact`。LLM 按契约执行 → 撞死命令 → 只能回头让用户手动 compact。全部引用已改指真命令，并加守卫测试防回归。
+
+3. **上下文窗口不再对未知模型默认 20w** — 新增 `PEAKS_CONTEXT_WINDOW_TOKENS`（env）与 `context.windowTokens`（config）覆盖，优先级 env > config > 启发式 > 默认；`peaks code context-now` 新增 `capacitySource` 字段，一眼看出窗口值来自哪。
+
+4. **assisted/strict 确认门不再阻塞在 TTY** — `requireUserConfirmation` 此前会开 `readline` 的 `(y/N)` 提示；LLM 会话里 stdin 非 TTY → 直接挂死，且违反 Human-NL-Choice-Only。现改为立即抛出带 `transitionKey` + `mode` + 可执行 nextActions 的错误，由 LLM 用 `AskUserQuestion` 承接、用户同意后重跑 `--confirm`。bypass 语义（`--confirm` / `--force-confirm` / `PEAKS_AUTO_CONFIRM`）完全不变。
+
+**验证**：build clean、tsc clean、全量 126 files / 1102 passed（1 skipped）；实测 `capacitySource` 默认 `model-heuristic`、`PEAKS_CONTEXT_WINDOW_TOKENS=400000` → `env-override`。
+
 ## 4.0.33 — 2026-09-09 (ECC 去插件化 + 动态获取修复 + 移除 understand-anything)
 
 **Highlights**:

package/dist/cli/commands/code-commands.js

@@ -23,6 +23,7 @@
  * registerCodeCommands (now a thin orchestrator).
  */
 import { registerCodeRunCommand } from './code-run-command.js';
+import { registerCodeModeStatusCommand } from './code-mode-status-command.js';
 import { registerCodeModeGateCommands } from './code-mode-gate-commands.js';
 import { registerCodeJobShapeCommands } from './code-job-shape-commands.js';
 import { registerCodeRuntimeCommands } from './code-runtime-commands.js';
@@ -113,6 +114,7 @@ export function registerCodeCommands(program, io) {
         .command('code', { hidden: true })
         .description('peaks-code LLM-side workflow planner (slice 2 fast mode)');
     registerCodeModeGateCommands(code, io);
+    registerCodeModeStatusCommand(code, io);
     registerCodeJobShapeCommands(code, io);
     registerCodeRuntimeCommands(code, io);
     registerCodeOrchestratorCanDoCommand(code, io);

package/dist/cli/commands/code-mode-gate-commands.js

@@ -35,7 +35,7 @@ export function registerCodeModeGateCommands(code, io) {
     addJsonOption(code
         .command('should-pause')
         .description('v2.11.0 D5: ask the mode-gate whether the LLM should pause for an AskUserQuestion at a given step. ' +
-        'full-auto / swarm auto-proceed (recommended = chosen); assisted / strict pause. ' +
+        'full-auto / 24h auto-proceed (recommended = chosen); assisted / strict pause. ' +
         'The 3 hard-floor categories always pause regardless of mode. ' +
         'v2.15.0 slice 002 AC-2: when --step step-1-mode-select AND the recorded skill presence is stale ' +
         '(outer-session-mismatch / no-presence), the gate returns shouldPause: true with reason "stale-presence" ' +
@@ -50,7 +50,7 @@ export function registerCodeModeGateCommands(code, io) {
         // pause on `step-1-mode-select` (mode-selection-itself) will
         // pause regardless, and the LLM-side caller can present
         // AskUserQuestion without first knowing the mode.
-        .option('--mode <mode>', 'one of: full-auto, assisted, swarm, strict. Defaults to full-auto when omitted (Step 1 chicken-and-egg fix).')
+        .option('--mode <mode>', 'one of: full-auto, assisted, strict, 24h. Defaults to full-auto when omitted (Step 1 chicken-and-egg fix).')
         .option('--hard-floor <category>', 'optional hard-floor override (irreversible-external-side-effect | authentication-credential | multi-day-investment | commit-boundary-side-effect)')
         .option('--recommended <option>', 'recommended option label to log when auto-proceeding', 'recommended-option')
         .option('--project <path>', 'v2.15.0 slice 002 AC-2: project root for presence:check-stale. Default: cwd. Pass only when step=step-1-mode-select.')
@@ -64,7 +64,7 @@ export function registerCodeModeGateCommands(code, io) {
             // step-1-mode-select will still pause regardless.
             const mode = opts.mode ?? 'full-auto';
             if (!isCodeMode(mode)) {
-                printResult(io, fail('code.should-pause', 'INVALID_MODE', `mode must be one of full-auto, assisted, swarm, strict (got "${mode}")`, { provided: mode }, ['Pass --mode full-auto | assisted | swarm | strict']), opts.json);
+                printResult(io, fail('code.should-pause', 'INVALID_MODE', `mode must be one of full-auto, assisted, strict, 24h (got "${mode}")`, { provided: mode }, ['Pass --mode full-auto | assisted | strict | 24h']), opts.json);
                 process.exitCode = 1;
                 return;
             }

package/dist/cli/commands/code-mode-status-command.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice D) — `peaks code mode status`.
+ *
+ * One read for the whole stacked autonomy picture:
+ *   - presence MODE (`full-auto | assisted | strict | 24h`),
+ *   - the 24h internal state machine (only when the mode is `24h`),
+ *   - Job mode,
+ *   - the resolved auto-compact profile (`standard | partial`).
+ *
+ * Read-only and fail-soft: the service degrades every unreadable
+ * artifact to `null` / `false`; this command only wraps the call in an
+ * envelope. Nested under the existing `peaks code` verb (no new
+ * top-level verb — peaks-loop is enhancement, not a new CLI surface).
+ */
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerCodeModeStatusCommand(code: Command, io: ProgramIO): void;

package/dist/cli/commands/code-mode-status-command.js

@@ -0,0 +1,51 @@
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice D) — `peaks code mode status`.
+ *
+ * One read for the whole stacked autonomy picture:
+ *   - presence MODE (`full-auto | assisted | strict | 24h`),
+ *   - the 24h internal state machine (only when the mode is `24h`),
+ *   - Job mode,
+ *   - the resolved auto-compact profile (`standard | partial`).
+ *
+ * Read-only and fail-soft: the service degrades every unreadable
+ * artifact to `null` / `false`; this command only wraps the call in an
+ * envelope. Nested under the existing `peaks code` verb (no new
+ * top-level verb — peaks-loop is enhancement, not a new CLI surface).
+ */
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
+import { resolveModeStatus } from '../../services/mode/mode-status-service.js';
+export function registerCodeModeStatusCommand(code, io) {
+    // Explicit two-step nesting (NOT `.command('mode status')` — that form
+    // creates a positional `<status>` argument, not a subcommand).
+    const mode = code
+        .command('mode')
+        .description('Mode introspection (read-only). Sub-actions: status.');
+    addJsonOption(mode
+        .command('status')
+        .description('v4.0.34 (slice 2026-09-09-mode-consolidation): one read for the whole stacked ' +
+        'autonomy picture — presence mode, the 24h internal state (when mode=24h), Job mode, ' +
+        'and the resolved auto-compact profile. Read-only + fail-soft.')
+        .option('--project <path>', 'project root (defaults to current directory)')
+        .option('--session-id <sessionId>', 'explicit session id (defaults to the canonical binding)')).action((options) => {
+        try {
+            const projectRoot = resolveCanonicalProjectRoot(options.project ?? process.cwd());
+            const status = resolveModeStatus({
+                projectRoot,
+                sessionId: options.sessionId ?? null
+            });
+            printResult(io, ok('code.mode.status', { projectRoot, ...status }, [], [
+                status.mode === null
+                    ? 'No presence mode recorded — Step 1 mode selection has not run for this session.'
+                    : `mode=${status.mode} (${status.modeSource}) → auto-compact profile=${status.autoCompactProfile}`
+            ]), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('code.mode.status', 'MODE_STATUS_FAILED', getErrorMessage(error), null, [
+                'Verify the project path and try again'
+            ]), options.json);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/cli/commands/code-run-command.js

@@ -1,5 +1,6 @@
 import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
 import { read24hState, write24hState } from '../../services/24h-mode/index.js';
+import { applyAutoEngagePresenceMode } from '../../services/24h-mode/auto-engage.js';
 import { getErrorMessage } from '../cli-helpers.js';
 function emit(io, payload, json) {
     io.stdout((json === true ? JSON.stringify(payload) : JSON.stringify(payload, null, 2)) + '\n');
@@ -54,9 +55,15 @@ export function registerCodeRunCommand(code, io) {
                 enteredFrom: current.state,
                 exitCondition: null
             });
+            // Slice 2026-09-09-mode-consolidation (Slice B): auto-engage is the
+            // ONLY path allowed to set a mode without a user pick, and `24h` is
+            // the only mode it may set. Stamp it onto the in-flight presence
+            // lease so the mode gate / statusline / `peaks code mode status`
+            // see the same autonomy level the 24h state machine is running.
+            const presenceMode = applyAutoEngagePresenceMode({ projectRoot, sessionId: sid });
             emit(io, {
                 ok: true,
-                data: { changeId: changeId ?? null, mode: '24H_ACTIVE', state: nextState, autoEngaged: true, trigger: options.trigger ?? options.tier, sessionId: sid, path: next.path },
+                data: { changeId: changeId ?? null, mode: '24H_ACTIVE', state: nextState, autoEngaged: true, trigger: options.trigger ?? options.tier, sessionId: sid, path: next.path, presenceMode },
                 next: 'Continue the existing 24H_ACTIVE flow; no brainstorming gate is required for T3/T4.'
             }, options.json);
         }

package/dist/cli/commands/code-runtime-commands.js

@@ -140,7 +140,11 @@ export function registerCodeRuntimeCommands(code, io) {
         'hermes / openclaw register their own env-var via IdeAdapter.compact. ' +
         'v3.1.2: when --enforce-job-mode is set OR job-shape.json says isJob=true, ' +
         '≥0.85 emits action=auto-compact-now (MANDATORY, not advisory) and ' +
-        '≥0.95 emits action=red-line (forced hook fires next turn).')
+        '≥0.95 emits action=red-line (forced hook fires next turn). ' +
+        'Context-window override: set env PEAKS_CONTEXT_WINDOW_TOKENS=<positive int> ' +
+        'or `peaks config set --key context.windowTokens --value <positive int>`; ' +
+        'the JSON envelope reports the winning layer as capacitySource ' +
+        '(env-override | config | model-heuristic | default).')
         .requiredOption('--project <path>', 'target project root')
         .option('--session-id <sid>', 'override session id (default: read from active presence)')
         .option('--enforce-job-mode', 'v3.1.2: treat ≥0.85 as MANDATORY auto-compact (not advisory). Auto-enabled when job-shape.json says isJob=true.')
@@ -190,12 +194,12 @@ export function registerCodeRuntimeCommands(code, io) {
             let next = null;
             if (probe.ratio >= 0.95) {
                 action = isJobMode ? 'red-line' : 'red-line';
-                next = 'peaks compact auto --execute';
+                next = 'peaks code auto-compact';
             }
             else if (probe.ratio >= 0.85) {
                 if (isJobMode) {
                     action = 'auto-compact-now';
-                    next = 'peaks compact auto --execute';
+                    next = 'peaks code auto-compact';
                 }
                 else {
                     action = 'soft-warn';
@@ -224,6 +228,10 @@ export function registerCodeRuntimeCommands(code, io) {
                 rawBytes: probe.rawBytes ?? null,
                 rawTokens: probe.rawTokens ?? null,
                 capacityTokens: probe.capacityTokens ?? null,
+                // Slice 2026-09-09-context-window-override: which layer produced
+                // capacityTokens (env-override | config | model-heuristic |
+                // default) — null for byte/percent sources, which have no window.
+                capacitySource: probe.capacitySource ?? null,
                 bytesPrompt: promptSizeBytes ?? null,
                 capturedAt: probe.capturedAt
             }, [], [
@@ -233,8 +241,8 @@ export function registerCodeRuntimeCommands(code, io) {
                         ? `Job-mode MANDATORY auto-compact. Code MUST call \`${next}\` WITHOUT confirmation.`
                         : action === 'soft-warn'
                             ? isJobMode
-                                ? `Job mode soft-warn (50–85%). Continue working; the next \`peaks compact auto\` will re-check.`
-                                : `Soft warn (50–85%). Continue working; the next \`peaks compact auto\` will re-check.`
+                                ? `Job mode soft-warn (50–85%). Continue working; the next \`peaks code auto-compact\` will re-check.`
+                                : `Soft warn (50–85%). Continue working; the next \`peaks code auto-compact\` will re-check.`
                             : `Below 50%. No action required.`,
                 jobModeNotice
             ]), true);

package/dist/cli/commands/core/skill-command.js

@@ -202,7 +202,7 @@ export function registerSkillCommand(program, io) {
         const projectOption = canonicalizeProjectOption(options.project);
         const projectRoot = projectOption ?? findProjectRoot(process.cwd()) ?? process.cwd();
         if (options.mode !== undefined && !isSkillPresenceMode(options.mode)) {
-            printResult(io, fail('skill.presence:set', 'INVALID_MODE', `Invalid mode: ${options.mode} (expected one of: full-auto, assisted, swarm, strict)`, { name, mode: options.mode }, ['Use a valid mode: full-auto, assisted, swarm, or strict']), options.json);
+            printResult(io, fail('skill.presence:set', 'INVALID_MODE', `Invalid mode: ${options.mode} (expected one of: full-auto, assisted, strict, 24h)`, { name, mode: options.mode }, ['Use a valid mode: full-auto, assisted, strict, or 24h']), options.json);
             process.exitCode = 1;
             return;
         }

package/dist/cli/commands/request-commands.js

@@ -158,7 +158,7 @@ export function registerRequestCommands(program, io) {
         .option('--session-id <session>', 'restrict to a specific session id')
         .option('--reason <text>', 'reason appended as a transition note; required when --allow-incomplete is set')
         .option('--allow-incomplete', 'bypass artifact prerequisite checks; requires --reason and records the bypass in the artifact')
-        .option('--confirm', 'skip interactive confirmation prompt (for non-interactive / LLM contexts)')
+        .option('--confirm', 'skip the confirmation gate (for non-interactive / LLM contexts)')
         .option('--force-confirm', 'bypass mode-enforced confirmation (use with caution)')).action(async (requestId, options) => {
         try {
             const role = options.role;
@@ -186,7 +186,7 @@ export function registerRequestCommands(program, io) {
                 const presence = getSkillPresence(options.project);
                 if (presence?.mode === 'assisted' || presence?.mode === 'strict') {
                     if (options.confirm !== true) {
-                        printResult(io, fail('request.transition', 'ALLOW_INCOMPLETE_RESTRICTED', `--allow-incomplete requires --confirm in ${presence.mode} mode`, { role, requestId, mode: presence.mode }, ['Add --confirm to proceed non-interactively, or run in an interactive terminal.']), options.json);
+                        printResult(io, fail('request.transition', 'ALLOW_INCOMPLETE_RESTRICTED', `--allow-incomplete requires --confirm in ${presence.mode} mode`, { role, requestId, mode: presence.mode }, ['Ask the user via AskUserQuestion whether to proceed, then re-run with --confirm if they approve.']), options.json);
                         process.exitCode = 1;
                         return;
                     }
@@ -387,11 +387,7 @@ export function registerRequestCommands(program, io) {
                 return;
             }
             if (error instanceof ConfirmationRequiredError) {
-                printResult(io, fail('request.transition', 'CONFIRMATION_REQUIRED', error.message, { role: options.role, requestId }, [
-                    'Add --confirm to proceed non-interactively.',
-                    'Or run in an interactive terminal.',
-                    'In assisted/strict mode, major workflow boundaries require explicit user approval.'
-                ]), options.json);
+                printResult(io, fail('request.transition', 'CONFIRMATION_REQUIRED', error.message, { role: options.role, requestId, transitionKey: error.transitionKey, mode: error.mode }, [...error.nextActions]), options.json);
                 process.exitCode = 1;
                 return;
             }

package/dist/cli/commands/session-24h-mode.js

@@ -20,6 +20,7 @@
 import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
 import { getErrorMessage } from '../cli-helpers.js';
 import { HANDOFF_EXIT_CONDITIONS, STATES, emptySnapshot, isHandoffExitCondition, isState, read24hState, write24hState } from '../../services/24h-mode/index.js';
+import { applyAutoEngagePresenceMode } from '../../services/24h-mode/auto-engage.js';
 function splitList(value) {
     if (!value)
         return [];
@@ -135,7 +136,14 @@ export function registerSession24hModeCommand(session, io) {
                 exitCondition: target === 'HANDOFF' ? (merged.exitCondition ?? null) : current.exitCondition
             };
             const result = write24hState(projectRoot, sid, next);
-            printJson(io, { ok: true, data: { ...next, path: result.path } }, merged);
+            // Slice 2026-09-09-mode-consolidation (Slice B): entering 24H_ACTIVE
+            // is an auto-engage of the `24h` mode. Stamp it onto the presence
+            // lease; every other target state leaves the mode untouched (the
+            // guard in `applyAutoEngagePresenceMode` refuses non-24h modes).
+            const presenceMode = target === '24H_ACTIVE'
+                ? applyAutoEngagePresenceMode({ projectRoot, sessionId: sid })
+                : null;
+            printJson(io, { ok: true, data: { ...next, path: result.path, presenceMode } }, merged);
         }
         catch (error) {
             printError(io, '24H_STATE_WRITE_FAILED', getErrorMessage(error), merged);

package/dist/services/24h-mode/auto-engage.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice B): auto-engage may set the
+ * 24h MODE — and ONLY the 24h mode.
+ *
+ * `24h` is the single mode that may be set without an explicit user pick
+ * (the T1–T5 triggers, and `peaks code run --24h`). Every other mode
+ * still requires the Step-1 hard-pause AskUserQuestion
+ * (`mode-gate.shouldPauseAtGate` keeps `step-1-mode-select` in
+ * `HARD_PAUSE_STEPS`).
+ *
+ * Before this slice the auto-engage paths wrote only
+ * `.peaks/_runtime/<sid>/24h-state.json`; the presence lease kept
+ * whatever mode it had (or none), so `24h` was invisible to the mode
+ * gate and `strict` + `24H_ACTIVE` still paused every gate. This module
+ * is the single place that closes that gap, and the single guard that
+ * refuses to stamp any other mode.
+ */
+export declare const AUTO_ENGAGE_PRESENCE_MODE: "24h";
+export type AutoEngagePresenceResult = {
+    applied: true;
+    mode: typeof AUTO_ENGAGE_PRESENCE_MODE;
+    updated: number;
+} | {
+    applied: false;
+    mode: string;
+    reason: 'mode-not-auto-settable' | 'no-in-flight-lease' | 'stamp-failed';
+};
+/**
+ * Stamp the 24h mode onto every in-flight presence lease of the bound
+ * session. Fail-soft: never throws — a missing lease / unreadable store
+ * degrades to `{ applied: false }` so the auto-engage caller can still
+ * report the 24h-state transition.
+ */
+export declare function applyAutoEngagePresenceMode(input: {
+    projectRoot: string;
+    sessionId: string;
+    /** Defaults to `24h`; any other value is refused. */
+    mode?: string;
+}): AutoEngagePresenceResult;

package/dist/services/24h-mode/auto-engage.js

@@ -0,0 +1,46 @@
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice B): auto-engage may set the
+ * 24h MODE — and ONLY the 24h mode.
+ *
+ * `24h` is the single mode that may be set without an explicit user pick
+ * (the T1–T5 triggers, and `peaks code run --24h`). Every other mode
+ * still requires the Step-1 hard-pause AskUserQuestion
+ * (`mode-gate.shouldPauseAtGate` keeps `step-1-mode-select` in
+ * `HARD_PAUSE_STEPS`).
+ *
+ * Before this slice the auto-engage paths wrote only
+ * `.peaks/_runtime/<sid>/24h-state.json`; the presence lease kept
+ * whatever mode it had (or none), so `24h` was invisible to the mode
+ * gate and `strict` + `24H_ACTIVE` still paused every gate. This module
+ * is the single place that closes that gap, and the single guard that
+ * refuses to stamp any other mode.
+ */
+import { stampPresenceLeaseMode } from '../skills/presence-lease-service.js';
+export const AUTO_ENGAGE_PRESENCE_MODE = '24h';
+/**
+ * Stamp the 24h mode onto every in-flight presence lease of the bound
+ * session. Fail-soft: never throws — a missing lease / unreadable store
+ * degrades to `{ applied: false }` so the auto-engage caller can still
+ * report the 24h-state transition.
+ */
+export function applyAutoEngagePresenceMode(input) {
+    const mode = input.mode ?? AUTO_ENGAGE_PRESENCE_MODE;
+    if (mode !== AUTO_ENGAGE_PRESENCE_MODE) {
+        return { applied: false, mode, reason: 'mode-not-auto-settable' };
+    }
+    let updated;
+    try {
+        updated = stampPresenceLeaseMode({
+            projectRoot: input.projectRoot,
+            sessionId: input.sessionId,
+            mode: AUTO_ENGAGE_PRESENCE_MODE
+        }).updated;
+    }
+    catch {
+        return { applied: false, mode, reason: 'stamp-failed' };
+    }
+    if (updated === 0) {
+        return { applied: false, mode, reason: 'no-in-flight-lease' };
+    }
+    return { applied: true, mode: AUTO_ENGAGE_PRESENCE_MODE, updated };
+}

package/dist/services/24h-mode/decider.d.ts

@@ -95,9 +95,15 @@ export type HandoffExitCondition = (typeof HANDOFF_EXIT_CONDITIONS)[number];
 export declare function isHandoffExitCondition(s: string): s is HandoffExitCondition;
 export declare function isHandoffState(s: State): boolean;
 /**
- * Slice 2026-07-28 (rid-027): resolve the auto-compact mode from
- * 24h-mode awareness. Returns `'partial'` when the session is
- * `24H_ACTIVE`, otherwise `'standard'`. This is the CLI-side default;
- * the explicit `--mode` flag in `peaks compact auto` overrides it.
+ * Slice 2026-07-28 (rid-027), re-keyed by slice
+ * 2026-09-09-mode-consolidation: resolve the auto-compact mode from
+ * the PRESENCE MODE, not the 24h state machine. Returns `'partial'`
+ * when the mode is `24h`, otherwise `'standard'`. This is the CLI-side
+ * default; the explicit `--mode` flag in `peaks code auto-compact`
+ * overrides it.
+ *
+ * `sessionId` is retained in the signature for callers that still pass
+ * it; the resolution itself is project-scoped (the presence lease is
+ * per project + caller).
  */
-export declare function getAutoCompactMode(projectRoot: string, sessionId: string): AutoCompactMode;
+export declare function getAutoCompactMode(projectRoot: string, _sessionId?: string): AutoCompactMode;

package/dist/services/24h-mode/decider.js

@@ -11,7 +11,7 @@
  * WAITING_USER — proposal §1 T3/T4 exception).
  */
 import { B3_THRESHOLD, isDecisionKey } from './state.js';
-import { read24hState } from './store.js';
+import { resolveAutoCompactProfile } from '../mode/mode-status-service.js';
 export const B3_TRIGGER_REASONS = [
     'prd_direction_change',
     'blocker_3_consecutive_slices',
@@ -128,17 +128,17 @@ export function isHandoffState(s) {
     return s === 'HANDOFF';
 }
 /**
- * Slice 2026-07-28 (rid-027): resolve the auto-compact mode from
- * 24h-mode awareness. Returns `'partial'` when the session is
- * `24H_ACTIVE`, otherwise `'standard'`. This is the CLI-side default;
- * the explicit `--mode` flag in `peaks compact auto` overrides it.
+ * Slice 2026-07-28 (rid-027), re-keyed by slice
+ * 2026-09-09-mode-consolidation: resolve the auto-compact mode from
+ * the PRESENCE MODE, not the 24h state machine. Returns `'partial'`
+ * when the mode is `24h`, otherwise `'standard'`. This is the CLI-side
+ * default; the explicit `--mode` flag in `peaks code auto-compact`
+ * overrides it.
+ *
+ * `sessionId` is retained in the signature for callers that still pass
+ * it; the resolution itself is project-scoped (the presence lease is
+ * per project + caller).
  */
-export function getAutoCompactMode(projectRoot, sessionId) {
-    try {
-        const snap = read24hState(projectRoot, sessionId);
-        return snap.state === '24H_ACTIVE' ? 'partial' : 'standard';
-    }
-    catch {
-        return 'standard';
-    }
+export function getAutoCompactMode(projectRoot, _sessionId) {
+    return resolveAutoCompactProfile(projectRoot);
 }

package/dist/services/audit/enforcers/active-skill-resolver.d.ts

@@ -30,7 +30,9 @@ export interface ActiveSkillResolution {
     readonly sessionId: string | null;
     /**
      * Mode token recorded on the canonical lease (e.g. `full-auto`,
-     * `assisted`, `swarm`, `strict`). `null` when the source is not
+     * `assisted`, `strict`, `24h`). Normalized on read: a legacy
+     * on-disk `'swarm'` surfaces as `'full-auto'` (slice
+     * 2026-09-09-mode-consolidation). `null` when the source is not
      * `canonical` (the legacy `active-skill-*.json` files do not
      * surface a mode field, and the `env` / `none` cases are test
      * overrides). Slice 2026-08-04-rid-005 surfaced this so the

package/dist/services/audit/enforcers/active-skill-resolver.js

@@ -29,7 +29,7 @@ import { join } from 'node:path';
 import { getSessionIdCanonical } from '../../session/session-manager.js';
 import { getSessionDir } from '../../session/getSessionDir.js';
 import { readPresenceLease, listPresenceLeases } from '../../skills/presence-lease-service.js';
-import { getCurrentSessionId } from '../../skills/skill-presence-service.js';
+import { getCurrentSessionId, normalizeSkillPresenceMode } from '../../skills/skill-presence-service.js';
 const ACTIVE_SKILL_PREFIX = 'active-skill-';
 /**
  * Resolve the active peak skill for the current hook invocation.
@@ -99,7 +99,7 @@ export function resolveActiveSkillForCaller(projectRoot, opts) {
                     skill: projection.lease.skill,
                     callerId: lease.callerId,
                     sessionId,
-                    mode: typeof projection.mode === 'string' && projection.mode.length > 0 ? projection.mode : null,
+                    mode: normalizeSkillPresenceMode(typeof projection.mode === 'string' ? projection.mode : null) ?? null,
                     source: 'canonical',
                 };
             }
@@ -127,9 +127,7 @@ export function resolveActiveSkillForCaller(projectRoot, opts) {
                 const raw = readFileSync(filePath, 'utf8');
                 const parsed = JSON.parse(raw);
                 if (typeof parsed.skill === 'string' && parsed.skill.length > 0) {
-                    const legacyMode = typeof parsed.mode === 'string' && parsed.mode.length > 0
-                        ? parsed.mode
-                        : null;
+                    const legacyMode = normalizeSkillPresenceMode(typeof parsed.mode === 'string' ? parsed.mode : null) ?? null;
                     return { skill: parsed.skill, callerId, sessionId, mode: legacyMode, source: 'file' };
                 }
             }

package/dist/services/code/auto-compact-lifecycle.d.ts

@@ -76,7 +76,7 @@ export declare function summarizeLifecycleError(error: unknown): string;
  *
  * This is the integration with the actual post-compact detection path.
  * The claude-code adapter's `postCompactDetectCommand` is
- * `peaks compact auto --json` — i.e. the next probe through this very
+ * `peaks code auto-compact --json` — i.e. the next probe through this very
  * function. So when a probe finds a run still sitting at `compacting`
  * and MEASURES a ratio that has dropped below the auto-fire threshold,
  * that measurement is the proof the compact landed. Only then do we

package/dist/services/code/auto-compact-lifecycle.js

@@ -168,7 +168,7 @@ export function summarizeLifecycleError(error) {
  *
  * This is the integration with the actual post-compact detection path.
  * The claude-code adapter's `postCompactDetectCommand` is
- * `peaks compact auto --json` — i.e. the next probe through this very
+ * `peaks code auto-compact --json` — i.e. the next probe through this very
  * function. So when a probe finds a run still sitting at `compacting`
  * and MEASURES a ratio that has dropped below the auto-fire threshold,
  * that measurement is the proof the compact landed. Only then do we

package/dist/services/code/auto-compact-modes.d.ts

@@ -8,7 +8,7 @@
  *
  * Slice 2026-07-29-context-evaluation-accuracy Part 22: a new
  * `autoFire` tier is added between soft-warn and preCompact. peaks-loop
- * preempts and runs `peaks compact auto --execute` itself when
+ * preempts and runs `peaks code auto-compact` itself when
  * context crosses `autoFire`; the LLM is NOT asked to "decide"
  * (the LLM-judged 0.85–0.95 zone was the source of false-positive
  * "context too low" reports at 60%+ free — the LLM was guessing).

package/dist/services/code/auto-compact-modes.js

@@ -8,7 +8,7 @@
  *
  * Slice 2026-07-29-context-evaluation-accuracy Part 22: a new
  * `autoFire` tier is added between soft-warn and preCompact. peaks-loop
- * preempts and runs `peaks compact auto --execute` itself when
+ * preempts and runs `peaks code auto-compact` itself when
  * context crosses `autoFire`; the LLM is NOT asked to "decide"
  * (the LLM-judged 0.85–0.95 zone was the source of false-positive
  * "context too low" reports at 60%+ free — the LLM was guessing).

package/dist/services/code/auto-compact-orchestrator.js

@@ -1,7 +1,7 @@
 /**
  * Auto-compact orchestrator (v2.13.0 AC-2 + AC-3 + AC-4).
  *
- * Closes the loop between `peaks compact auto` (AC-1) and the IDE's
+ * Closes the loop between `peaks code auto-compact` (AC-1) and the IDE's
  * native compact capability (AC-3). peaks-loop is project-aware: it
  * knows the current plan, open questions, recent decisions, in-flight
  * batches, todo state, git status, and active skills. That context is
@@ -16,7 +16,7 @@
  *   3. If 0.85 ≤ ratio < 0.95 (pre-compact zone): peaks-loop prepares
  *      the convergence toolkit (checkpoint + auto-decisions log +
  *      IDE-dispatch handle) and surfaces it to the LLM. The LLM
- *      DECIDES when to fire `peaks compact auto --execute`;
+ *      DECIDES when to fire `peaks code auto-compact`;
  *      peaks-loop does NOT auto-fire. The toolkit is ready so the
  *      LLM doesn't lose context to a last-second `/compact` panic.
  *   4. If ratio < 0.85: skip — return a one-line info row.
@@ -34,7 +34,7 @@ import { getSessionIdCanonical } from '../session/session-manager.js';
 import { resolveOuterSessionId } from '../session/binding-status-service.js';
 import { AUTO_COMPACT_PRE_COMPACT_RATIO, AUTO_COMPACT_THRESHOLD_RATIO } from '../context/auto-compact-types.js';
 import { describeMode, thresholdFor } from './auto-compact-modes.js';
-import { read24hState } from '../24h-mode/store.js';
+import { resolveAutoCompactProfile } from '../mode/mode-status-service.js';
 import { CompactLifecyclePublisher, newCompactRunId, settleOpenLifecycleRun, summarizeLifecycleError } from './auto-compact-lifecycle.js';
 const PRE_COMPACT_REASON = 'pre-compact-auto';
 /**
@@ -72,7 +72,7 @@ export function evaluateCompactTrigger(ratio, mode = 'standard') {
     }
     if (ratio < preCompact) {
         // Part 22: auto-fire zone (0.80 ≤ ratio < 0.85). peaks-loop
-        // preempts and runs `peaks compact auto --execute` itself
+        // preempts and runs `peaks code auto-compact` itself
         // without LLM involvement. The LLM is not asked to "decide";
         // the toolkit is applied synchronously. Closes the
         // LLM-misjudges-context window that previously let the
@@ -255,20 +255,15 @@ function writePreCompactCheckpoint(input) {
     return path;
 }
 /**
- * Slice 2026-07-28 (rid-027): resolve the auto-compact mode from
- * 24h-mode awareness. Returns `'partial'` when the session is
- * `24H_ACTIVE`, otherwise `'standard'`. The CLI flag `--mode` takes
- * precedence (caller passes `input.mode` directly), so this helper is
- * only consulted when the flag is absent.
+ * Slice 2026-07-28 (rid-027), re-keyed by slice
+ * 2026-09-09-mode-consolidation: resolve the auto-compact mode from
+ * the PRESENCE MODE, not the 24h state machine. Returns `'partial'`
+ * when the mode is `24h`, otherwise `'standard'`. The CLI flag
+ * `--mode` takes precedence (caller passes `input.mode` directly), so
+ * this helper is only consulted when the flag is absent.
  */
-function resolveAutoCompactMode(projectRoot, sessionId) {
-    try {
-        const snap = read24hState(projectRoot, sessionId);
-        return snap.state === '24H_ACTIVE' ? 'partial' : 'standard';
-    }
-    catch {
-        return 'standard';
-    }
+function resolveAutoCompactMode(projectRoot) {
+    return resolveAutoCompactProfile(projectRoot);
 }
 /**
  * Execute the auto-compact flow.
@@ -300,9 +295,10 @@ export async function runAutoCompact(input) {
         };
     }
     // Slice 2026-07-28 (rid-027): resolve mode. CLI flag `--mode` wins;
-    // 24h-mode awareness yields 'partial' when 24h_ACTIVE; default
-    // 'standard' preserves v2.13.0 zero-pause contract.
-    const mode = input.mode ?? resolveAutoCompactMode(input.projectRoot, sessionId);
+    // slice 2026-09-09-mode-consolidation keys the default off the
+    // presence MODE ('24h' → 'partial'); 'standard' preserves the
+    // v2.13.0 zero-pause contract.
+    const mode = input.mode ?? resolveAutoCompactMode(input.projectRoot);
     // Lazy import to avoid the AC-1 module depending on the orchestrator.
     const { readContextPercent } = await import('../context/auto-compact-reader.js');
     const outerSessionId = resolveOuterSessionId(input.projectRoot, sessionId, input.env ?? process.env);
@@ -398,12 +394,12 @@ export async function runAutoCompact(input) {
             ? [
                 'RED-LINE compact dispatched — further sub-agent dispatch BLOCKED until ratio < 0.85',
                 'Post-compact resume picks up the convergence plan from auto-decisions.md',
-                'Next `peaks compact auto` probe will confirm ratio dropped below 0.85'
+                'Next `peaks code auto-compact` probe will confirm ratio dropped below 0.85'
             ]
             : [
                 'Pre-compact dispatched — IDE compact in progress (async)',
                 'Post-compact resume picks up the convergence plan from auto-decisions.md',
-                'Next `peaks compact auto` probe will confirm ratio dropped below 0.85'
+                'Next `peaks code auto-compact` probe will confirm ratio dropped below 0.85'
             ];
         plan = buildConvergencePlan({
             sessionId,