peaks-loop 4.0.33 → 4.0.34

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/skills/presence-lease-service.d.ts

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

package/dist/services/skills/presence-lease-service.js

@@ -175,6 +175,32 @@ export function setPresenceLease(input) {
         gc,
     };
 }
+/**
+ * Slice 2026-09-09-mode-consolidation (Slice B): stamp `mode` onto every
+ * in-flight lease of the bound session, in place.
+ *
+ * Used by the 24h auto-engage path (T3/T4, `peaks code run --24h`,
+ * `peaks session 24h-mode transition --state 24H_ACTIVE`) to record the
+ * autonomy level without re-creating the lease (a fresh `setPresenceLease`
+ * would reset `startedAt` / `status`). `lastHeartbeat` is intentionally
+ * NOT touched — stamping a mode is not a liveness signal.
+ *
+ * Returns the number of leases updated; 0 when there is nothing in flight.
+ * Callers are responsible for the "only `24h` may be auto-set" guard.
+ */
+export function stampPresenceLeaseMode(input) {
+    const sessionId = validateSessionId(input.sessionId);
+    const leasePaths = [];
+    for (const lease of listPresenceLeases(input.projectRoot, sessionId)) {
+        if (lease.status !== 'preparing' && lease.status !== 'running')
+            continue;
+        const path = leaseFilePath(input.projectRoot, sessionId, lease.callerId, lease.workflowId);
+        const next = { ...lease, mode: input.mode };
+        writeAtomic(path, JSON.stringify(next, null, 2));
+        leasePaths.push(path);
+    }
+    return { updated: leasePaths.length, leasePaths };
+}
 export function readPresenceLease(input) {
     const sessionId = validateSessionId(input.sessionId ?? null);
     const callerId = validateCallerId(input.callerId);

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

@@ -1,6 +1,15 @@
-export type SkillPresenceMode = 'full-auto' | 'assisted' | 'swarm' | 'strict';
+export type SkillPresenceMode = 'full-auto' | 'assisted' | 'strict' | '24h';
 export declare const VALID_SKILL_PRESENCE_MODES: ReadonlyArray<SkillPresenceMode>;
+export declare const LEGACY_SKILL_PRESENCE_MODE_ALIASES: Readonly<Record<string, SkillPresenceMode>>;
 export declare function isSkillPresenceMode(value: string): value is SkillPresenceMode;
+/**
+ * Normalize a raw on-disk / CLI mode token to a current
+ * `SkillPresenceMode`. Current values pass through; the legacy
+ * `'swarm'` alias maps to `'full-auto'`; anything else returns
+ * `undefined` so the caller can decide (drop the field, not the
+ * presence). Never throws.
+ */
+export declare function normalizeSkillPresenceMode(value: string | undefined | null): SkillPresenceMode | undefined;
 export type SkillPresence = {
     skill: string;
     mode?: SkillPresenceMode;

package/dist/services/skills/skill-presence-service.js

@@ -20,12 +20,33 @@ void null;
 export const VALID_SKILL_PRESENCE_MODES = [
     'full-auto',
     'assisted',
-    'swarm',
-    'strict'
+    'strict',
+    '24h'
 ];
+// Migration note (slice 2026-09-09-mode-consolidation): `swarm` was REMOVED
+// as a mode — parallel fan-out is now the default execution strategy in
+// every mode. A legacy on-disk `mode: 'swarm'` is normalized on read to
+// `'full-auto'` (never crash, never drop the presence).
+export const LEGACY_SKILL_PRESENCE_MODE_ALIASES = {
+    swarm: 'full-auto'
+};
 export function isSkillPresenceMode(value) {
     return VALID_SKILL_PRESENCE_MODES.includes(value);
 }
+/**
+ * Normalize a raw on-disk / CLI mode token to a current
+ * `SkillPresenceMode`. Current values pass through; the legacy
+ * `'swarm'` alias maps to `'full-auto'`; anything else returns
+ * `undefined` so the caller can decide (drop the field, not the
+ * presence). Never throws.
+ */
+export function normalizeSkillPresenceMode(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        return undefined;
+    if (isSkillPresenceMode(value))
+        return value;
+    return LEGACY_SKILL_PRESENCE_MODE_ALIASES[value];
+}
 /**
  * The current outer session id, exposed to Bash tool calls via the
  * `PEAKS_OUTER_SESSION_ID` environment variable. Stamping it onto the
@@ -118,8 +139,15 @@ function readSkillPresenceFromLease(projectRootOverride) {
     // The lease carries `callerId` (the adapter / harness session id),
     // not the legacy `outerSessionId` field. Project it for back-compat
     // with `clearStalePresenceOnRotation`'s outer-mismatch check.
+    //
+    // Slice 2026-09-09-mode-consolidation: `mode` is projected too (it was
+    // silently dropped before, which made `getSkillPresence().mode` always
+    // undefined and left every `presence.mode` consumer dead). Normalize on
+    // read so a legacy `'swarm'` lease surfaces as `'full-auto'`.
+    const leaseMode = normalizeSkillPresenceMode(lease.mode);
     return {
         skill: lease.skill,
+        ...(leaseMode !== undefined ? { mode: leaseMode } : {}),
         sessionId,
         outerSessionId: lease.callerId,
         setAt: lease.startedAt,
@@ -208,7 +236,7 @@ function getPreviousOuterSessionId(projectRootOverride) {
  * `peakSessionId`, OR via `ensureSession` for the first-time case).
  */
 export function setSkillPresenceForCaller(projectRootOverride, callerId, peakSessionId, skill, mode, gate) {
-    const validatedMode = mode && isSkillPresenceMode(mode) ? mode : undefined;
+    const validatedMode = normalizeSkillPresenceMode(mode);
     const now = new Date().toISOString();
     const presence = {
         skill,
@@ -257,7 +285,7 @@ export function setSkillPresence(skill, mode, gate, projectRootOverride) {
     //      the old shape don't break) but we surface a warning to the
     //      CLI boundary via the `outerSessionMismatch` field.
     //   3. delegates the canonical write to `setPresenceLease`.
-    const validatedMode = mode && isSkillPresenceMode(mode) ? mode : undefined;
+    const validatedMode = normalizeSkillPresenceMode(mode);
     const sessionId = getCurrentSessionId(projectRootOverride);
     const outerSessionId = getCurrentOuterSessionId();
     const previousOuterSessionId = getPreviousOuterSessionId(projectRootOverride);

package/dist/services/skills/skill-statusline-service.js

@@ -30,6 +30,7 @@ import { readActiveDispatchIndex } from '../dispatch/dispatch-record-writer.js';
  * picks the most recent in-flight lease across all callers; this is the
  * documented back-compat path.
  */
+import { normalizeSkillPresenceMode } from './skill-presence-service.js';
 const STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
 /**
  * Slice rid-statusline-24h-overlay (2026-08-10): name-distinct from
@@ -245,12 +246,14 @@ function readPresenceReadOnly(projectRoot, callerId) {
     }
     // Leases on disk may carry an optional `mode` field (the lease constructor
     // spreads `input.mode` when present); the typed `SkillPresenceLease` does
-    // not declare it, so widen the read shape here.
-    const latestMode = latest.mode;
+    // not declare it, so widen the read shape here. Normalized on read: a
+    // legacy `'swarm'` lease renders as `'full-auto'` (slice
+    // 2026-09-09-mode-consolidation).
+    const latestMode = normalizeSkillPresenceMode(latest.mode);
     return {
         presence: {
             skill: latest.skill,
-            ...(typeof latestMode === 'string' && latestMode.length > 0 ? { mode: latestMode } : {}),
+            ...(latestMode !== undefined ? { mode: latestMode } : {}),
             setAt: latest.startedAt,
         },
         invalid: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.33",
+  "version": "4.0.34",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "keywords": [
@@ -101,10 +101,10 @@
     "fzf": "^0.5.2",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "peaks-loop-internal-runtime": "0.0.18",
-    "peaks-loop-shared": "0.0.67",
-    "peaks-loop-mut": "0.1.31",
-    "peaks-loop-shared-channel": "0.0.35"
+    "peaks-loop-internal-runtime": "0.0.19",
+    "peaks-loop-shared": "0.0.68",
+    "peaks-loop-shared-channel": "0.0.36",
+    "peaks-loop-mut": "0.1.32"
   },
   "devDependencies": {
     "@changesets/cli": "2.31.1",

package/skills/peaks-code/SKILL.md

@@ -104,7 +104,7 @@ peaks sub-agent dispatch rd --prompt '<your task>' --graph-node <nid> --workflow
 **Integration surfaces:** `peaks code run --24h` / `peaks dashboard long-run --since 24h` / `peaks session 24h-mode state|transition|attempts|reset`.
 
 **Red lines (peaks-code side):**
-- No auto-compact prose ban: never write "ask the user to compact" / "prompt the user to run `/compact`" / "the user should run `peaks compact auto` manually" / "the user is responsible for context management" / legacy 50/75/90 percent tiers. **0.85 / 0.95 contract is mandatory.**
+- No auto-compact prose ban: never write "ask the user to compact" / "prompt the user to run `/compact`" / "the user should run `peaks code auto-compact` manually" / "the user is responsible for context management" / legacy 50/75/90 percent tiers. **0.85 / 0.95 contract is mandatory.**
 - SquabbyZ sole-author rule: no `Co-Authored-By: Claude/Anthropic` trailer.
 - 24h mode is a flag on `peaks-code`; MUST NOT introduce a sibling `peaks-24h` skill or competing top-level verb.
 
@@ -151,7 +151,7 @@ Before the first planning action, run `peaks fresh-context preflight --prompt "<
 1. **PreToolUse hook — `peaks code gate-step-08`.** Installed by `peaks workspace init` on the `Bash` matcher; checks `job-shape.json` presence + fail-closed backup regex. If `job-shape.json` AND `progress.json` exist, surfaces `Next: slice #N of M (<currentSlice>)` so the LLM cannot wake up cold.
 2. **Size-fear ban — `peaks code emit-handoff`.** Refuses to emit a final handoff while `remaining > 0` under Job mode. Pass `--force-under-job` only with explicit user approval.
 3. **On-disk slice progress — `peaks job progress`.** `peaks job checkpoint --state done` writes `progress.json`. `peaks job progress --job-id <jid> [--allow-missing]` is the canonical reader.
-4. **Forced auto-compact — `--enforce-job-mode`.** `peaks code context-now --enforce-job-mode` returns `action: 'auto-compact-now'` at ≥ 0.85. **Job mode at ≥ 0.85 is MANDATORY auto-compact** — Code MUST call `peaks compact auto --execute` without confirmation.
+4. **Forced auto-compact — `--enforce-job-mode`.** `peaks code context-now --enforce-job-mode` returns `action: 'auto-compact-now'` at ≥ 0.85. **Job mode at ≥ 0.85 is MANDATORY auto-compact** — Code MUST call `peaks code auto-compact` without confirmation.
 
 **Step 0.7 resume rule (read-FIRST):** on resume, `peaks code gate-step-08` reads `progress.json` first and surfaces `Next: slice #N of M (<currentSlice>)` so the orchestrator picks up at the right slice without re-reading the artifact tree.
 
@@ -161,26 +161,26 @@ Before the first planning action, run `peaks fresh-context preflight --prompt "<
 
 ### Peaks-Loop Step N+2: Auto-compact at the warning line (v2.13.0 zero-pause contract)
 
-> **Zero-pause contract.** When context usage crosses the pre-compact threshold, peaks-loop **automatically fires `peaks compact auto --execute` — the LLM does NOT prompt the user to run `/compact` manually**. Stale prose that says "ask the user to compact" silently stalls the workflow. The v2.13.0 contract makes auto-compact a system responsibility, not a user action.
+> **Zero-pause contract.** When context usage crosses the pre-compact threshold, peaks-loop **automatically fires `peaks code auto-compact` — the LLM does NOT prompt the user to run `/compact` manually**. Stale prose that says "ask the user to compact" silently stalls the workflow. The v2.13.0 contract makes auto-compact a system responsibility, not a user action.
 
 **Thresholds (v2.13.0, replacing legacy 50/75/90):**
 
 | ratio zone | zone name | action |
 |---|---|---|
 | `< 0.85` | normal | skip — LLM keeps working |
-| `0.85 ≤ ratio < 0.95` | **pre-compact zone** | `peaks compact auto --execute` fires **automatically** (deferred only when in-flight sub-agent batch is running; fires the moment the batch lands). The LLM does not prompt the user. |
-| `ratio ≥ 0.95` | **red-line (Karpathy §4)** | synchronous gate — `peaks compact auto --execute` invoked immediately; `peaks code context-now` returns `action: 'red-line'` and refuses to advance until ratio drops below 0.85. **Karpathy §4 automatic exception** — LLM cannot opt out. |
+| `0.85 ≤ ratio < 0.95` | **pre-compact zone** | `peaks code auto-compact` fires **automatically** (deferred only when in-flight sub-agent batch is running; fires the moment the batch lands). The LLM does not prompt the user. |
+| `ratio ≥ 0.95` | **red-line (Karpathy §4)** | synchronous gate — `peaks code auto-compact` invoked immediately; `peaks code context-now` returns `action: 'red-line'` and refuses to advance until ratio drops below 0.85. **Karpathy §4 automatic exception** — LLM cannot opt out. |
 
-**Probe primitive (single source of truth):** `peaks code context-now --json`. Do NOT use `peaks context check --prompt-size` (deprecated, will silently under-report ratio). Returns `{ ratio, action: 'ok' | 'soft-warn' | 'auto-compact-now' | 'red-line' }` — Code reads `action` and dispatches `peaks compact auto --execute` on `auto-compact-now` or `red-line` without user confirmation.
+**Probe primitive (single source of truth):** `peaks code context-now --json`. Do NOT use `peaks context check --prompt-size` (deprecated, will silently under-report ratio). Returns `{ ratio, action: 'ok' | 'soft-warn' | 'auto-compact-now' | 'red-line' }` — Code reads `action` and dispatches `peaks code auto-compact` on `auto-compact-now` or `red-line` without user confirmation.
 
 **Enforcement layers (defense in depth):**
 1. `src/services/code/auto-compact-orchestrator.ts` — `evaluateAutoCompactDecision` default-returns `shouldCompact: true` for both `pre-compact` and `red-line`. Only deferral is `inFlightBatch.hasInFlightBatch` (D6.e); no LLM/human approval branch.
 2. `--enforce-job-mode` (v3.1.2) — Job mode elevates ≥0.85 to MANDATORY regardless of in-flight batch.
 3. `peaks code gate-step-08` (PreToolUse hook) — surfaces `auto-compact-now` on every Bash call when ratio is in the zone, so the LLM cannot wake up cold and forget.
-4. Karpathy §4 exception: `peaks compact auto --execute` is fired *by the orchestrator*, not by the user. If you find yourself about to write "ask the user to compact" / "prompt the user to run `/compact`", STOP — that is the regression.
+4. Karpathy §4 exception: `peaks code auto-compact` is fired *by the orchestrator*, not by the user. If you find yourself about to write "ask the user to compact" / "prompt the user to run `/compact`", STOP — that is the regression.
 
 **Anti-pattern (DO NOT introduce):** any of these strings in skills/* or comments signals the zero-pause contract has been broken:
-- "ask the user to compact" / "prompt the user to run `/compact`" / "the user should run `peaks compact auto` manually" / "the user is responsible for context management" / legacy mid/seventy-five/ninety percent tiers (current is 0.85 / 0.95).
+- "ask the user to compact" / "prompt the user to run `/compact`" / "the user should run `peaks code auto-compact` manually" / "the user is responsible for context management" / legacy mid/seventy-five/ninety percent tiers (current is 0.85 / 0.95).
 
 If the prose audit (`peaks audit red-lines`) flags any of the above, the slice is **blocked** until the prose is rewritten.
 
@@ -270,7 +270,7 @@ After `peaks-rd` finishes, Code MUST auto-route to `peaks-qa` without waiting fo
 
 ## Default runbook
 
-The end-to-end CLI sequence for `full-auto` lives in `references/runbook.md`. `assisted`/`strict` pause at `[CONFIRM]`; `full-auto`/`swarm` auto-proceed.
+The end-to-end CLI sequence for `full-auto` lives in `references/runbook.md`. `assisted`/`strict` pause at `[CONFIRM]`; `full-auto`/`24h` auto-proceed. At a `[CONFIRM]` gate the CLI never prompts: the transition throws `CONFIRMATION_REQUIRED`, so Code asks the user via `AskUserQuestion` and, on approval, re-runs the same command with `--confirm`. Never expect or ask for a terminal `y/N` prompt.
 
 When adding new CLI commands, mirror into `references/runbook.md` and `tests/unit/skill-default-runbook.test.ts` (test falls back to the reference).
 

package/skills/peaks-code/references/mode-selection.md

@@ -3,8 +3,8 @@
 > Body of `### Peaks-Loop Step 1`. After Step 0 has anchored the workspace and presence, when the user invokes Peaks-Loop Code without explicitly naming an execution profile, use `AskUserQuestion` to pick the profile. Present the recommended full-auto path as the first/default option with a practical description for each:
 
 1. **Full auto (Recommended)** — Peaks-Loop handles planning, role coordination, validation, and compact handoff end-to-end while preserving required confirmation gates for risky or shared-state actions.
-2. **Assisted** — Peaks-Loop proposes plans, artifacts, and checks, then pauses for user decisions at major workflow boundaries.
-3. **Swarm** — Peaks-Loop maximizes safe parallel role/worker execution for larger RD or QA workloads while keeping reducer validation and artifact boundaries explicit.
+2. **24h** — Long-run autonomy profile: auto-proceed gates, periodic checkpoints, and the partial auto-compact cadence for overnight / multi-hour runs. It may be auto-engaged by the T1–T5 triggers without a pick.
+3. **Assisted** — Peaks-Loop proposes plans, artifacts, and checks, then pauses for user decisions at major workflow boundaries.
 4. **Strict** — Peaks-Loop uses the most conservative gates: explicit confirmations, strict slice specs, coverage evidence, QA acceptance, and commit boundaries before continuing.
 
 Map the user's selection to the `--mode` flag value (used by `peaks skill presence:set`; `presence:set --mode` accepts any string, so the name matches the user-facing label rather than overloading "code" which is also the skill name):
@@ -12,10 +12,14 @@ Map the user's selection to the `--mode` flag value (used by `peaks skill presen
 | User selects | `--mode` value |
 |---|---|
 | Full auto | `full-auto` |
+| 24h | `24h` |
 | Assisted | `assisted` |
-| Swarm | `swarm` |
 | Strict | `strict` |
 
+> Note: in `assisted` / `strict`, a workflow-boundary confirmation is resolved by asking the user via `AskUserQuestion` and, on approval, re-running the same CLI command with `--confirm`. The CLI never opens a terminal prompt (no stdin read, no `y/N`) — an LLM-driven session has no TTY.
+
+> Note: parallel role/worker fan-out is the default execution strategy in **every** mode — it is not a mode of its own. The old `swarm` profile was removed; a legacy on-disk `mode: 'swarm'` is read as `full-auto`.
+
 > Note: `peaks workflow route --mode code|team` is a **different** CLI dimension (code developer vs team flow) and is unrelated to the profile choice here. Do not conflate them.
 
 If the user already names a profile in their invocation (e.g. `/peaks-code --full-auto`, "用全自动模式"), skip this question and use the named profile directly.

package/skills/peaks-code/references/periodic-checkpoint.md

@@ -72,10 +72,10 @@ This step is strictly IDE-agnostic. The LLM calls the peaks CLI; no IDE-specific
 
 ## Companion surface — auto-compact (zero-pause)
 
-When the runner crosses the v2.13.0 auto-compact thresholds (0.85 pre-compact / 0.95 red-line), `peaks session checkpoint` is NOT enough on its own — the LLM must also fire `peaks compact auto --execute` (or wait for the in-band PreToolUse hook at ratio ≥ 0.95 to compact the runner itself). See:
+When the runner crosses the v2.13.0 auto-compact thresholds (0.85 pre-compact / 0.95 red-line), `peaks session checkpoint` is NOT enough on its own — the LLM must also fire `peaks code auto-compact` (or wait for the in-band PreToolUse hook at ratio ≥ 0.95 to compact the runner itself). See:
 
-- `peaks compact auto --execute` — orchestrator that writes the convergence plan + dispatches the compact pathway
-- `peaks compact auto` — the PreToolUse hook entrypoint fired by `.claude/settings.local.json` (slice 2026-07-02-auto-compact-zero-pause)
+- `peaks code auto-compact` — orchestrator that writes the convergence plan + dispatches the compact pathway
+- `peaks code auto-compact` — the PreToolUse hook entrypoint fired by `.claude/settings.local.json` (slice 2026-07-02-auto-compact-zero-pause)
 - `.peaks/memory/2026-06-27-auto-compact-design.md` — zero-human-intervention design rationale
 
-The two surfaces compose: `peaks session checkpoint` persists the context state, `peaks compact auto` collapses the runner's window. The LLM fires both in the 0.85–0.95 zone; the hook fires alone at ≥ 0.95.
+The two surfaces compose: `peaks session checkpoint` persists the context state, `peaks code auto-compact` collapses the runner's window. The LLM fires both in the 0.85–0.95 zone; the hook fires alone at ≥ 0.95.