peaks-loop 4.0.0-beta → 4.0.0-beta.10

package/skills/peaks-solo/references/sediment-prompt-template.md

@@ -0,0 +1,62 @@
+# peaks-solo — Sediment Prompt Template (沉淀提议 AskUserQuestion)
+
+> 自规划兜底跑完(转交 leaf 跑完则由 leaf 内部 Step 11 处理,**不重复问**)→ peaks-solo 用本模板提议沉淀。
+> **核心约束(HC-9 Human-NL-Choice-Only 锁死):** 必须用 AskUserQuestion 4-option,**不**允许自由文本输入;**默认推荐 = (a)**,**不**是 (d)。
+
+## 4-option AskUserQuestion 模板
+
+```yaml
+question: "本次结果是否沉淀?"
+options:
+  - label: "(a) 沉淀为普通 lesson / convention"
+    description: "通过 peaks memory extract --apply 写到 .peaks/memory/<user>/,作为可复用 lessons/conventions。"
+  - label: "(b) 沉淀为 Loop Engineering 资产"
+    description: "通过 peaks asset crystallize 提升为 Loop Engineering Asset(标准 / skill / SOP / framework)。"
+  - label: "(c) 改 scope 再沉淀"
+    description: "本次 scope 不对,LLM 继续追问(例如想问清楚是什么 lesson),然后再走 (a) 或 (b)。"
+  - label: "(d) 不沉淀"
+    description: "单次性结果,丢弃,不写入任何 .peaks/ 路径。"
+multiSelect: false
+```
+
+## 默认推荐
+
+**默认推荐 = (a)**(普通 lesson / convention),**不**是 (d)。
+
+**为什么推荐 (a) 而不是 (b):** (b) 沉淀为 Loop Engineering Asset 是**重操作**——会进入 `.peaks/standards/` 或 `.peaks/memory/<asset>/`,影响所有 peaks-* skill 的语义。普通 lesson / convention 风险低、可回滚、不会污染项目 invariants,适合作为大多数一次性结果的首选归宿。(b) 仅在 LLM 识别 ≥ 2 个 reuse signals 时推荐。
+
+## LLM 必须给一段 NL rationale
+
+在调 AskUserQuestion 前,LLM **必须**先(在最终回复里,AskUserQuestion 之前)给一段 1-3 句的 NL 解释,说明为什么推荐 (a) 或 (b)。模板:
+
+> "我推荐 (a) 沉淀为普通 lesson / convention,理由:<1 句:本次结果的可复用程度 / 适用范围 / 为什么不是 (b) / 为什么不是 (d)>。如果你认为这是 Loop Engineering 级别的资产,选 (b);如果本次是单次性 / scope 不对,选 (c) 或 (d)。"
+
+**禁止:** 直接弹 AskUserQuestion 不解释;**禁止:** 默认推荐 (d)。
+
+## 触发条件矩阵
+
+| peaks-solo 跑完类型 | 是否问沉淀 | trigger 标记 |
+|---|---|---|
+| 转交 leaf 跑完 | **不问**(leaf 内部 Step 11 处理) | `leaf_handled` |
+| 自规划兜底跑完(成功) | **默认问** | `success_default_prompt` |
+| 自规划兜底跑完(部分失败) | **附带"是否继续"二选一 + 沉淀四选一**两个 AskUserQuestion | `partial_failure` |
+| 用户主动说"沉淀这个" / "把这个记下来" | **立即问**(跳过自规划完成检测) | `user_explicit` |
+| LLM 识别 ≥ 2 个 reuse signals(同一结果可在 ≥ 2 个未来场景复用) | **附带 4-section brief 问**(在 question 前先输出 brief:reuse contexts / scope / drift risks / crystallize recommendation) | `llm_suggested` |
+| 沉淀提议被用户选 (d) 后 | **不重复问**,直接关闭 peaks-solo session | `user_declined` |
+| 沉淀提议被用户选 (c) 后(scope 改) | **继续追问 → 再问一次 4-option** | `scope_change` |
+
+## 沉淀后的执行
+
+| 用户选 | LLM 执行 |
+|---|---|
+| (a) | `peaks memory extract --apply --session-id <sid> --project <repo>` —— 走现成 CLI,不重写 |
+| (b) | `peaks asset crystallize --asset <name> --project <repo>` —— 走现成 CLI;**仅**在用户明确选 (b) 后执行 |
+| (c) | 继续 AskUserQuestion 追问(例如"具体是什么场景的 lesson?" / "适用哪个子项目?") |
+| (d) | 不写任何文件;peaks-solo 直接结束 |
+
+## 反 pattern 警告
+
+- **不推荐 (b) 默认推荐** —— 大多数一次性结果进不了 Loop Engineering Asset 层;盲目 crystallize 会污染 `.peaks/standards/`。
+- **不静默丢弃** —— 用户没明示"不要沉淀",就必须问;选 (d) 必须是用户**主动选**,不是 LLM 默认。
+- **不重复问** —— 转交 leaf 跑完由 leaf 处理 sediment;peaks-solo 只对**自规划兜底跑完**问。
+- **不让用户自由文本** —— HC-9 锁死;不在 AskUserQuestion 选项之外加 free-form input。

