peaks-loop 4.0.32 → 4.0.34

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/cli/commands/shadcn-commands.d.ts

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+/** Pinned upstream version — bump deliberately, never float on `latest`. */
+export declare const SHADCN_PACKAGE = "shadcn@4.21.0";
+export type ShadcnInitState = 'ok' | 'shadcn-missing' | 'execution-failed';
+export type ShadcnInitOptions = {
+    readonly cwd: string;
+    readonly preset: string;
+    readonly template?: string;
+    readonly yes?: boolean;
+    readonly timeoutMs?: number;
+};
+export type ShadcnInitResult = {
+    readonly state: ShadcnInitState;
+    readonly argv: readonly string[];
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exitCode: number | null;
+    readonly durationMs: number;
+};
+/**
+ * Pure argv builder. `--package <pin> --` makes npx resolve the pinned
+ * upstream CLI without installing it into the project.
+ */
+export declare function buildShadcnInitArgs(options: Pick<ShadcnInitOptions, 'preset' | 'template' | 'yes'>): string[];
+/**
+ * Spawn the upstream CLI through the cross-platform npx resolver (on Windows
+ * `npx` is a `.cmd` shim that `spawnSync` refuses to invoke directly).
+ * Fail-soft: a missing network / missing npx returns a state, never throws.
+ */
+export declare function runShadcnInit(options: ShadcnInitOptions): ShadcnInitResult;
+export declare function registerShadcnCommands(program: Command, io: ProgramIO): void;

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

