peaks-loop 4.0.33 → 4.0.35

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.35",
   "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.20",
+    "peaks-loop-mut": "0.1.33",
+    "peaks-loop-shared": "0.0.69",
+    "peaks-loop-shared-channel": "0.0.37"
   },
   "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).
 
@@ -296,7 +296,7 @@ After final validation, refresh project-local standards via `peaks standards ini
 
 ## Peaks-Loop Step 11: Memory sediment (BLOCKING on workflow complete)
 
-> **Hard rule.** Code MUST NOT declare a workflow complete until Step 11 has produced ≥ 1 file in `.peaks/memory/` OR the user has explicitly approved a no-sediment outcome via AskUserQuestion. Canonical CLI: `peaks memory extract --project <repo> --artifact .peaks/_runtime/<sessionId>/txt/handoff.md --apply --json` (the artifact-scoped extract; the batch-scoped sibling `peaks project memories:extract` is for non-handoff flows only). Substeps 11a/11b/11c/11d (Gate A/B/C), D-010 fix root cause check → `references/step-11-memory-sediment.md` + `references/runbook.md` §Step 11.
+> **Hard rule.** Code MUST NOT declare a workflow complete until Step 11 has produced ≥ 1 file in `.peaks/memory/` OR the user has explicitly approved a no-sediment outcome via AskUserQuestion. Canonical CLI: `peaks memory extract --project <repo> --artifact .peaks/_runtime/<sessionId>/txt/handoff.md --apply --json` (the artifact-scoped extract; the batch-scoped sibling `peaks project memories:extract` is for non-handoff flows only). **Single authority:** inside a peaks-code workflow, sedimenting memory writes to `.peaks/memory/`; the IDE-side memory dir (`~/.claude/projects/<hash>/memory/`) is a session note, not the authority and is read-only for peaks — pull any session note in with `peaks memory ingest --apply`, and keep the index in sync with `peaks memory reindex --apply`. Substeps 11a/11b/11c/11d (Gate A/B/C), 11e (index hygiene), 11f (IDE-side ingest), D-010 fix root cause check → `references/step-11-memory-sediment.md` + `references/runbook.md` §Step 11.
 
 ## Peaks-Loop External references and lifecycle
 

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.

package/skills/peaks-code/references/runbook.md

@@ -10,7 +10,9 @@
 
 ## Default runbook — CLI sequence
 
-The end-to-end CLI sequence for the `full-auto` profile. `assisted` and `strict` profiles pause at `[CONFIRM]` markers below. `full-auto` and `swarm` auto-proceed through all gates. See Transition Gates for artifact verification at each stage.
+The end-to-end CLI sequence for the `full-auto` profile. `assisted` and `strict` profiles pause at `[CONFIRM]` markers below. `full-auto` and `24h` auto-proceed through all gates. See Transition Gates for artifact verification at each stage.
+
+> **How to resolve a `[CONFIRM]` marker (never a terminal prompt):** the CLI does not read stdin. Without `--confirm` / `--force-confirm` the transition fails with `CONFIRMATION_REQUIRED` and `nextActions`. Code must ask the user via `AskUserQuestion` whether to proceed; if the user approves, re-run the *same* command with `--confirm`. Never wait for a `y/N` prompt — no TTY exists in an LLM-driven session.
 
 Canonical single-shot sub-agent dispatch (the `--prompt` flag is required):
 
@@ -34,11 +36,11 @@ peaks scan existing-system --project <repo> --json
 # → copy tokens, sources, conventions, inconsistencies into .peaks/_runtime/<session-id>/system/existing-system.md (Peaks-Loop Gate A.5)
 
 # 1. Peaks-Loop Standards preflight + apply
-#    Run dry-run first to inspect deltas, then APPLY. In full-auto and swarm modes,
+#    Run dry-run first to inspect deltas, then APPLY. In full-auto and 24h modes,
 #    --apply is the default — Standards files (CLAUDE.md, .claude/rules/**) live INSIDE
 #    the target project and are required for downstream skill preflight, so producing
 #    them is part of completing the workflow. Assisted/Strict modes pause for [CONFIRM]
-#    between dry-run and apply.
+#    between dry-run and apply (AskUserQuestion → re-run with --confirm; no terminal prompt).
 peaks standards init   --project <repo> --dry-run --json
 # or: peaks standards update --project <repo> --dry-run --json
 peaks standards init   --project <repo> --apply --json
@@ -57,7 +59,8 @@ peaks standards init   --project <repo> --apply --json
 # 若 LLM 看到 peaks-code runbook 里出现老命令(>9 之外的 raw 名字),
 # 先 `peaks --help` 校验当前 surface,再决定改 runbook 还是改命令。
 
-# 2. Peaks-Loop PRD (Assisted/Strict: [CONFIRM] before confirmed-by-user)
+# 2. Peaks-Loop PRD (Assisted/Strict: [CONFIRM] before confirmed-by-user
+#    → AskUserQuestion; on approval re-run the transition with --confirm)
 # Classify the request type from the PRD: feature | bugfix | refactor | docs | config | chore
 # This drives RD/QA gate strictness — see "Mandatory RD QA repair loop" for the matrix.
 peaks request init --role prd --id <rid> --project <repo> --apply --type <type> --json
@@ -139,6 +142,7 @@ ls .peaks/_runtime/<sid>/qa/test-cases/<rid>.md                # QA test-cases (
 ls .peaks/_runtime/<sid>/ui/design-draft.md 2>&1               # non-blocking (Gate B info)
 # Apply the degradation rules in the main SKILL.md if any artefact is missing.
 # → Peaks-Loop Gate B convergence check. Assisted/Strict: [CONFIRM]
+#   → AskUserQuestion; on approval re-run the transition with --confirm
 
 # 4. Peaks-Loop RD planning artifact (the file required by the prerequisite gate)
 #    feature / refactor → write .peaks/_runtime/<id>/rd/tech-doc.md
@@ -163,6 +167,7 @@ peaks request transition <rid> --role qa --state running --project <repo> --json
 #                                 + .peaks/_runtime/<id>/qa/performance-findings.md (feature/refactor only)
 peaks request transition <rid> --role qa --state verdict-issued --project <repo> --json
 # → Peaks-Loop Gate D check. Assisted/Strict: [CONFIRM]
+#   → AskUserQuestion; on approval re-run the transition with --confirm
 
 # 7. Peaks-Loop RD↔QA repair loop — if verdict is return-to-rd, re-run 4 through 6 until QA passes or blocked TXT.
 #    Before invoking peaks-rd again, check the cycle count so you don't blow past the cap silently:
@@ -210,6 +215,12 @@ peaks memory extract --project <repo> --artifact .peaks/_runtime/<id>/txt/handof
 #      --apply is REQUIRED to write .peaks/memory/; without it the command only
 #      previews. The extract regenerates index.json in the same call.
 
+# 10d. Index hygiene (single authority: .peaks/memory/ is peaks-owned):
+peaks memory reindex --project <repo> --json          # drift report (unclassified / orphans both ways)
+peaks memory reindex --project <repo> --apply --json  # rebuild index.json + regenerate MEMORY.md
+peaks memory ingest  --project <repo> --json          # preview IDE-side session notes
+peaks memory ingest  --project <repo> --apply --json  # import them into .peaks/memory (IDE side stays read-only)
+
 # 11. Peaks-Loop Final snapshot
 peaks project dashboard --project <repo> --json
 peaks skill doctor --json
@@ -289,7 +300,7 @@ peaks code emit-handoff --project <repo> --job-id <jid> --json
 # job-shape.json says isJob=true, ≥0.85 is MANDATORY auto-compact.
 # Code MUST call this without confirmation under Job mode.
 peaks code context-now --project <repo> --enforce-job-mode --json
-peaks compact auto --execute --project <repo> --json
+peaks code auto-compact --project <repo> --json
 
 # v3.1.2 PreToolUse gate (installed by `peaks workspace init`):
 # every Bash tool call runs `peaks code gate-step-08` automatically.

package/skills/peaks-code/references/session-overload-signal-index.md

@@ -15,8 +15,8 @@ the lookup table the LLM must consult in lieu of intuition.
 
 | # | Signal source | Threshold | File / CLI | LLM action |
 |---|---|---|---|---|
-| 1 | prompt size (main session) | 50% / 75% / 80% / 90% | `src/services/context/threshold.ts`; probe via `peaks code context-now` | soft-warn at 50%; consider compact at 75%; MUST NOT auto-compact mid-batch (D6.e); Job mode ≥ 0.85 ⇒ MANDATORY `peaks compact auto --execute` |
-| 2 | auto-compact zone | 0.85 pre-compact / 0.95 red-line | `src/services/code/auto-compact-orchestrator.ts`; `--enforce-job-mode` flag | Auto-fires `peaks compact auto --execute`; LLM MUST NOT prompt user to compact (zero-pause contract v2.13.0) |
+| 1 | prompt size (main session) | 50% / 75% / 80% / 90% | `src/services/context/threshold.ts`; probe via `peaks code context-now` | soft-warn at 50%; consider compact at 75%; MUST NOT auto-compact mid-batch (D6.e); Job mode ≥ 0.85 ⇒ MANDATORY `peaks code auto-compact` |
+| 2 | auto-compact zone | 0.85 pre-compact / 0.95 red-line | `src/services/code/auto-compact-orchestrator.ts`; `--enforce-job-mode` flag | Auto-fires `peaks code auto-compact`; LLM MUST NOT prompt user to compact (zero-pause contract v2.13.0) |
 | 3 | sub-agent dispatch prompt size | 50% / 75% / 80% | `src/services/context/context-guard.ts`; `peaks sub-agent-dispatch-guard` PreToolUse hook | soft-warn at 50%; CONTEXT_NEAR_LIMIT at 75%; hard-reject at 80% (CLI + hook double-guard) |
 | 4 | statusline compact bar | visual | `src/services/compact-statusline/compact-statusline-service.ts` | ambient UI; surfaces queued/preparing/compacting/verifying/completed/failed/stalled |
 | 5 | in-flight batch deferral | D6.e | `src/services/code/auto-compact-modes.ts` | defer compact until batch lands (NOT "new session") |

package/skills/peaks-code/references/standards-preflight.md

@@ -5,7 +5,7 @@
 - `peaks standards init --project <path> --dry-run`
 - `peaks standards update --project <path> --dry-run`
 
-Use `standards init` for first-time creation and `standards update` for existing `CLAUDE.md` append/review behavior. In `full-auto` and `swarm` profiles, `--apply` runs automatically after `--dry-run` succeeds — these files live inside the target project, are required for downstream skill preflight, and producing them is part of finishing the workflow (Peaks-Loop Gate G enforces this). `assisted` and `strict` profiles pause for explicit user confirmation between dry-run and apply.
+Use `standards init` for first-time creation and `standards update` for existing `CLAUDE.md` append/review behavior. In `full-auto` and `24h` profiles, `--apply` runs automatically after `--dry-run` succeeds — these files live inside the target project, are required for downstream skill preflight, and producing them is part of finishing the workflow (Peaks-Loop Gate G enforces this). `assisted` and `strict` profiles pause for explicit user confirmation between dry-run and apply.
 
 **CRITICAL — Standards must reflect the project scan.** When generating or updating `CLAUDE.md`, the content must reference concrete findings from `.peaks/project-scan/project-scan.md`: the detected component library (e.g. "This project uses antd 5.x"), CSS solution (e.g. "Uses Less via Umi"), build tool, state management, and routing. Never emit a generic template that says "read .claude/rules/..." without naming the actual project stack. If the project-scan has not been run yet, run it before standards init/update.
 

package/skills/peaks-code/references/startup-sequence.md

@@ -31,7 +31,7 @@ After autonomous work (RD, QA, security, perf), invoke peaks-final-review for 4-
 
 ### Peaks-Loop Step N+2: Main-session context monitor (D6 + slice 2026-07-02)
 
-After every 4th tool call, probe via `peaks code context-now --project <repo> --json`. Thresholds: 50% / **0.85 pre-compact / 0.95 red-line** (v2.13.0). **In Job mode ≥ 0.85 is MANDATORY auto-compact** (`peaks compact auto --execute`). Pass `--enforce-job-mode` for single-rid. **≥ 0.95** red line: next Bash/Task fires `peaks compact auto`. **Karpathy §4 exception**: compact red line keeps runner alive — zero-intervention wins; LLM MUST NOT ask user to run `/compact`. Honor `--in-flight-batch` (D6.e).
+After every 4th tool call, probe via `peaks code context-now --project <repo> --json`. Thresholds: 50% / **0.85 pre-compact / 0.95 red-line** (v2.13.0). **In Job mode ≥ 0.85 is MANDATORY auto-compact** (`peaks code auto-compact`). Pass `--enforce-job-mode` for single-rid. **≥ 0.95** red line: next Bash/Task fires `peaks code auto-compact`. **Karpathy §4 exception**: compact red line keeps runner alive — zero-intervention wins; LLM MUST NOT ask user to run `/compact`. Honor `--in-flight-batch` (D6.e).
 
 ### Peaks-Loop Step 0: Anchor the workflow (MANDATORY FIRST ACTIONS — no bail-out)
 

package/skills/peaks-code/references/step-0-8-gate.md

@@ -45,7 +45,7 @@ Refuses to emit a final handoff while `remaining > 0` under Job mode. Pass `--fo
 
 ### 3. Forced auto-compact — `--enforce-job-mode`
 