package/skills/peaks-solo/references/triage-decision-table.md

@@ -0,0 +1,31 @@
+# peaks-solo — Triage Decision Table
+
+> 关键词 → leaf skill 快速映射。peaks-solo 在 §3 triage 决策流里先扫本表做"启发式预判",再用 `peaks skill search --query "<NL>"` 做精确匹配。
+> 匹配规则:case-insensitive substring(命中即行;同 NL 多行命中 → AskUserQuestion 多选)。
+
+| keyword | → | leaf skill |
+|---|---|---|
+| code / 代码 / 改 bug / 写功能 / 全流程 / 端到端 / PR / 测试覆盖 / 改 src | → | /peaks-code |
+| 文档 / article / blog / 内容 / 写稿 / 内容工作流 / 公众号 / 长文 | → | /peaks-content |
+| 健康 / health / 体检 / audit / 报告 / doctor report / 项目诊断 | → | /peaks-doctor |
+| issue / 修 issue / sweep / 批量修 / open issue 处理 | → | /peaks-issue-fix-orchestrator |
+| SOP / 流程 / 工作流 / 审批 / 门禁 / 标准操作 | → | /peaks-sop |
+| 性能 / perf / 慢 / 优化 / latency / 响应时间 | → | /peaks-perf-audit (or 自规划) |
+| 安全 / security / 漏洞 / vulnerability / OWASP | → | /peaks-security-audit (or 自规划) |
+| 状态 / status / 进度 / 现在到哪 / 当前在哪一步 | → | /peaks-status |
+| 跑测试 / test / vitest / unit test | → | /peaks-test |
+| 恢复 / resume / 继续 / 接上次 | → | /peaks-resume |
+| 不知道 / 随便 / 帮我 / 你帮我决定 / 我想做点东西 | → | peaks-solo triage (this skill) |
+| 切片 / slice / 拆解任务 / 大任务拆小 | → | /peaks-slice-decompose |
+| 想法 / brain-storm / 创意 / 探索思路 | → | /peaks-ide |
+| 最终审查 / final review / 验收 / 4-dim evidence | → | /peaks-final-review |
+| 研究 / research / 信息查询 / GitHub trending / top 10 / 调查 | → | (no leaf) → 自规划(deep-search / WebSearch) |
+| 一句话需求 / 一次性 / 单次性 | → | peaks-solo 自规划兜底 |
+
+## 使用说明
+
+1. **先扫表,再跑 search。** 表是 O(N) 的 substring 命中;跑 `peaks skill search` 是兜底。两者结果不一致时,以 search 为准(search 读的是 live frontmatter)。
+2. **多行命中 → AskUserQuestion 多选,**模板见 SKILL.md §3.1。
+3. **(e) "都不对" → 自规划兜底。** 走 SKILL.md §4。
+4. **空表条目:** "研究 / 信息查询 / GitHub trending / top 10" 等一次性信息查询,**当前 skill 池没有专属 leaf**,peaks-solo 直接走自规划(deep-search / WebSearch)。
+5. **本表是 opportunistic 表,**不是 exhaustive 表。S2/S3 后续可在 dogfood 中发现新关键词补行。

package/skills/peaks-status/SKILL.md

@@ -3,9 +3,9 @@ name: peaks-status
 description: Universal status primitive for any in-flight Peaks-Loop workflow (orchestrator-agnostic). Reads the existing CLI primitives (peaks skill presence, peaks session list, peaks project dashboard, peaks request show) and renders a 1-screen status table. Use when the user asks "where are we", "现在到哪了", "what's the current state" for ANY bee (peaks-code, future peaks-research, …). Triggers on "/peaks-status", "现在到哪了", "what is the current state", "show me the dashboard". (Replaces peaks-status as a top-level primitive.)
 ---
 
-# Peaks-Loop Solo Status (wrapper)
+# Peaks-Loop Code Status (wrapper)
 
-Peaks-Loop Solo Status is a thin wrapper that renders a compact status table for the current peaks-code orchestrator state. It is the answer to "I just want to know where we are" — no PRD, no RD, no QA, no full peaks-code orchestration. Just read the existing CLI state and render a 1-screen summary.
+Peaks-Loop Code Status is a thin wrapper that renders a compact status table for the current peaks-code orchestrator state. It is the answer to "I just want to know where we are" — no PRD, no RD, no QA, no full peaks-code orchestration. Just read the existing CLI state and render a 1-screen summary.
 
 **This is a transparent wrapper.** The user does not stay in this skill — the status table is rendered, and control hands off (back to the user, or to `peaks-code` if the user wants to act on the status).
 