@@ -0,0 +1,120 @@
+/**
+ * `peaks shadcn init` — dynamic wrapper around the upstream `shadcn` CLI.
+ *
+ * Slice B2 of 2026-09-09-ecc-dynamic-and-cleanup: `skills/bee/peaks-rd/SKILL.md`
+ * and `references/frontend-project-generation.md` already tell RD to scaffold
+ * a frontend with `peaks shadcn init --preset [CODE] --template vite`, but the
+ * command did not exist and `shadcn` was not a dependency. Rather than add a
+ * hard dependency, this mirrors `src/services/lint/detect-ocr-18.ts` +
+ * `npx-resolver.ts`: the tool is obtained on demand via
+ * `npx --package shadcn@<pin> -- shadcn ...`, so the skill reference is true
+ * and the dependency stays dynamic.
+ *
+ * Per the "Enhancement, not new AI CLI" tenet this is a thin pass-through:
+ * peaks-loop resolves the upstream binary and forwards the user's intent. It
+ * does not reimplement scaffolding and does not inject its own prompts.
+ */
+import { spawnSync } from 'node:child_process';
+import { resolveNpxInvocation } from '../../services/lint/npx-resolver.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+/** Pinned upstream version — bump deliberately, never float on `latest`. */
+export const SHADCN_PACKAGE = 'shadcn@4.21.0';
+/**
+ * Pure argv builder. `--package <pin> --` makes npx resolve the pinned
+ * upstream CLI without installing it into the project.
+ */
+export function buildShadcnInitArgs(options) {
+    const args = ['--package', SHADCN_PACKAGE, '--', 'shadcn', 'init', '--preset', options.preset];
+    if (options.template !== undefined && options.template.length > 0) {
+        args.push('--template', options.template);
+    }
+    if (options.yes === true) {
+        args.push('--yes');
+    }
+    return args;
+}
+/**
+ * Spawn the upstream CLI through the cross-platform npx resolver (on Windows
+ * `npx` is a `.cmd` shim that `spawnSync` refuses to invoke directly).
+ * Fail-soft: a missing network / missing npx returns a state, never throws.
+ */
+export function runShadcnInit(options) {
+    const start = Date.now();
+    const args = buildShadcnInitArgs(options);
+    const invocation = resolveNpxInvocation(args);
+    const result = spawnSync(invocation.command, [...invocation.args], {
+        cwd: options.cwd,
+        encoding: 'utf8',
+        timeout: options.timeoutMs ?? 300_000,
+        maxBuffer: 32 * 1024 * 1024,
+        env: invocation.baseEnv
+    });
+    const stdout = typeof result.stdout === 'string' ? result.stdout : '';
+    const stderr = typeof result.stderr === 'string' ? result.stderr : '';
+    if (result.error !== undefined && result.error !== null) {
+        return {
+            state: 'shadcn-missing',
+            argv: args,
+            stdout,
+            stderr: stderr.length > 0 ? stderr : getErrorMessage(result.error),
+            exitCode: null,
+            durationMs: Date.now() - start
+        };
+    }
+    if (result.status !== 0) {
+        return {
+            state: 'execution-failed',
+            argv: args,
+            stdout,
+            stderr,
+            exitCode: result.status,
+            durationMs: Date.now() - start
+        };
+    }
+    return {
+        state: 'ok',
+        argv: args,
+        stdout,
+        stderr,
+        exitCode: 0,
+        durationMs: Date.now() - start
+    };
+}
+export function registerShadcnCommands(program, io) {
+    const shadcn = program
+        .command('shadcn')
+        .description('Dynamic wrapper for the upstream shadcn CLI (obtained via `npx --package`; no hard dependency).');
+    addJsonOption(shadcn
+        .command('init')
+        .description('Scaffold/init a shadcn/ui project by forwarding to upstream `shadcn init`.')
+        .requiredOption('--preset <code>', 'shadcn registry preset code (resolve it before scaffolding when unknown)')
+        .option('--template <name>', 'project template, e.g. vite or next')
+        .option('--project <path>', 'target project root', '.')
+        .option('--yes', 'forward --yes to upstream (skip its confirmation prompts)', false)).action((options) => {
+        const asJson = options.json === true;
+        const result = runShadcnInit({
+            cwd: options.project,
+            preset: options.preset,
+            ...(options.template !== undefined && options.template.length > 0 ? { template: options.template } : {}),
+            ...(options.yes === true ? { yes: true } : {})
+        });
+        if (result.state === 'ok') {
+            printResult(io, ok('shadcn.init', result, [], [
+                `Upstream argv: npx ${result.argv.join(' ')}`,
+                'Generated projects must be TypeScript-only (no JavaScript source or config files).'
+            ]), asJson);
+            return;
+        }
+        const code = result.state === 'shadcn-missing' ? 'SHADCN_UNAVAILABLE' : 'SHADCN_INIT_FAILED';
+        const message = result.state === 'shadcn-missing'
+            ? `could not resolve ${SHADCN_PACKAGE} via npx`
+            : `upstream shadcn init exited with code ${result.exitCode}`;
+        printResult(io, fail('shadcn.init', code, message, result, [
+            `Pinned package: ${SHADCN_PACKAGE}`,
+            'Ensure Node.js >= 20 with npm is on PATH and the network allows the npm registry.',
+            `Retry with: npx --package ${SHADCN_PACKAGE} -- shadcn init --preset <code>`
+        ]), asJson);
+        process.exitCode = 1;
+    });
+}

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

