peaks-loop 4.0.33 → 4.0.35

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 4.0.35 — 2026-09-10 (记忆系统 overhaul — 写入合一 / 索引重建 / 按任务调取 / 漂移健康检查 / rotate)
+
+**Highlights**:
+
+1. **记忆写入单一权威** — `peaks memory ingest` 把 IDE 侧（Claude Code）记忆导入 `.peaks/memory/`，源目录只读、**绝不写 `~/.claude/`**；SKILL.md 明确：工作流内"沉淀记忆"落 `.peaks/memory/`，IDE 侧仅作会话笔记。
+
+2. **索引重建 + 根因修复** — `peaks memory reindex` 全量重扫并重建 `index.json`。**根因**：共享 frontmatter 解析器只认顶层 `type:`，按契约写 `metadata.type` 的文件被**静默丢弃**。现按 `metadata.type → kind → type` 解析，未识别值**输出清单**而非静默跳过。name 解析新增 `name → title → 文件名` 回退；重名冲突上报不覆盖。本仓库实测：索引 **231 → 276**。
+
+3. **调取按任务 + 分层预算** — preflight 此前 `fetchBlock(_taskTitle)` 的 `taskTitle` **完全未使用**，永远注入同一批 feedback+layerA。现按任务排序（per-token fuzzy，无网络/无 embedding），hot 必进、warm 按相关度入选，三重预算（条数/字节/时间）+ 可观测字段。warm 层首次可被注入。顺带修：读取器原来只扁平化 4 种 kind，丢了 decision/rule/convention/module/lesson。
+
+4. **kind 词表 8 → 21** — 纳入语料中实际使用的 13 个 kind（`bug`/`investigation`/`technical-pattern`/`project-rule`/`design`/`handoff`/`session-handoff`/`project-todo`/`publish-closure`/`project-closure`/`slice-closure`/`slice-pilot-findings`/`sediment`），单一常量驱动解析/索引/CLI/doctor。
+
+5. **`peaks memory rotate`（清除机制）** — 实现 2026-07-24 pruning policy 早已规定但从未实现的轮转：A/B 层永不入选（测试断言）、C 层满 **6 个月**且未被钉住 → 归档、D 层 → 报告待删（不删）、每个候选先过 `src/`+`skills/` 引用 grep。默认 dry-run。
+
+6. **doctor 漂移检查** — 新增 `l3-memory-coverage` / `l3-memory-orphans` / `l3-memory-unclassified`；此前只校验"index.json 是合法 JSON"，46% 不可见也报 ok。
+
+**验证**：build clean、tsc clean、全量 133 files / 1180 passed（1 skipped）；本仓库 rotate dry-run `A:22 B:146 C:138 D:12`。
+
+## 4.0.34 — 2026-09-09 (mode 模型收敛 + auto-compact 死命令 + 上下文窗口覆盖 + 确认门去 TTY)
+
+**Highlights**:
+
+1. **mode 模型收敛（用户设计）** — 此前 `SkillPresenceMode` 与 24h 状态机是两个互不相识的自主性开关。
+
+   - `SkillPresenceMode = full-auto | assisted | strict | 24h`（四选一，并列）。
+   - `swarm` 从"模式"降级为**所有 mode 的默认执行策略**（与"fan-out 强制、不可退回串行"一致）。
+   - 24h 的 6 状态机保留为 **24h mode 的内部状态**；24h 是**唯一可自动开启**的 mode（T1–T5），其余 mode 仍需用户选。
+   - 新增 `peaks code mode status`：一条命令输出 presence mode / 24h 状态 / job mode / auto-compact profile。
+   - **顺带修好一个严重 bug**：`getSkillPresence()` 一直在丢掉 `mode` 字段，导致所有读 `presence.mode` 的守卫（mode-enforcement、assisted/strict 边界、post-compact-detector）**全是死代码**——用户选的 mode 从未真正生效。
+
+2. **auto-compact 契约指向不存在的命令（根因）** — `peaks compact auto --execute` 在 `skills/` + `src/` 出现 **49 次**（含 CLI 自己返回的 `next`），实际执行是 `COMMAND_NOT_FOUND`。真命令是 `peaks code auto-compact`。LLM 按契约执行 → 撞死命令 → 只能回头让用户手动 compact。全部引用已改指真命令，并加守卫测试防回归。
+
+3. **上下文窗口不再对未知模型默认 20w** — 新增 `PEAKS_CONTEXT_WINDOW_TOKENS`（env）与 `context.windowTokens`（config）覆盖，优先级 env > config > 启发式 > 默认；`peaks code context-now` 新增 `capacitySource` 字段，一眼看出窗口值来自哪。
+
+4. **assisted/strict 确认门不再阻塞在 TTY** — `requireUserConfirmation` 此前会开 `readline` 的 `(y/N)` 提示；LLM 会话里 stdin 非 TTY → 直接挂死，且违反 Human-NL-Choice-Only。现改为立即抛出带 `transitionKey` + `mode` + 可执行 nextActions 的错误，由 LLM 用 `AskUserQuestion` 承接、用户同意后重跑 `--confirm`。bypass 语义（`--confirm` / `--force-confirm` / `PEAKS_AUTO_CONFIRM`）完全不变。
+
+**验证**：build clean、tsc clean、全量 126 files / 1102 passed（1 skipped）；实测 `capacitySource` 默认 `model-heuristic`、`PEAKS_CONTEXT_WINDOW_TOKENS=400000` → `env-override`。
+
 ## 4.0.33 — 2026-09-09 (ECC 去插件化 + 动态获取修复 + 移除 understand-anything)
 
 **Highlights**:

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,8 @@
-import { executeProjectMemoryBackup, executeProjectMemoryExtract, summarizeProjectMemoryBackupResult, summarizeProjectMemoryExtractResult } from '../../../services/memory/project-memory-service.js';
+import { executeProjectMemoryBackup, executeProjectMemoryExtract, summarizeProjectMemoryBackupResult, summarizeProjectMemoryExtractResult, VALID_PROJECT_MEMORY_KINDS } from '../../../services/memory/project-memory-service.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { addJsonOption, getErrorMessage, printResult } from '../../cli-helpers.js';
+/** Derived from the canonical kind vocabulary — never hand-maintain a list here. */
+const KIND_HELP = VALID_PROJECT_MEMORY_KINDS.join(', ');
 export function registerMemoryCommand(program, io) {
     const memory = program.command('memory').description('Manage project-local Peaks memory');
     addJsonOption(memory
@@ -48,7 +50,7 @@ export function registerMemoryCommand(program, io) {
     addJsonOption(memory
         .command('list')
         .description('List all memory entries from .peaks/memory/index.json. Pass --pick to spawn fzf for interactive multi-select; the picked subset is written to .peaks/memory/picked.json.')
-        .option('--kind <kind>', 'filter by memory kind (one of: project, rule, decision, reference, feedback, convention, module, lesson)')
+        .option('--kind <kind>', `filter by memory kind (one of: ${KIND_HELP})`)
         .option('--pick', 'spawn fzf for interactive multi-select (requires fzf >= 0.38); writes picked.json')
         .option('--fzf-bin <path>', 'override fzf binary path (default: fzf on PATH)', 'fzf')
         .option('--project <path>', 'target project root (defaults to git root or cwd)')).action((options) => {
@@ -72,10 +74,66 @@ export function registerMemoryCommand(program, io) {
                 process.exitCode = 1;
         });
     });
+    addJsonOption(memory
+        .command('reindex')
+        .description('Rebuild .peaks/memory/index.json from every memory file on disk and regenerate MEMORY.md; reports unclassified files and orphans both ways. Dry-run by default; pass --apply to write.')
+        .option('--project <path>', 'target project root (defaults to git root or cwd)')
+        .option('--dry-run', 'report drift without writing (default)')
+        .option('--apply', 'rebuild index.json and regenerate MEMORY.md')).action((options) => {
+        void import('../memory-commands.js').then(({ runMemoryReindex }) => {
+            void runMemoryReindex(io, {
+                ...(options.project !== undefined ? { project: options.project } : {}),
+                ...(options.dryRun === true ? { dryRun: true } : {}),
+                ...(options.apply === true ? { apply: true } : {}),
+                ...(options.json !== undefined ? { json: options.json } : {}),
+            });
+        }).catch((error) => {
+            printResult(io, fail('memory.reindex', 'MEMORY_REINDEX_BOOTSTRAP_FAILED', getErrorMessage(error), {}, []), options.json);
+            process.exitCode = 1;
+        });
+    });
+    addJsonOption(memory
+        .command('ingest')
+        .description('Import memories written by the IDE-side agent (~/.claude/projects/<hash>/memory/*.md) into the peaks-owned .peaks/memory store. The IDE-side dir is read-only. Dry-run by default; pass --apply to write.')
+        .option('--project <path>', 'target project root (defaults to git root or cwd)')
+        .option('--source-dir <path>', 'override the IDE-side memory directory')
+        .option('--dry-run', 'preview imports without writing (default)')
+        .option('--apply', 'write normalized memories into .peaks/memory')).action((options) => {
+        void import('../memory-commands.js').then(({ runMemoryIngest }) => {
+            void runMemoryIngest(io, {
+                ...(options.project !== undefined ? { project: options.project } : {}),
+                ...(options.sourceDir !== undefined ? { sourceDir: options.sourceDir } : {}),
+                ...(options.dryRun === true ? { dryRun: true } : {}),
+                ...(options.apply === true ? { apply: true } : {}),
+                ...(options.json !== undefined ? { json: options.json } : {}),
+            });
+        }).catch((error) => {
+            printResult(io, fail('memory.ingest', 'MEMORY_INGEST_BOOTSTRAP_FAILED', getErrorMessage(error), {}, []), options.json);
+            process.exitCode = 1;
+        });
+    });
+    addJsonOption(memory
+        .command('rotate')
+        .description('Tier-driven retention for .peaks/memory/ (sediment pruning policy, tier 1: archive only, never delete). Tier assignment: explicit `metadata.tier: A|B|C|D` wins; else files under archived/ are D, files pinned in MEMORY.md are B, kinds rule/convention/project-rule are A, kinds decision/reference/feedback/module/bug/investigation/technical-pattern are B, everything else is C. Tier C older than 6 months (frontmatter updatedAt/updated/modified, else file mtime) and not pinned is archived; tier D is reported as a delete-candidate only. Tier A/B are never selected, every candidate must pass a reference grep against src/ + skills/, and --apply refuses an empty plan or a failed gate. Dry-run by default.')
+        .option('--project <path>', 'target project root (defaults to git root or cwd)')
+        .option('--dry-run', 'report the rotation plan without moving anything (default)')
+        .option('--apply', 'move tier-C candidates into .peaks/memory/archived/')).action((options) => {
+        void import('../memory-commands.js').then(({ runMemoryRotate }) => {
+            void runMemoryRotate(io, {
+                ...(options.project !== undefined ? { project: options.project } : {}),
+                ...(options.dryRun === true ? { dryRun: true } : {}),
+                ...(options.apply === true ? { apply: true } : {}),
+                ...(options.json !== undefined ? { json: options.json } : {}),
+            });
+        }).catch((error) => {
+            printResult(io, fail('memory.rotate', 'MEMORY_ROTATE_BOOTSTRAP_FAILED', getErrorMessage(error), {}, []), options.json);
+            process.exitCode = 1;
+        });
+    });
     addJsonOption(memory
         .command('search <query>')
         .description('Fuzzy-search the memory index (deterministic, local, zero-token). Default --limit 6.')
-        .option('--kind <kind>', 'filter by memory kind (one of: project, rule, decision, reference, feedback, convention, module, lesson)')
+        .option('--kind <kind>', `filter by memory kind (one of: ${KIND_HELP})`)
         .option('--limit <n>', 'maximum number of matches to return', (value) => Number(value))
         .option('--project <path>', 'target project root (defaults to git root or cwd)')).action((query, options) => {
         // Lazy import avoids a top-of-file import cycle (memory-commands.ts

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

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

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

@@ -36,7 +36,7 @@ import { writeLogEntry } from '../../services/log/logger.js';
 import { PROMPT_LIMIT_BYTES, RECOMMENDED_ROLES, validateRole } from './sub-agent-shared.js';
 import { runDispatchFromDag } from './dispatch-from-dag.js';
 import { TEST_TOOL_DETECTION_BLOCK, formatTestToolDetection } from '../../services/dispatch/test-tool-detection.js';
-import { MemoryPreflightService } from '../../services/context/memory-preflight-service.js';
+import { MemoryPreflightService, deriveMemoryQuery } from '../../services/context/memory-preflight-service.js';
 import { buildDispatchSystemPrompt } from '../../services/context/build-dispatch-system-prompt.js';
 import { computeUiLibraryDispatchBlock } from '../../services/standards/ui-library-dispatch-block.js';
 import { readFreshContextBlock } from '../../services/fresh-context/fresh-context-block.js';
@@ -373,7 +373,9 @@ export function registerDispatchCommand(parent, io) {
             // memory preflight block (or silently skip when unavailable) via the
             // pure-function builder.
             const preflightService = new MemoryPreflightService(projectRoot, projectPrefs);
-            const memoryBlock = await preflightService.fetchBlock(role);
+            // Slice 2026-09-09-memory-retrieval: rank the injected memory by the
+            // task at hand (role + first line of the brief), not the bare role.
+            const memoryBlock = await preflightService.fetchBlock(deriveMemoryQuery(role, options.prompt));
             // Slice 2026-09-03-codegraph-preread (Option A): pre-dispatch
             // codegraph preflight for RD planning. BEFORE the RD sub-agent's
             // prompt is composed, ensure the codegraph index exists (init +

package/dist/cli/commands/memory-commands.d.ts

@@ -13,9 +13,44 @@ export interface MemoryListCommandOptions {
     project?: string;
     json?: boolean;
 }
+export interface MemoryReindexCommandOptions {
+    project?: string;
+    dryRun?: boolean;
+    apply?: boolean;
+    json?: boolean;
+}
+export interface MemoryIngestCommandOptions {
+    project?: string;
+    sourceDir?: string;
+    dryRun?: boolean;
+    apply?: boolean;
+    json?: boolean;
+}
+export interface MemoryRotateCommandOptions {
+    project?: string;
+    dryRun?: boolean;
+    apply?: boolean;
+    json?: boolean;
+}
 export declare function runMemoryList(io: ProgramIO, options: MemoryListCommandOptions): Promise<void>;
 /**
  * Run the memory search subcommand. Extracted so unit tests can
  * exercise the full envelope without spawning a subprocess.
  */
 export declare function runMemorySearch(io: ProgramIO, options: MemorySearchCommandOptions): Promise<void>;
+/**
+ * `peaks memory reindex` — rebuild `.peaks/memory/index.json` from disk and
+ * regenerate `MEMORY.md`. Dry-run by default; `--apply` writes.
+ */
+export declare function runMemoryReindex(io: ProgramIO, options: MemoryReindexCommandOptions): Promise<void>;
+/**
+ * `peaks memory rotate` — tier-driven retention for `.peaks/memory/`.
+ * Implements the sediment pruning policy (tier 1: archive, never delete).
+ * Dry-run by default; `--apply` moves tier-C candidates into `archived/`.
+ */
+export declare function runMemoryRotate(io: ProgramIO, options: MemoryRotateCommandOptions): Promise<void>;
+/**
+ * `peaks memory ingest` — import memories written by the IDE-side agent into
+ * `.peaks/memory/`. The IDE-side source is read-only; dry-run by default.
+ */
+export declare function runMemoryIngest(io: ProgramIO, options: MemoryIngestCommandOptions): Promise<void>;

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

@@ -1,20 +1,19 @@
 import { findProjectRoot } from '../../services/config/config-safety.js';
 import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
 import { loadMemoryIndex, searchMemory } from '../../services/memory/memory-search-service.js';
+import { executeMemoryReindex, VALID_PROJECT_MEMORY_KINDS } from '../../services/memory/project-memory-service.js';
+import { executeMemoryIngest } from '../../services/memory/memory-ingest-service.js';
+import { executeMemoryRotate } from '../../services/memory/memory-rotate-service.js';
 import { pickFromList } from '../../services/fuzzy-matching/fzf-pick-service.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { getErrorMessage, printResult } from '../cli-helpers.js';
 import { join } from 'node:path';
-const VALID_KINDS = [
-    'project',
-    'rule',
-    'decision',
-    'reference',
-    'feedback',
-    'convention',
-    'module',
-    'lesson',
-];
+const VALID_KINDS = VALID_PROJECT_MEMORY_KINDS;
+function resolveMemoryProjectRoot(project) {
+    return project !== undefined
+        ? resolveCanonicalProjectRoot(project)
+        : (findProjectRoot(process.cwd()) ?? process.cwd());
+}
 export async function runMemoryList(io, options) {
     const projectRoot = options.project !== undefined
         ? resolveCanonicalProjectRoot(options.project)
@@ -124,3 +123,113 @@ export async function runMemorySearch(io, options) {
         process.exitCode = 1;
     }
 }
+/**
+ * `peaks memory reindex` — rebuild `.peaks/memory/index.json` from disk and
+ * regenerate `MEMORY.md`. Dry-run by default; `--apply` writes.
+ */
+export async function runMemoryReindex(io, options) {
+    const projectRoot = resolveMemoryProjectRoot(options.project);
+    if (options.dryRun === true && options.apply === true) {
+        printResult(io, fail('memory.reindex', 'INVALID_MEMORY_REINDEX_FLAGS', 'Use either --dry-run or --apply, not both', {}, ['Run without --apply to preview the drift report, or pass --apply to rebuild']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const report = executeMemoryReindex({ projectRoot, apply: options.apply === true });
+        const nextActions = [];
+        if (options.apply !== true) {
+            nextActions.push('Preview only — re-run with --apply to rebuild index.json and regenerate MEMORY.md.');
+        }
+        if (report.unclassified.length > 0) {
+            nextActions.push(`${report.unclassified.length} file(s) have no resolvable kind; add \`metadata.type\` (or \`kind:\`) to index them.`);
+        }
+        if (report.orphanIndex.length > 0) {
+            nextActions.push(`${report.orphanIndex.length} previous index entry(ies) point at missing files; they are dropped from the rebuilt index.`);
+        }
+        if (report.nameConflicts.length > 0) {
+            nextActions.push(`${report.nameConflicts.length} name collision(s) across files; both entries are kept — rename one file to disambiguate.`);
+        }
+        printResult(io, ok('memory.reindex', report, [], nextActions), options.json);
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        const code = error.code ?? 'MEMORY_REINDEX_FAILED';
+        printResult(io, fail('memory.reindex', code, message, { projectRoot }, ['Check that the project has a readable .peaks/memory directory']), options.json);
+        process.exitCode = 1;
+    }
+}
+/**
+ * `peaks memory rotate` — tier-driven retention for `.peaks/memory/`.
+ * Implements the sediment pruning policy (tier 1: archive, never delete).
+ * Dry-run by default; `--apply` moves tier-C candidates into `archived/`.
+ */
+export async function runMemoryRotate(io, options) {
+    const projectRoot = resolveMemoryProjectRoot(options.project);
+    if (options.dryRun === true && options.apply === true) {
+        printResult(io, fail('memory.rotate', 'INVALID_MEMORY_ROTATE_FLAGS', 'Use either --dry-run or --apply, not both', {}, ['Run without --apply to preview the rotation plan, or pass --apply to archive tier-C candidates']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const report = executeMemoryRotate({ projectRoot, apply: options.apply === true });
+        const nextActions = [];
+        if (report.refused) {
+            nextActions.push(`Refused to apply: ${report.refusalReasons.join('; ')}`);
+        }
+        else if (options.apply !== true) {
+            nextActions.push('Preview only — re-run with --apply to move the tier-C candidates into archived/.');
+        }
+        if (report.excluded.length > 0) {
+            nextActions.push(`${report.excluded.length} candidate(s) excluded by a safety gate (see \`excluded\`).`);
+        }
+        const deleteCandidates = report.candidates.filter((candidate) => candidate.action === 'delete-candidate');
+        if (deleteCandidates.length > 0) {
+            nextActions.push(`${deleteCandidates.length} tier-D file(s) are delete-candidates only; peaks never deletes them — remove by hand if you are sure.`);
+        }
+        printResult(io, ok('memory.rotate', report, report.warnings, nextActions), options.json);
+        if (report.refused)
+            process.exitCode = 1;
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        const code = error.code ?? 'MEMORY_ROTATE_FAILED';
+        printResult(io, fail('memory.rotate', code, message, { projectRoot }, ['Check that the project has a readable .peaks/memory directory']), options.json);
+        process.exitCode = 1;
+    }
+}
+/**
+ * `peaks memory ingest` — import memories written by the IDE-side agent into
+ * `.peaks/memory/`. The IDE-side source is read-only; dry-run by default.
+ */
+export async function runMemoryIngest(io, options) {
+    const projectRoot = resolveMemoryProjectRoot(options.project);
+    if (options.dryRun === true && options.apply === true) {
+        printResult(io, fail('memory.ingest', 'INVALID_MEMORY_INGEST_FLAGS', 'Use either --dry-run or --apply, not both', {}, ['Run without --apply to preview imports, or pass --apply to write them into .peaks/memory']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const report = executeMemoryIngest({
+            projectRoot,
+            ...(options.sourceDir !== undefined ? { sourceDir: options.sourceDir } : {}),
+            apply: options.apply === true
+        });
+        const nextActions = [];
+        if (options.apply !== true && report.imported.length > 0) {
+            nextActions.push('Preview only — re-run with --apply to write these memories into .peaks/memory.');
+        }
+        if (report.conflicts.length > 0) {
+            nextActions.push(`${report.conflicts.length} conflict(s) left both copies in place; resolve them by hand.`);
+        }
+        if (report.needsClassification.length > 0) {
+            nextActions.push(`${report.needsClassification.length} file(s) could not be classified; add \`metadata.type\` to the source before re-running.`);
+        }
+        printResult(io, ok('memory.ingest', report, report.warnings, nextActions), options.json);
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        const code = error.code ?? 'MEMORY_INGEST_FAILED';
+        printResult(io, fail('memory.ingest', code, message, { projectRoot }, ['Check the --source-dir path and that .peaks/memory is writable']), options.json);
+        process.exitCode = 1;
+    }
+}

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);