package/skills/peaks-test/SKILL.md

@@ -3,9 +3,9 @@ name: peaks-test
 description: Universal test-runner primitive for any in-flight Peaks-Loop workflow (orchestrator-agnostic). Runs the project's test suite on the current repo and reports results. Use when the user asks "run the tests", "跑一下 test", "跑测试" for ANY bee (peaks-code, future peaks-research, …). Triggers on "/peaks-test", "跑一下 test", "跑测试", "run the tests", "test now". (Replaces peaks-test as a top-level primitive.)
 ---
 
-# Peaks-Loop Solo Test (wrapper)
+# Peaks-Loop Code Test (wrapper)
 
-Peaks-Loop Solo Test is a thin wrapper that runs the project's test suite on the current repo and reports results. It is the answer to "I just want to see if the tests pass" — no PRD, no RD, no QA, no full peaks-code orchestration. Just `pnpm vitest run` and a compact summary.
+Peaks-Loop Code Test is a thin wrapper that runs the project's test suite on the current repo and reports results. It is the answer to "I just want to see if the tests pass" — no PRD, no RD, no QA, no full peaks-code orchestration. Just `pnpm vitest run` and a compact summary.
 
 **This is a transparent wrapper.** The user does not stay in this skill — the test command runs, the result is summarized, and control hands off (back to the user, or to `peaks-code` if the user wants to act on the result).
 

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