@@ -134,7 +134,7 @@ export function registerSliceCommands(program, io) {
     addJsonOption(slice
         .command('decompose <rid>')
         .description('Run the 6-stage slice-decomposition algorithm on a PRD. ' +
-        'Inputs: PRD body + peaks codegraph + .understand-anything/knowledge-graph.json (optional). ' +
+        'Inputs: PRD body + peaks codegraph (project analysis is codegraph-first; structural import edges are the fallback). ' +
         'Outputs: .peaks/sc/slice-decomposition/<rid>.json with critical-path, ' +
         'parallel-batches, and per-slice work estimates. ' +
         'Algorithm is fzf-free. Replay vs hand-derived 2.1.0 dry-run: +-10% on p50. ' +
@@ -202,9 +202,6 @@ export function registerSliceCommands(program, io) {
                 `Next: peaks slice pick ${rid}  (requires fzf >= 0.38)`,
                 `Or manually craft -picked.json from the JSON output, then peaks slice plan ${rid}`
             ];
-            if (result.understandAnything.fallback === 'structural-only') {
-                nextActions.push('Note: understand-anything not indexed; cuts are structural-only. Run /understand in your IDE to improve semantic-cut quality.');
-            }
             if (result.pickHint) {
                 nextActions.push(result.pickHint);
             }

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/audit/static-service.d.ts

@@ -5,7 +5,7 @@
  * integration entirely. The pre-Slice-3 implementation probed
  * `npx ecc-agentshield --version` and shelled out to
  * `npx ecc-agentshield scan --json --target <path>` on every audit
- * call, but the upstream `affaan-m/everything-claude-code` v2.0.0
+ * call, but the upstream `affaan-m/everything-claude-code` (now `affaan-m/ECC`) v2.0.0
  * release ships no `ecc-agentshield` binary — the repo is
  * `agents/*.md` flat files plus SKILL.md descriptors.
  *

package/dist/services/audit/static-service.js

@@ -5,7 +5,7 @@
  * integration entirely. The pre-Slice-3 implementation probed
  * `npx ecc-agentshield --version` and shelled out to
  * `npx ecc-agentshield scan --json --target <path>` on every audit
- * call, but the upstream `affaan-m/everything-claude-code` v2.0.0
+ * call, but the upstream `affaan-m/everything-claude-code` (now `affaan-m/ECC`) v2.0.0
  * release ships no `ecc-agentshield` binary — the repo is
  * `agents/*.md` flat files plus SKILL.md descriptors.
  *

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,

package/dist/services/code/mode-gate.d.ts

@@ -5,7 +5,7 @@
  * pause for an AskUserQuestion round-trip?" The D5 design (per
  * `.peaks/memory/2026-06-26-v2-11-full-auto-self-decision.md`) requires:
  *
- *   - `full-auto` and `swarm` modes → auto-proceed (recommended = chosen)
+ *   - `full-auto` and `24h` modes → auto-proceed (recommended = chosen)
  *   - `assisted` and `strict` modes → pause for confirmation
  *   - 3 hard-floor categories ALWAYS ask, regardless of mode:
  *     1. Irreversible external side effects (git push, npm publish, …)
@@ -77,7 +77,11 @@ export declare function isHardFloorCategory(value: string): value is HardFloorCa
 /**
  * `true` when the current mode should auto-proceed (skip the
  * AskUserQuestion round-trip). Mirrors D5.a: "recommended = chosen
- * in full-auto / swarm; always log, never silently skip".
+ * in full-auto / 24h; always log, never silently skip".
+ *
+ * Slice 2026-09-09-mode-consolidation: `swarm` was removed as a mode
+ * (parallel fan-out is now the default execution strategy in every
+ * mode); `24h` replaces it as the second auto-proceed peer.
  */
 export declare function shouldAutoProceed(mode: CodeMode): boolean;
 /**

package/dist/services/code/mode-gate.js

@@ -5,7 +5,7 @@
  * pause for an AskUserQuestion round-trip?" The D5 design (per
  * `.peaks/memory/2026-06-26-v2-11-full-auto-self-decision.md`) requires:
  *
- *   - `full-auto` and `swarm` modes → auto-proceed (recommended = chosen)
+ *   - `full-auto` and `24h` modes → auto-proceed (recommended = chosen)
  *   - `assisted` and `strict` modes → pause for confirmation
  *   - 3 hard-floor categories ALWAYS ask, regardless of mode:
  *     1. Irreversible external side effects (git push, npm publish, …)
@@ -22,8 +22,8 @@
 export const CODE_MODES = [
     'full-auto',
     'assisted',
-    'swarm',
-    'strict'
+    'strict',
+    '24h'
 ];
 export const HARD_FLOOR_CATEGORIES = [
     'irreversible-external-side-effect',
@@ -56,10 +56,14 @@ export function isHardFloorCategory(value) {
 /**
  * `true` when the current mode should auto-proceed (skip the
  * AskUserQuestion round-trip). Mirrors D5.a: "recommended = chosen
- * in full-auto / swarm; always log, never silently skip".
+ * in full-auto / 24h; always log, never silently skip".
+ *
+ * Slice 2026-09-09-mode-consolidation: `swarm` was removed as a mode
+ * (parallel fan-out is now the default execution strategy in every
+ * mode); `24h` replaces it as the second auto-proceed peer.
  */
 export function shouldAutoProceed(mode) {
-    return mode === 'full-auto' || mode === 'swarm';
+    return mode === 'full-auto' || mode === '24h';
 }
 export const COMMIT_BOUNDARY_ACTIONS = [
     'git-push',