-`peaks code context-now --enforce-job-mode` (auto-enabled when `job-shape.json` says `isJob=true`) returns `action: 'auto-compact-now'` at ≥ 0.85; Code MUST call `peaks compact auto --execute` without confirmation.
+`peaks code context-now --enforce-job-mode` (auto-enabled when `job-shape.json` says `isJob=true`) returns `action: 'auto-compact-now'` at ≥ 0.85; Code MUST call `peaks code auto-compact` without confirmation.
 
 ### 4. On-disk slice progress — `progress.json`
 

package/skills/peaks-code/references/step-11-memory-sediment.md

@@ -6,6 +6,15 @@ Companion to `SKILL.md` §"Peaks-Loop Step 11". This file holds the substep-by-s
 
 Code MUST NOT declare a workflow complete until Step 11 has produced ≥ 1 file in `.peaks/memory/` OR the user has explicitly approved a no-sediment outcome via AskUserQuestion. Applies to **all modes** including `assisted` and `strict`.
 
+## Single authority (2026-09-09)
+
+**Inside a peaks-code workflow, sedimenting memory writes to `.peaks/memory/`. The IDE-side memory dir is a session note, not the authority.**
+
+- `.peaks/memory/` is peaks-owned and authoritative. Every sediment action ends there.
+- Claude Code's per-project memory dir (`~/.claude/projects/<project-hash>/memory/*.md`) is the IDE's own scratch memory. It is **read-only** for peaks — never write there (same rule as `~/.claude/agents/`).
+- If a session note was written to the IDE-side dir instead of `.peaks/memory/`, pull it in with `peaks memory ingest --apply` (LLM-run; read-only on the IDE side, normalizes frontmatter to `metadata.type`, idempotent by filename stem). Conflicts leave both copies in place — resolve by hand.
+- Never let a memory exist only in the IDE-side dir when the workflow claims the memory was sedimented.
+
 ## Substeps
 
 ### 11a — Gate A (txt/ inventory)