@@ -1,275 +0,0 @@
-import { runDoctor } from '../../../services/doctor/doctor-service.js';
-import { listSkills } from '../../../services/skills/skill-registry.js';
-import { runSkillSync, SYNC_PLATFORMS } from '../../../services/skills/sync-service.js';
-import { inspectSkillRunbook } from '../../../services/skills/skill-runbook-service.js';
-import { setSkillPresence, clearSkillPresence, getSkillPresence, isSkillPresenceMode, touchSkillHeartbeat, checkStalePresence } from '../../../services/skills/skill-presence-service.js';
-import { detectPresenceMarker } from '../../../services/hooks/presence-marker-detector.js';
-import { findProjectRoot } from '../../../services/config/config-safety.js';
-import { generateProjectContext } from '../../../services/memory/project-context-service.js';
-import { getSessionId, setSessionMeta } from '../../../services/session/session-manager.js';
-import { fail, ok } from '../../../shared/result.js';
-import { addJsonOption, getErrorMessage, printResult } from '../../cli-helpers.js';
-export function registerSkillCommand(program, io) {
-    const skill = program.command('skill').description('Manage Peaks skills');
-    addJsonOption(skill.command('list').description('List skills derived from skills/*/SKILL.md')).action(async (options) => {
-        const skills = await listSkills();
-        if (options.json === true) {
-            printResult(io, ok('skill.list', { skills }), true);
-        }
-        else {
-            const sorted = [...skills].sort((a, b) => {
-                if (a.name === 'peaks-sop')
-                    return -1;
-                if (b.name === 'peaks-sop')
-                    return 1;
-                if (a.name === 'peaks-code')
-                    return -1;
-                if (b.name === 'peaks-code')
-                    return 1;
-                return a.name.localeCompare(b.name);
-            });
-            for (const skill of sorted) {
-                io.stdout(`  ${skill.name.padEnd(14)}${skill.description}`);
-            }
-            io.stdout(`\n  Invoke any skill by typing its name in conversation (e.g. \`peaks-sop\`).`);
-        }
-    });
-    addJsonOption(skill.command('doctor').description('Run skill-related doctor checks')).action(async (options) => {
-        const report = await runDoctor();
-        const skillChecks = report.checks.filter((check) => check.id.startsWith('skill'));
-        const failed = skillChecks.filter((check) => !check.ok).length;
-        if (options.json === true) {
-            printResult(io, ok('skill.doctor', { checks: skillChecks, ok: failed === 0 }), true);
-        }
-        else {
-            for (const check of skillChecks) {
-                const icon = check.ok ? '+' : '×';
-                io.stdout(`  ${icon}  ${check.message}`);
-            }
-            io.stdout(`\n  ${skillChecks.length - failed} passed, ${failed} failed`);
-            if (failed > 0) {
-                io.stderr('\nOne or more skill checks failed.');
-            }
-        }
-        if (failed > 0) {
-            process.exitCode = 1;
-        }
-    });
-    // Slice #12 final piece (per spec §9 line 1105):
-    // `peaks skills sync 8 平台分发`. Idempotent: re-running is a
-    // no-op when the symlinks are already correct.
-    addJsonOption(skill
-        .command('sync')
-        .description(`Sync the peaks-* skill family to one or all of the 8 supported LLM-CLI platforms (${SYNC_PLATFORMS.join(', ')}). Idempotent.`)
-        .option('--platform <id>', `sync only one platform (default: --all). Valid: ${SYNC_PLATFORMS.join(', ')}`)
-        .option('--all', 'sync all 8 platforms (default if --platform is omitted)')
-        .option('--dry-run', 'do not write; emit the same shape with applied=false')
-        .option('--project <path>', 'project root (default: cwd)')).action(async (options) => {
-        try {
-            const projectRoot = options.project ?? process.cwd();
-            const platforms = options.platform !== undefined ? [options.platform] : undefined;
-            const result = await runSkillSync({
-                projectRoot,
-                ...(platforms !== undefined ? { platforms } : {}),
-                ...(options.dryRun === true ? { dryRun: true } : {}),
-            });
-            const envelope = ok('skill.sync', result, [], [
-                `syncedCount: ${result.syncedCount}/${result.perPlatform.length} platforms`,
-                `totalInstalled: ${result.totalInstalled} skill symlinks`,
-                result.failedCount > 0
-                    ? `failedCount: ${result.failedCount} (run \`peaks skill status\` for details)`
-                    : 'no failures',
-            ]);
-            printResult(io, envelope, options.json);
-            if (result.failedCount > 0) {
-                process.exitCode = 1;
-            }
-        }
-        catch (error) {
-            const message = getErrorMessage(error);
-            printResult(io, fail('skill.sync', 'SKILL_SYNC_FAILED', message, { applied: false }, [message]), options.json);
-            process.exitCode = 1;
-        }
-    });
-    addJsonOption(skill
-        .command('runbook <name>')
-        .description('Inspect a skill Default runbook section and its --apply authorization-note status')).action(async (name, options) => {
-        try {
-            const inspection = await inspectSkillRunbook(name);
-            const result = inspection.ok
-                ? ok('skill.runbook', inspection)
-                : fail('skill.runbook', inspection.hasRunbook ? 'SKILL_RUNBOOK_APPLY_UNGATED' : 'SKILL_RUNBOOK_MISSING', inspection.hasRunbook
-                    ? `Skill ${inspection.name} has ${inspection.destructiveApplyLines.length} destructive --apply command(s) without an authorization/dry-run note`
-                    : `Skill ${inspection.name} is missing a ## Default runbook section`, inspection, inspection.hasRunbook
-                    ? ['Add an authorization or --dry-run note next to destructive --apply lines in the runbook section']
-                    : ['Add a `## Default runbook` section to the skill SKILL.md']);
-            printResult(io, result, options.json);
-            if (!inspection.ok) {
-                process.exitCode = 1;
-            }
-        }
-        catch (error) {
-            printResult(io, fail('skill.runbook', 'SKILL_NOT_FOUND', getErrorMessage(error), { name }), options.json);
-            process.exitCode = 1;
-        }
-    });
-    addJsonOption(skill
-        .command('presence')
-        .description('Show the currently active Peaks skill (alias: presence:get)')
-        .option('--check-stale', 'slice 002 (v2.15.0): also report whether the recorded outer session id still matches the current one. Default false (back-compat).')
-        .option('--project <path>', 'project root (default: cwd)')).action((options) => {
-        const presence = getSkillPresence(options.project);
-        if (presence === null) {
-            printResult(io, ok('skill.presence', { active: false }), options.json);
-            return;
-        }
-        if (options.checkStale === true) {
-            // Slice 002 (v2.15.0) AC-1: pair the read with a staleness
-            // check so callers (peaks-code Step 1, statusline) get both
-            // pieces of info from a single CLI invocation. The presence
-            // is returned UNCHANGED — `--check-stale` is a read-only flag,
-            // not a clear.
-            const staleness = checkStalePresence({ projectRootOverride: options.project });
-            printResult(io, ok('skill.presence', {
-                active: true,
-                ...presence,
-                stale: staleness.stale,
-                staleReason: staleness.reason,
-                currentOuterSessionId: staleness.currentOuterSessionId,
-                recordedOuterSessionId: staleness.recordedOuterSessionId
-            }), options.json);
-            return;
-        }
-        printResult(io, ok('skill.presence', { active: true, ...presence }), options.json);
-    });
-    addJsonOption(skill
-        .command('presence:set <name>')
-        .description('Set the currently active Peaks skill for session-wide visibility')
-        .option('--mode <mode>', 'execution mode')
-        .option('--gate <gate>', 'current gate')
-        .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')).action((name, options) => {
-        const projectRoot = options.project ?? 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);
-            process.exitCode = 1;
-            return;
-        }
-        const presence = setSkillPresence(name, options.mode, options.gate, options.project);
-        // As of slice 003-2026-06-06-session-layout-canonicalize we do NOT
-        // call `ensureSession` here. The CLI wrapper previously spawned a
-        // new session on every presence call, which made the canonical
-        // session binding drift (the LLM saw the session id change every
-        // turn). The presence now reuses the session bound at
-        // `.peaks/_runtime/session.json` (or the legacy `.peaks/.session.json`
-        // during the back-compat window). If no session is bound, the
-        // presence still writes the active-skill marker — downstream code
-        // can `peaks workspace init` separately to create the session.
-        //
-        // Session metadata is updated when a session is bound (read-only
-        // path: `getSessionId`). We do not auto-spawn a session.
-        const boundSessionId = getSessionId(projectRoot);
-        if (boundSessionId !== null) {
-            setSessionMeta(projectRoot, boundSessionId, {
-                skill: name,
-                ...(options.mode ? { mode: options.mode } : {}),
-                ...(options.gate ? { gate: options.gate } : {})
-            });
-        }
-        printResult(io, ok('skill.presence:set', { active: true, ...presence }), options.json);
-    });
-    addJsonOption(skill
-        .command('presence:clear')
-        .description('Clear the active Peaks skill presence indicator and update project context')
-        .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')).action((options) => {
-        const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-        const removed = clearSkillPresence(options.project);
-        // Auto-update project context so future sessions have up-to-date history
-        try {
-            generateProjectContext(projectRoot);
-        }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-            // non-fatal: context update failure should not block presence clear
-        }
-        printResult(io, ok('skill.presence:clear', { active: false, removed, projectContextUpdated: true }), options.json);
-    });
-    // Slice 002 (v2.15.0) — AC-1: presence staleness detector.
-    // peaks-code Step 1 (and `peaks solo should-pause --step
-    // step-1-mode-select`) calls this to decide whether the recorded
-    // `mode` field can be trusted or whether the LLM must AskUserQuestion.
-    addJsonOption(skill
-        .command('presence:check-stale')
-        .description('Slice 002 (v2.15.0) AC-1: report whether the recorded presence outer session id still matches the current outer session id. ' +
-        'Returns { stale: boolean, reason: "outer-session-mismatch" | "no-presence" | null }. ' +
-        'Pure read-only — does NOT clear the presence (use `peaks skill presence:clear` for that).')
-        .option('--project <path>', 'project root (default: cwd)')
-        .option('--current-outer <id>', 'override the current outer session id (test seam; default: read from PEAKS_OUTER_SESSION_ID / CLAUDE_CODE_SESSION_ID)')).action((options) => {
-        // v2.15.0 slice 002 repair: do NOT pass `currentOuter: undefined`
-        // when the user omits the flag. The service-layer branch
-        // `'currentOuter' in opts` returns true for an explicit
-        // `undefined` (the key exists on the spread object literal),
-        // which would skip the env-var fallback and pin `current =
-        // undefined` — always reading the presence as stale. Build a
-        // sparse opts object so the service can fall back to
-        // `getCurrentOuterSessionId()` (reads PEAKS_OUTER_SESSION_ID /
-        // CLAUDE_CODE_SESSION_ID).
-        const checkOpts = options.project !== undefined ? { projectRootOverride: options.project } : {};
-        if (options.currentOuter !== undefined) {
-            checkOpts.currentOuter = options.currentOuter;
-        }
-        const result = checkStalePresence(checkOpts);
-        // Always emit `currentOuterSessionId` in the JSON envelope (even
-        // when undefined → ''), per slice 002 AC-1 contract: downstream
-        // tooling (statusline, sub-agent dispatch) reads the field by
-        // name, never by `data.currentOuterSessionId ?? ''`. JSON.stringify
-        // drops `undefined` properties, so we coerce to '' before
-        // wrapping in the envelope.
-        const data = {
-            stale: result.stale,
-            reason: result.reason,
-            presence: result.presence,
-            currentOuterSessionId: result.currentOuterSessionId ?? '',
-            recordedOuterSessionId: result.recordedOuterSessionId ?? ''
-        };
-        printResult(io, ok('skill.presence:check-stale', data), options.json);
-    });
-    addJsonOption(skill
-        .command('heartbeat')
-        .description('Show the heartbeat status of the active Peaks skill')).action((options) => {
-        const presence = getSkillPresence();
-        if (presence === null) {
-            printResult(io, ok('skill.heartbeat', { active: false, heartbeat: 'none' }), options.json);
-            return;
-        }
-        printResult(io, ok('skill.heartbeat', {
-            active: true,
-            skill: presence.skill,
-            gate: presence.gate ?? null,
-            lastHeartbeat: presence.lastHeartbeat ?? presence.setAt,
-            setAt: presence.setAt
-        }), options.json);
-    });
-    addJsonOption(skill
-        .command('heartbeat:touch')
-        .description('Update the heartbeat timestamp (called by the LLM each turn to confirm peaks skill context is alive)')).action((options) => {
-        const updated = touchSkillHeartbeat();
-        if (updated === null) {
-            printResult(io, ok('skill.heartbeat:touch', { active: false, heartbeat: 'none' }), options.json);
-            return;
-        }
-        printResult(io, ok('skill.heartbeat:touch', {
-            active: true,
-            skill: updated.skill,
-            lastHeartbeat: updated.lastHeartbeat
-        }), options.json);
-    });
-    addJsonOption(skill
-        .command('detect-marker-loss')
-        .description('Detect whether the latest assistant message lost the Peaks-Loop status header while a peaks skill is still active (slice 028 detection primitive).')
-        .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')
-        .option('--message <text>', 'latest assistant message text to scan (defaults to reading the most recent LLM response from the stdin pipe, or empty string when no pipe is attached)')).action((options) => {
-        const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-        const message = options.message ?? '';
-        const result = detectPresenceMarker({ project: projectRoot, latestAssistantMessage: message });
-        printResult(io, ok('skill.detect-marker-loss', result), options.json);
-    });
-}