@@ -42,6 +51,32 @@ If `extractedCount === 0` after 11c, fire AskUserQuestion:
 
 > **D-010 fix root cause check:** When firing 11d, first inspect whether the block has the YAML frontmatter (`title:` + `kind:` + `---`). If the `<!-- peaks-memory:start -->` exists but no `title:` line follows, fix the block format and re-run 11c — don't ask the user yet. Default option = (a). Code MUST NOT silently accept (b) without user pick.
 
+### 11e — Index hygiene (run after any sediment)
+
+```bash
+peaks memory reindex --project <repo> --json          # drift report (dry run)
+peaks memory reindex --project <repo> --apply --json  # rebuild index.json + MEMORY.md
+```
+
+`reindex` re-scans **every** `.peaks/memory/*.md` (including `archived/`), resolves each file's kind as `metadata.type` → top-level `kind:` → top-level `type:`, rebuilds `index.json` deterministically, and regenerates `MEMORY.md` (generated banner; do not hand-edit). It reports, never silently drops:
+
+- `unclassified[]` — files with no resolvable kind (add `metadata.type` to fix);
+- `orphanIndex[]` — index entries whose `sourcePath` no longer exists;
+- `orphanDisk[]` — files on disk the rebuilt index does not contain.
+
+Run it whenever Step 11 wrote or imported memories, so the machine index and `MEMORY.md` never drift apart again.
+
+### 11f — Pull in IDE-side session notes (only when needed)
+
+If a memory was written to Claude Code's own memory dir during the session instead of `.peaks/memory/`:
+
+```bash
+peaks memory ingest --project <repo> --json          # preview
+peaks memory ingest --project <repo> --apply --json  # write into .peaks/memory
+```
+
+Source defaults to `~/.claude/projects/<project-hash>/memory/` (read-only). Import is idempotent by filename stem; differing destinations are reported as conflicts and both copies are left in place. Files whose kind cannot be resolved are reported as needing classification — never invented.
+
 ## Why Step 11 exists
 
 Audit 2026-07-03 confirmed 2 consecutive sessions produced zero `.peaks/memory/` files despite completing RD + QA + handoff artifacts; `assisted` mode silently skipped runbook Step 10 (no STOP condition).

package/skills/peaks-code/references/swarm-dispatch-contract.md

@@ -48,7 +48,7 @@ Return a compact JSON envelope — do not write prose.
 - session-id: <sid>          (from .peaks/.active-skill.json or .peaks/.session.json)
 - request-id: <rid>          (PRD id)
 - type: <type>               (feature | bugfix | refactor | config | docs | chore)
-- mode: <mode>               (full-auto | swarm | assisted | strict)
+- mode: <mode>               (full-auto | assisted | strict | 24h)
 - project-scan-path: <path>  (read this for component library / CSS / build tool)
 - existing-system-path: <path>  (legacy projects only)
 - frontendOnly: <bool>       (from project-scan)
@@ -209,7 +209,7 @@ Sub-agent presence in this list = Code launched a Task for it. Absence = the rol
 | Mode | How the swarm plan is decided | What Code does |
 |---|---|---|
 | `full-auto` | Compute plan from signals above, no question to user | Auto-launch all sub-agents in the plan in parallel |
-| `swarm` | Same as `full-auto` | Same as `full-auto` (this profile name is historical — behavior is identical) |
+| `24h` | Same as `full-auto` | Same as `full-auto` (long-run profile; the fan-out shape is identical, only the auto-compact cadence differs) |
 | `assisted` | `AskUserQuestion` with three options: (a) Full — UI + RD(planning) + QA(test-cases); (b) Backend-only — RD(planning) + QA(test-cases); (c) Sequential — run RD first, then QA, skip UI | Use the user's choice as the plan |
 | `strict` | Same as `assisted` (the question is informational; strict still enforces confirmation gates later) | Same as `assisted` |
 

package/skills/peaks-code/references/workflow-gates-and-types.md

@@ -182,5 +182,5 @@ ls <repo>/.claude/rules/common/coding-style.md \
 # standards init/update with --apply and re-verify.
 # Skipping Peaks-Loop Gate G (e.g. because the user did not explicitly authorize writes) is
 # only acceptable in `assisted`/`strict` modes where the user actively declined; in
-# `full-auto`/`swarm` the absence of these files is a workflow violation.
+# `full-auto`/`24h` the absence of these files is a workflow violation.
 ```