package/dist/src/cli/commands/dispatch-from-dag.js

@@ -1,251 +0,0 @@
-/**
- * `peaks sub-agent dispatch --from-dag <file>` — slice 2026-06-23-audit-3rd #7.
- *
- * Pulled out of `dispatch-commands.ts` to honor the 800-line file cap
- * (Karpathy #2 Simplicity First). The single-dispatch action stays in
- * `dispatch-commands.ts`; the DAG-dispatch path lives here because the
- * two paths share no logic — the warm-path single dispatch does NOT
- * load slice-dag / dag-orchestrator / contract-store (slice 9 perf),
- * while the --from-dag codepath loads all three on first call.
- *
- * 2.7.0 slice-dag-dispatcher MVP: read a SliceDag from a file and run
- * it through `runDag`. The orchestrator's `runSlice` is a thin wrapper
- * that emits the per-IDE `buildToolCall` envelope for each topological
- * level.
- *
- * 1.2 MVP scope: this dispatches the FIRST topological level synchronously
- * (returns the dispatch specs); subsequent levels are not surfaced in
- * the CLI envelope because the LLM-side runner must actually execute
- * each `buildToolCall` and write the resulting contract before level 2+
- * can be safely auto-advanced. The LLM re-invokes
- * `peaks sub-agent dispatch --from-dag <file> --batch-id <id>` after
- * writing level-1 contracts, which causes runDag to plan level 2+ with
- * the level-1 ancestor contracts spliced into their dispatch prompts.
- *
- * Internally, runDag DOES iterate all levels so its join-barrier +
- * cancel-on-fail path is exercised end-to-end during the MVP emit; only
- * the CLI envelope is filtered to level-1 toolCalls (see `firstLevelIds`).
- */
-import { randomUUID } from 'node:crypto';
-import { printResult } from '../cli-helpers.js';
-import { fail, ok } from '../../shared/result.js';
-import { detectInstalledIde } from '../../services/ide/ide-detector.js';
-import { getAdapter } from '../../services/ide/ide-registry.js';
-import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
-export async function runDispatchFromDag(role, options, asJson, io) {
-    if (!options.fromDag)
-        return;
-    const projectRoot = options.project ?? process.cwd();
-    // Slice 2026-06-26-unknown-sid-fallback-fix: see dispatch-commands.ts.
-    // Auto-resolve sid from .peaks/_runtime/session.json before falling back.
-    const sid = options.sessionId
-        ?? process.env.PEAKS_SESSION_ID
-        ?? getCurrentSessionId(projectRoot)
-        ?? 'unknown-sid';
-    const rid = options.requestId ?? 'unknown-rid';
-    const batchId = options.batchId ?? randomUUID();
-    // Slice 9 (dispatch CLI latency): the --from-dag codepath loads three
-    // heavy modules (slice-dag, dag-orchestrator, contract-store) that
-    // transitively import 10+ more services. They are NOT touched by the
-    // warm-path single-dispatch action, so we lazy-load them here only
-    // when --from-dag is actually requested. The dynamic-import promise
-    // resolves on first call, then ESM caches the module for subsequent
-    // calls in the same process.
-    const [{ readFileSync }, sliceDagMod, dagOrchestratorMod, contractStoreMod] = await Promise.all([
-        import('node:fs'),
-        import('../../services/dispatch/slice-dag.js'),
-        import('../../services/solo/dag-orchestrator.js'),
-        import('../../services/dispatch/contract-store.js')
-    ]);
-    const { validateDag, topologicalLevels, isSliceComplexity } = sliceDagMod;
-    const { runLayeredDag } = dagOrchestratorMod;
-    const { listContracts, hashContract } = contractStoreMod;
-    let dag;
-    try {
-        const raw = readFileSync(options.fromDag, 'utf8');
-        const parsed = JSON.parse(raw);
-        validateDag(parsed);
-        dag = parsed;
-    }
-    catch (err) {
-        printResult(io, fail('sub-agent.dispatch', 'INVALID_DAG', `failed to read or validate DAG from ${options.fromDag}: ${err.message}`, { role, toolCall: null, dispatchRecordPath: null }, [
-            'Check the JSON file at the given path; the DAG must have {nodes, edges} and pass validateDag().'
-        ]), asJson);
-        process.exitCode = 1;
-        return;
-    }
-    // MVP (1.2): the orchestrator iterates topological levels + join
-    // barrier + cancel-on-fail end-to-end. The CLI's runner returns `done`
-    // for every leaf (so runDag's cancel-on-fail path is exercised when a
-    // leaf actually fails); the CLI envelope filters `emittedToolCalls` to
-    // the first level only (see `firstLevelIds`). The LLM-side runner
-    // re-invokes `--from-dag` for level 2+ after writing level-1
-    // contracts via `peaks contract write`.
-    let levelArr;
-    try {
-        levelArr = topologicalLevels(dag);
-    }
-    catch (err) {
-        printResult(io, fail('sub-agent.dispatch', 'INVALID_DAG', `topologicalLevels failed for ${options.fromDag}: ${err.message}`, { role, toolCall: null, dispatchRecordPath: null }, [
-            'The DAG passed validateDag() but topologicalLevels threw (likely a cycle that slipped past validateDag, or a runtime invariant).',
-            'Inspect the DAG file with the editor and re-invoke dispatch. (No peaks scan dag CLI ships in 2.7.0; if you need a programmatic DAG validator, import validateDag / topologicalLevels from src/services/dispatch/slice-dag.ts directly.)'
-        ]), asJson);
-        process.exitCode = 1;
-        return;
-    }
-    // Read upstream contracts so downstream-level prompts (when re-invoked
-    // for level 2+) get auto-injected ancestors via `formatContractInjection`.
-    // At level-1 emit time, contracts is empty (no ancestors yet); the
-    // injection matters when the LLM re-invokes for level 2+ after writing
-    // level-1 contracts via `writeContract`.
-    const existingContracts = listContracts(projectRoot, sid);
-    const ide = detectInstalledIde(projectRoot) ?? 'claude-code';
-    const adapter = getAdapter(ide);
-    const dispatcher = adapter.subAgentDispatcher;
-    if (!dispatcher.supportsRole(role)) {
-        printResult(io, fail('sub-agent.dispatch', 'IDE_NOT_SUPPORTED', `IDE ${ide} does not support role "${role}"`, { role, toolCall: null, dispatchRecordPath: null }, [
-            'Switch to a registered IDE (e.g. claude-code) or pick a role the current IDE supports.'
-        ]), asJson);
-        process.exitCode = 1;
-        return;
-    }
-    // Track per-level emissions so the CLI envelope can expose ONLY the
-    // first topological level to the LLM (matching MVP 1.2 semantics: LLM
-    // executes level-1 toolCalls, writes contracts via `peaks contract
-    // write`, then re-invokes `--from-dag` for level 2+). Level-2+ leaves
-    // still flow through runDag's join-barrier — their toolCalls are
-    // generated internally so the orchestrator's happy path is exercised
-    // end-to-end, but they are NOT surfaced in the CLI envelope (the LLM
-    // sees them only after re-invoking with fresh level-1 contracts).
-    const firstLevelIds = new Set(levelArr[0] ?? []);
-    const emittedToolCalls = [];
-    const emittedSliceIds = [];
-    // CLI runner: emit the per-slice `buildToolCall` envelope, then return
-    // `done` with an empty `publicSurface` placeholder. The orchestrator
-    // treats the slice as "CLI-emitted, awaiting LLM-side execution" and
-    // advances to the next topological level (or breaks on failure). The
-    // placeholder surface is intentionally empty: the real public surface
-    // arrives later via `peaks contract write` from the LLM-side runner,
-    // and overwrites the CLI placeholder contract written by `noopWriter`.
-    // Why not `cancelled`? Returning `cancelled` here short-circuits
-    // runDag's join-barrier + cancel-on-fail path — the orchestrator
-    // breaks out after the first level with a cancellation, which hides
-    // the real cancel-on-fail semantics from the test suite (and from any
-    // future caller that wants to use `runDag` end-to-end from the CLI).
-    // Returning `done` exercises the full happy path; cancel-on-fail
-    // semantics will be covered when 1.3 lands real per-IDE await.
-    const cliRunner = async (spec) => {
-        const toolCall = dispatcher.buildToolCall({
-            role: spec.role,
-            prompt: spec.prompt,
-            requestId: rid,
-            sessionId: sid
-        });
-        if (firstLevelIds.has(spec.sliceId)) {
-            emittedToolCalls.push(toolCall);
-            emittedSliceIds.push(spec.sliceId);
-        }
-        return {
-            status: 'done',
-            publicSurface: {
-                exports: [],
-                types: [],
-                publicSignatures: []
-            }
-        };
-    };
-    // CLI noop writer — the orchestrator collects a `SliceContract` per
-    // emitted toolCall so downstream re-invocations (level 2+) can splice
-    // ancestor contracts via `formatContractInjection`. We don't write to
-    // disk here (the LLM-side runner does that via `peaks contract write`
-    // after each toolCall resolves), but the returned placeholder MUST be
-    // shape-valid: the `contractHash` field has to be a real SHA-256 hex
-    // string so formatContractInjection + downstream validators don't
-    // reject the placeholder. The placeholder hash is computed from the
-    // slice identity only (`sliceId|sessionId`) — it's deterministic,
-    // stable, and collision-free for the MVP run, but obviously does NOT
-    // represent the slice's actual public surface. The LLM-side runner's
-    // `peaks contract write` call will overwrite this with a content-based
-    // hash once the slice finishes.
-    const noopWriter = (sliceId, _publicSurface) => {
-        const partial = {
-            sliceId,
-            sessionId: sid,
-            exports: [],
-            types: [],
-            publicSignatures: []
-        };
-        return {
-            sliceId,
-            sessionId: sid,
-            completedAt: new Date(0).toISOString(), // epoch sentinel = "placeholder, not yet finished"
-            exports: [],
-            types: [],
-            publicSignatures: [],
-            contractHash: hashContract(partial)
-        };
-    };
-    // runLayeredDag IS in the path: validates the DAG, iterates all
-    // topological levels (foundation/upstreamSync slices prioritized within
-    // each level by `topologicalLevels`), runs the join barrier after
-    // each level, and triggers cancel-on-fail rollback if any leaf
-    // returns `failed` (or `cancelled`, once 1.3 lands). The CLI
-    // envelope below filters `emittedToolCalls` / `emittedSliceIds` to
-    // the first level — see the `firstLevelIds` filter inside `cliRunner`.
-    try {
-        await runLayeredDag(dag, {
-            projectRoot,
-            sessionId: sid,
-            existingContracts,
-            runSlice: cliRunner,
-            writeContractFn: noopWriter
-        });
-    }
-    catch (err) {
-        // runLayeredDag throws DagPlanError for plan-level failures (e.g.
-        // cycle slipping past validateDag). Surface it as INVALID_DAG so
-        // the CLI envelope has a clear failure code, not a generic
-        // DISPATCH_ERROR.
-        printResult(io, fail('sub-agent.dispatch', 'INVALID_DAG', `runLayeredDag failed for ${options.fromDag}: ${err.message}`, { role, toolCall: null, dispatchRecordPath: null }, [
-            'runLayeredDag threw DagPlanError; the DAG passed validateDag() but failed at topologicalLevels or contractStore dispatch.',
-            'Inspect the DAG file and re-run.'
-        ]), asJson);
-        process.exitCode = 1;
-        return;
-    }
-    printResult(io, ok('sub-agent.dispatch', {
-        // Slice 2026-06-23-audit-4th #E1: envelopeVersion marker
-        envelopeVersion: '2.1.0',
-        role,
-        ide: dispatcher.label,
-        fromDag: options.fromDag,
-        batchId,
-        dispatchCount: emittedSliceIds.length,
-        levelsTotal: levelArr.length,
-        firstLevel: emittedSliceIds,
-        toolCalls: emittedToolCalls,
-        existingContractCount: existingContracts.length,
-        // v2.15.0 follow-up — G12/G11/G2: per-slice metadata (foundation /
-        // upstreamSync / complexity) for downstream scheduling decisions.
-        sliceMeta: emittedSliceIds.map((id) => {
-            const node = dag.nodes.find((n) => n.id === id);
-            return {
-                id,
-                foundation: node?.foundation === true,
-                upstreamSync: node?.upstreamSync === true,
-                complexity: node?.complexity !== undefined && isSliceComplexity(node.complexity)
-                    ? node.complexity
-                    : null
-            };
-        }),
-        nextActions: [
-            'Execute each toolCall in your IDE; on completion, write the slice contract to .peaks/_runtime/<sid>/dispatch/contracts/<slice-id>.json.',
-            'Re-invoke `peaks sub-agent dispatch --from-dag <file>` with the same batch-id to advance to the next level once all current-level slices have written contracts.'
-        ]
-    }, [], [
-        'MVP (1.2) plans the first level via runLayeredDag orchestrator (cancel-on-fail path active); the LLM drives subsequent levels by re-invoking this command after contract writes.',
-        existingContracts.length > 0
-            ? `Injected ${existingContracts.length} upstream contract(s) into downstream-level prompts via formatContractInjection.`
-            : 'No upstream contracts found; first-level prompts have empty ancestor blocks.'
-    ]), asJson);
-}