peaks-loop 4.1.3 → 4.1.4

package/.claude-plugin/marketplace.json

@@ -1,13 +1,13 @@
 {
   "metadata": {
     "pluginRoot": ".",
-    "version": "4.1.3"
+    "version": "4.1.4"
   },
   "plugins": [
     {
       "name": "peaks-loop",
       "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
-      "version": "4.1.3",
+      "version": "4.1.4",
       "author": {
         "name": "SquabbyZ"
       },

package/CHANGELOG.md

@@ -1,5 +1,61 @@
 # Changelog
 
+## 4.1.4 — 2026-10-10 (修掉推送门上的一个假绿；`src/cli/commands` 清空超帽；两条"BLOCKING 却拦不住任何东西"的步骤；以及一项被推迟的边界)
+
+**版本级别**: 未发布区间 `v4.1.3..HEAD` 共 **17 个 commit**（1 feat / 5 fix / 6 refactor / 2 test / 其余 docs+memory）。取 **patch**，依维护者 2026-07-22 的常设规则"默认版本新增采用最小的版本位"。4 个 workspace 包各 +1 patch（internal-runtime 0.0.43→0.0.44、mut 0.1.57→0.1.58、shared 0.0.92→0.0.93、shared-channel 0.0.60→0.0.61），`CLI_VERSION` 与 `RUNTIME_VERSION` 由 `scripts/sync-version.mjs` 同步。**本版不新增命令族**，所以 4.1.3 那条"新增命令应取 minor"的注记不适用。
+
+### 1. 推送门上的一个假绿（1 fix，三轮交付）
+
+**leg 2 的分类器会把"新增了 gated 文件却忘了重生成基线"的改动放过去。** 实测 `6a1938a8` 那次推送：leg 2 跑了 601 个测试，**其中没有一条**是钉"每个 in-scope 文件都在 `gate-baseline.json` 里有 `files[]` 行"的那个守卫——它住在 `tests/unit/standards/`，而分类器只把 `src/<area>` 映射到 `tests/unit/<area>`，**没有任何一条路径通向那里**。守卫直到**下一次**推送（改了 `.husky/` 触发全量）才变红，`0c5fe123` 就是那两次提交需要付的修。
+
+分类器现在是一个**纯模块**（`scripts/test-changed-classify.mjs`），三条规则旧映射表达不了：
+
+- **R1** 基线**内容**动了 ⇒ 跑它的守卫套件（`tests/unit/standards/` + `tests/unit/lint/`），而不是 0 个测试
+- **R2** 任何 `A`/`D`/`R`/`C` ⇒ 跑人口守卫（按 git **status** 判定，不重述 census 的策略目录）
+- **R3** census 的**策略源文件**被改 ⇒ 同样跑（`M src/services/scan/file-size-policy.ts` 会让 44 个 `.md` 突然进 scope）
+
+**只有 `generatedAt` 动了的重生成仍然是惰性的（0 测试）——但现在是建立在一个真命题上。** 旧豁免写的理由是"没有测试读它"，那是**假的**：读者经由 `tests/unit/standards/_file-size-cap-scan.ts` 的 `BASELINE_PATH` 常量抵达它，而 2026-09-23 那次搜索找的是路径**字符串**，看不见常量间接引用。
+
+**第一版实现被 5 路评审否决，而这是本版最有价值的一段记录。** 它把守卫加进**选择集**，于是"没映射到测试 ⇒ 跑全量"那张网永不触发：**新增一个 CI workflow 会一个读 `.github/` 的测试都不跑**（实测有 5 个）。四个来源独立撞上同一缺陷，而 AC5 的验收臂看不见它——**因为那条臂用的正是唯一还能漏下去的形状**（`M README.md`）。修完的形状是：**守卫是映射的加法，不是全量网的替代品**，且那张复现表变成了一组臂。
+
+### 2. `src/cli/commands` 清空超帽（6 refactor）
+
+**30 个超帽文件 → 0**（目录从 300 走到 440 个跟踪文件）。配方是**拆分与压函数必须在同一次交付里完成**——只拆会把 `eslintFindings` 推高（本仓第一批就这样被拒过 +23/+19），一起做则下降。
+
+三个 `src/services` 顶层文件也一并处理（`hooks-settings-service` 1037→300、`auto-compact-orchestrator` 1030→285、`config-service` 1011→253）。
+
+**四个 ceiling 全程只降不升**：
+
+```
+fileSizeOverCap        112 -> 78
+fileSizeExcessLines  30352 -> 22502
+eslintFindings        1951 -> 1760
+eslintErrors           709 ->  590
+```
+
+### 3. 两条"BLOCKING 却拦不住任何东西"的步骤（1 fix）
+
+**由一次真实事故追出**：本会话的编排者跑完 4 个 slice、11 个提交，**从未执行 Step 11 的记忆沉淀**，而契约写着它 BLOCKING。追查后是两条可定位的缺陷：
+
+- **Step 11 没有任何可执行的拒绝点。** `verify-pipeline` 查 QA 与 Gate H；`emit-handoff` 查 **job 账本**；`gate-step-08` 查 job 叙述——**没有一个查 memory**。唯一"可执行的" Step 11 相关物，断言的是 SKILL.md 里那个**标题**存在。
+- **`gate-step-08` 在输入缺失时 fail-open**，并把"我没有能力判断"说成"我判断了，这不像 Job"。实测：整轮**一次 `Next: slice #N of M` 都没出现**。而这个真空本仓的 drift **D-003** 已记过（`JOB_SHAPE_NOT_DECIDED` 自 4.0.0-beta.6 起不再抛），它只是从另一个角度又咬了一次。
+
+修法：`emit-handoff` 增加 `block-no-sediment`（信号取自 `.peaks/memory/index.json`，**peaks 自己的状态，不是裸 mtime**；三值化且 **`unknown` 拒绝**）；`gate-step-08` 三态化，**无决定但有账本 ⇒ 拒绝**。**两半都端到端验过**：把 `job-shape.json` 移开 ⇒ exit 2；让 memory index 不可读 ⇒ exit 1。**这里的 fail-closed 语义是"别再声称一个你没做出的判断"，不是"拦下每一次 Bash 调用"**——该 hook 跑在每个会话的每次 Bash 上。
+
+同时把 5 条反馈记忆提升到强制层（3 条 Layer A 由 CLI 自行生成注册，2 条 Layer B 写成**真的** PreToolUse hook：一条拦会改全局状态的命令，一条拦"把测试运行器管进管道"——后者本会话被犯过两次）。**Layer B 的注册一度只存在于 gitignored 的生成文件里**，所以本版把两条条目加进生成器、**并把它从 475 行压到 299 行**（帽 300）以不抬 ceiling。**`shell` pin 是真正的坑**：照抄旁边那条的约定会让两个 hook 变成非阻断错误从而**静默放行**。
+
+### 4. 一项被推迟的边界（1 fix）
+
+slice 1 当初**刻意推迟**了 git C-quoting：含非 ASCII/控制字节的路径会被加引号，于是匹配不上任何锚定正则。推迟的理由是它先于本版存在、且当时 0 个受影响路径。本版用 `git diff --name-status -z`（NUL 分隔、不加引号不转义）关掉它，`parseNameStatus` 按 status 字母隐含的字段数消费记录。**对照是真的**：同一份 diff 去掉 `-z` 确实带引号，而 HEAD 的解析器逐字返回那个带引号路径。
+
+### 5. 边界取证（2 test）
+
+三项"机制存在但从未端到端跑过"的欠账：`format:check` 在 CI runner 上**确实评过**（不是被跳过）；PATH 上的 `peaks` 是**已安装构建**而非工作树，且**8 个未推送提交新增的 161 个 src 文件全部不在已安装 dist 里而两边都报 4.1.3**——本地 e2e 覆盖**看起来存在而实际为零**；棘轮唯一的联合判定例外 `COUPLED_SIZE_RISE`**确实能开，而且是有条件的**（双向实测）。
+
+审计另外补上了两处此前**没有任何东西能抓到**的行为（`docker rm --force` 的 argv、`docker run` 的 flags），方式是对未驱动路径做**注入式直接调用测试**——评审证明过：五个相同的注册表哈希是**一个维度重复五次**，而它**看不见函数体**。
+
+---
+
 ## 4.1.3 — 2026-10-09 (只读 MCP 能力面首次发布：把"只读"做成可证伪的东西；两处"工具在说假话"的修复；三批尺寸债，以及门禁自己被加固)
 
 **版本级别**: 未发布区间 `v4.1.2..HEAD` 共 **20 个 commit**（2 feat / 3 fix / 4 refactor / 2 chore(gate) / 2 merge / 其余 docs+memory）。取 **patch**，依维护者 2026-07-22 的常设规则"默认版本新增采用最小的版本位"。

package/README-en.md

@@ -155,7 +155,7 @@ Every lane opens with **one slash command**.
 
 | | |
 | --- | --- |
-| **Latest** | [![npm](https://img.shields.io/npm/v/peaks-loop?style=for-the-badge&logo=npm&logoColor=white&color=cb3837)](https://www.npmjs.com/package/peaks-loop) — 4.1.3 (2026-10-09) |
+| **Latest** | [![npm](https://img.shields.io/npm/v/peaks-loop?style=for-the-badge&logo=npm&logoColor=white&color=cb3837)](https://www.npmjs.com/package/peaks-loop) — 4.1.4 (2026-10-10) |
 | **Domains** | Code (`peaks-code`) · Content (`peaks-content`) · Project health (`peaks-doctor`) · Issue sweep (`peaks-issue-fix-orchestrator`) · Custom SOP (`peaks-sop`) · Cross-domain primitives (`peaks-solo` dispatcher · `peaks-resume` · `peaks-status` · `peaks-test` · `peaks-slice-decompose`) |
 | **Sediment pool** | `~/.peaks/` local pool · twice-clean runs auto-promote to a bee · broken runs come back for you to redefine · the bee grows with your taste |
 | **Test suite** | 285+ cases · 4 packages (peaks-loop / peaks-loop-mut / peaks-loop-shared-channel / peaks-loop-shared) · **0 timeouts** · 14 BDD caller-binding edge cases |

package/README.md

@@ -175,7 +175,7 @@ npm i -g peaks-loop
 
 | | |
 | --- | --- |
-| **最新版本** | [![npm](https://img.shields.io/npm/v/peaks-loop?style=for-the-badge&logo=npm&logoColor=white&color=cb3837)](https://www.npmjs.com/package/peaks-loop) — 4.1.3(2026-10-09) |
+| **最新版本** | [![npm](https://img.shields.io/npm/v/peaks-loop?style=for-the-badge&logo=npm&logoColor=white&color=cb3837)](https://www.npmjs.com/package/peaks-loop) — 4.1.4(2026-10-10) |
 | **覆盖域** | 代码(`peaks-code`) · 内容(`peaks-content`) · 项目健康(`peaks-doctor`) · 批量修 issue(`peaks-issue-fix-orchestrator`) · 自定义 SOP(`peaks-sop`) · 通用原语(`peaks-solo` 分诊 / `peaks-resume` 续 / `peaks-status` 看 / `peaks-test` 测 / `peaks-slice-decompose` 切片) |
 | **沉淀池** | `~/.peaks/` 本地池 · 跑两次自动晋升成 bee · 跑翻车让你重定义 · bee 跟着你的口味长 |
 | **测试套件** | 1096 cases · 4 packages (peaks-loop 1015 / runtime 39 / mut 22 / shared-channel 20) · **CI 首次全绿**(ubuntu + windows) · 14 BDD caller-binding coverage |

package/dist/cli/commands/asset-command-shared.d.ts

@@ -0,0 +1,12 @@
+import { openStateDb } from '../../services/skillhub/sqlite-store.js';
+import { CrystallizationService, type CrystallizationTrigger } from '../../services/crystallization/index.js';
+export declare function collectRepeatable(value: string, previous: string[]): string[];
+export declare const DISPOSE_MODES: readonly ["trace_only", "retain", "destroy"];
+export type DisposeMode = (typeof DISPOSE_MODES)[number];
+export declare function parseTriggerFlag(raw: string): CrystallizationTrigger | null;
+/** `--project`, else the nearest project root above cwd, else cwd. */
+export declare function resolveAssetProjectRoot(project: string | undefined): string;
+/** Ensure `<projectRoot>/.peaks/` exists and open its `state.db`. */
+export declare function openAssetDb(projectRoot: string): ReturnType<typeof openStateDb>;
+/** The CrystallizationService wiring every asset verb repeats, built once. */
+export declare function createCrystallizationService(db: ReturnType<typeof openStateDb>): CrystallizationService;

package/dist/cli/commands/asset-command-shared.js

@@ -0,0 +1,45 @@
+// src/cli/commands/asset-command-shared.ts
+//
+// The flag parsers, project/db bootstrap and service wiring the three
+// `peaks asset` verbs share. Split out of `asset-commands.ts` so each verb can
+// live in its own module without repeating the same twelve-line construction.
+import { existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { openStateDb } from '../../services/skillhub/sqlite-store.js';
+import { CrystallizationService, CRYSTALLIZATION_TRIGGERS } from '../../services/crystallization/index.js';
+import { LoopReleaseSchema } from '../../services/loop/loop-release-types.js';
+import { insertLoopRelease } from '../../services/loop/loop-release-store.js';
+import { insertLoopBeeRelation } from '../../services/loop/loop-bee-relation-store.js';
+import { LoopBeeRelationSchema } from '../../services/loop/loop-bee-relation-types.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+export function collectRepeatable(value, previous) {
+    if (Array.isArray(previous))
+        return [...previous, value];
+    return [value];
+}
+export const DISPOSE_MODES = ['trace_only', 'retain', 'destroy'];
+export function parseTriggerFlag(raw) {
+    return CRYSTALLIZATION_TRIGGERS.includes(raw)
+        ? raw
+        : null;
+}
+/** `--project`, else the nearest project root above cwd, else cwd. */
+export function resolveAssetProjectRoot(project) {
+    return project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+}
+/** Ensure `<projectRoot>/.peaks/` exists and open its `state.db`. */
+export function openAssetDb(projectRoot) {
+    if (!existsSync(join(projectRoot, '.peaks'))) {
+        mkdirSync(join(projectRoot, '.peaks'), { recursive: true });
+    }
+    return openStateDb(join(projectRoot, '.peaks', 'state.db'));
+}
+/** The CrystallizationService wiring every asset verb repeats, built once. */
+export function createCrystallizationService(db) {
+    return new CrystallizationService(db, {
+        loopReleaseSchema: LoopReleaseSchema,
+        loopBeeRelationSchema: LoopBeeRelationSchema,
+        insertLoopRelease: insertLoopRelease,
+        insertLoopBeeRelation: insertLoopBeeRelation
+    });
+}

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

@@ -39,7 +39,12 @@
  * Defense in depth: the CrystallizationService enforces the
  * pre-run gate and the brief-section guard; the CLI only
  * translates flags into the service payload.
+ *
+ * The verb implementations live beside this file, one module per verb:
+ * `asset-crystallize-command.ts`, `asset-dispose-command.ts`,
+ * `asset-status-command.ts`, with their shared bootstrap in
+ * `asset-command-shared.ts`.
  */
 import type { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
+import type { ProgramIO } from '../cli-helpers.js';
 export declare function registerAssetCommands(program: Command, io: ProgramIO): void;

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

@@ -39,29 +39,15 @@
  * Defense in depth: the CrystallizationService enforces the
  * pre-run gate and the brief-section guard; the CLI only
  * translates flags into the service payload.
+ *
+ * The verb implementations live beside this file, one module per verb:
+ * `asset-crystallize-command.ts`, `asset-dispose-command.ts`,
+ * `asset-status-command.ts`, with their shared bootstrap in
+ * `asset-command-shared.ts`.
  */
-import { existsSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { openStateDb } from '../../services/skillhub/sqlite-store.js';
-import { CrystallizationService, CrystallizationIntegrityError, BriefSectionError, safeRenderRecommendationPayload, CRYSTALLIZATION_TRIGGERS, parseEvidenceBrief } from '../../services/crystallization/index.js';
-import { LoopReleaseSchema } from '../../services/loop/loop-release-types.js';
-import { insertLoopRelease } from '../../services/loop/loop-release-store.js';
-import { insertLoopBeeRelation } from '../../services/loop/loop-bee-relation-store.js';
-import { LoopBeeRelationSchema } from '../../services/loop/loop-bee-relation-types.js';
-import { findProjectRoot } from '../../services/config/config-safety.js';
-import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
-import { fail, ok } from 'peaks-loop-shared/result';
-function collectRepeatable(value, previous) {
-    if (Array.isArray(previous))
-        return [...previous, value];
-    return [value];
-}
-const DISPOSE_MODES = ['trace_only', 'retain', 'destroy'];
-function parseTriggerFlag(raw) {
-    return CRYSTALLIZATION_TRIGGERS.includes(raw)
-        ? raw
-        : null;
-}
+import { registerAssetCrystallizeCommand } from './asset-crystallize-command.js';
+import { registerAssetDisposeCommand } from './asset-dispose-command.js';
+import { registerAssetStatusCommand } from './asset-status-command.js';
 export function registerAssetCommands(program, io) {
     // Reuse the existing `asset` parent if one is registered; the
     // add-a-new-subcommand-check-for-existing-top-level-first rule
@@ -71,354 +57,7 @@ export function registerAssetCommands(program, io) {
         program
             .command('asset')
             .description('M5: cross-asset crystallization surface (crystallize / dispose / status — spec §5 / §7.4)');
-    // ---------- peaks asset crystallize ----------
-    addJsonOption(asset
-        .command('crystallize')
-        .description('M5: persist a new loop_release + main_bee_release + loop_bee_relation + crystallization_event in a single transaction. Enforces the pre-run gate (task_status=completed AND gates_passed=true AND evidence_collected=true; AC-4 / RL-2) and the brief-section guard (all 4 sections required; AC-15 / RL-7).')
-        .requiredOption('--from-task <id>', "the candidate task id (must be 'completed' with gates_passed + evidence_collected)")
-        .requiredOption('--loop-id <id>', 'kebab-case loop id, e.g. loop-onboarding-research')
-        .requiredOption('--loop-name <name>', 'NL display name')
-        .requiredOption('--loop-scenario <text>', 'long-form scenario text (what real problem the loop solves)')
-        .requiredOption('--loop-trigger-policy <text>', 'trigger policy (NL intent match)')
-        .requiredOption('--loop-interaction-policy <text>', 'interaction policy (Human-NL-Choice-Only is the default)')
-        .requiredOption('--loop-feedback-policy <text>', 'feedback policy (what feedback enters long-term memory)')
-        .requiredOption('--loop-evolution-policy <text>', 'evolution policy (Darwin-style ratchet rules)')
-        .requiredOption('--loop-success-criterion <text>', 'declarative success criterion (repeatable)', collectRepeatable, [])
-        .requiredOption('--loop-evaluator-policy <text>', 'evaluator policy line (repeatable)', collectRepeatable, [])
-        .requiredOption('--loop-version <semver>', 'loop version (e.g. 0.1.0)')
-        .requiredOption('--bee-name <name>', 'main bee name (kebab-case)')
-        .requiredOption('--bee-version <semver>', 'bee version (e.g. 0.1.0)')
-        .requiredOption('--bee-description <text>', 'main bee description (manifest-level)')
-        .requiredOption('--bee-relation-reason <text>', 'NL reason for the main bee relation')
-        .requiredOption('--brief-what-happened <text>', 'brief section: what_happened (1-2 sentence factual account)')
-        .requiredOption('--brief-why-it-matters <text>', 'brief section: why_it_matters (1-2 sentence explanation)')
-        .requiredOption('--brief-what-learned <text>', 'brief section: what_learned (1-2 sentence learning)')
-        .requiredOption('--brief-what-action <text>', 'brief section: what_action (1 sentence recommended action)')
-        .option('--brief-bullet <bullet>', 'structured bullet supporting the brief (repeatable)', collectRepeatable, [])
-        .option('--source-trace <id>', 'workflow trace id backing the brief (repeatable)', collectRepeatable, [])
-        .option('--evaluator-summary <text>', 'evaluator one-liner (independent scorers)', '')
-        .option('--user-decision-summary <text>', 'user decision summary (NL)', '')
-        .option('--bee-intent-raw <text>', 'optional bee user_intent_raw')
-        .option('--bee-parent-version <semver>', 'optional parent_version')
-        .option('--bee-changelog <text>', 'optional changelog')
-        .option('--trigger <name>', `crystallization trigger (one of: ${CRYSTALLIZATION_TRIGGERS.join('|')})`, 'user_explicit')
-        .option('--project <path>', 'project root (default: cwd)')).action((options) => {
-        try {
-            const trigger = parseTriggerFlag(options.trigger);
-            if (!trigger) {
-                printResult(io, fail('asset.crystallize', 'ASSET_INVALID_TRIGGER', `--trigger must be one of: ${CRYSTALLIZATION_TRIGGERS.join('|')}`, { trigger: options.trigger }, ['Pass a valid --trigger value.']), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            // Build the brief from CLI flags and re-validate it through
-            // the canonical schema (so a partial brief is caught BEFORE
-            // any DB side effects fire).
-            const candidateBrief = {
-                what_happened: options.briefWhatHappened,
-                why_it_matters: options.briefWhyItMatters,
-                what_learned: options.briefWhatLearned,
-                what_action: options.briefWhatAction
-            };
-            let brief;
-            try {
-                brief = parseEvidenceBrief(candidateBrief);
-            }
-            catch (err) {
-                if (err instanceof BriefSectionError) {
-                    const briefErr = err;
-                    printResult(io, fail('asset.crystallize', 'MISSING_BRIEF_SECTION', briefErr.message, { findings: [...briefErr.findings], flagsProvided: Object.keys(candidateBrief) }, [
-                        'Pass ALL FOUR brief sections via --brief-what-happened / --brief-why-it-matters / --brief-what-learned / --brief-what-action.',
-                        'The CLI refuses to render a recommendation without a complete 4-section brief (spec §4.7 / RL-7).'
-                    ]), options.json);
-                    process.exitCode = 1;
-                    return;
-                }
-                throw err;
-            }
-            // Render the recommendation envelope up-front so the CLI can
-            // refuse to write if any brief section is missing. This is
-            // the same code path the crystallization service uses.
-            const recommendation = safeRenderRecommendationPayload({
-                brief,
-                bullets: options.briefBullet ?? [],
-                source_trace_pointers: options.sourceTrace ?? [],
-                evaluator_summary: {
-                    one_liner: options.evaluatorSummary ?? '',
-                    risk_tags: []
-                }
-            });
-            if (!recommendation.ok) {
-                printResult(io, fail('asset.crystallize', recommendation.code ?? 'MISSING_BRIEF_SECTION', 'recommendation envelope rejected — brief is missing one of its 4 sections', { findings: recommendation.findings, briefProvided: candidateBrief }, [
-                    'Pass ALL FOUR brief sections via the matching CLI flags.',
-                    'Counts in --brief-bullet may support the brief; they do NOT replace it (spec §4.7 / RL-7).'
-                ]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-            if (!existsSync(join(projectRoot, '.peaks'))) {
-                mkdirSync(join(projectRoot, '.peaks'), { recursive: true });
-            }
-            const db = openStateDb(join(projectRoot, '.peaks', 'state.db'));
-            try {
-                const svc = new CrystallizationService(db, {
-                    loopReleaseSchema: LoopReleaseSchema,
-                    loopBeeRelationSchema: LoopBeeRelationSchema,
-                    insertLoopRelease: insertLoopRelease,
-                    insertLoopBeeRelation: insertLoopBeeRelation
-                });
-                const result = svc.crystallize({
-                    task: {
-                        task_id: options.fromTask,
-                        task_status: 'completed',
-                        gates_passed: true,
-                        evidence_collected: true
-                    },
-                    loop_input: {
-                        id: options.loopId,
-                        name: options.loopName,
-                        scenario: options.loopScenario,
-                        trigger_policy: options.loopTriggerPolicy,
-                        success_criteria: options.loopSuccessCriterion,
-                        interaction_policy: options.loopInteractionPolicy,
-                        feedback_policy: options.loopFeedbackPolicy,
-                        evolution_policy: options.loopEvolutionPolicy,
-                        evaluator_policy: options.loopEvaluatorPolicy,
-                        linked_bees: [],
-                        run_history: [],
-                        crystallization_evidence: [],
-                        lifecycle_status: 'candidate',
-                        version: options.loopVersion
-                    },
-                    bee_input: {
-                        bee_name: options.beeName,
-                        version: options.beeVersion,
-                        description: options.beeDescription,
-                        ...(options.beeIntentRaw !== undefined
-                            ? { user_intent_raw: options.beeIntentRaw }
-                            : {}),
-                        ...(options.beeParentVersion !== undefined
-                            ? { parent_version: options.beeParentVersion }
-                            : {}),
-                        ...(options.beeChangelog !== undefined ? { changelog: options.beeChangelog } : {})
-                    },
-                    bee_relation_reason: options.beeRelationReason,
-                    evidence_brief: brief,
-                    evidence_bullets: options.briefBullet ?? [],
-                    source_trace_pointers: options.sourceTrace ?? [],
-                    ...(options.evaluatorSummary !== undefined
-                        ? { evaluator_summary: options.evaluatorSummary }
-                        : {}),
-                    ...(options.userDecisionSummary !== undefined
-                        ? { user_decision_summary: options.userDecisionSummary }
-                        : {}),
-                    trigger
-                });
-                printResult(io, ok('asset.crystallize', {
-                    recommendation: {
-                        brief: recommendation.payload.brief,
-                        bullets: recommendation.payload.bullets,
-                        source_trace_pointers: recommendation.payload.source_trace_pointers,
-                        evaluator_summary: recommendation.payload.evaluator_summary
-                    },
-                    result,
-                    nextActions: [
-                        `Run \`peaks loop show --loop ${result.loop_release_id}\` to inspect the new loop_release.`,
-                        `Run \`peaks asset dispose --crystallization-event ${result.crystallization_event_id} --mode trace_only\` to retire the event without touching the asset.`
-                    ]
-                }, [], [
-                    'The CLI has surfaced a complete 4-section brief; the LLM should now drive the user through AskUserQuestion picks (spec §5.3).'
-                ]), options.json);
-            }
-            finally {
-                db.close();
-            }
-        }
-        catch (err) {
-            if (err instanceof CrystallizationIntegrityError) {
-                const integrityErr = err;
-                printResult(io, fail('asset.crystallize', integrityErr.code, integrityErr.message, { findings: [...integrityErr.findings] }, [
-                    integrityErr.code === 'CRYSTALLIZATION_PRE_RUN'
-                        ? 'Re-shape the candidate task so task_status=completed AND gates_passed=true AND evidence_collected=true (spec §5 / RL-2).'
-                        : integrityErr.code === 'MISSING_BRIEF_SECTION'
-                            ? 'Pass ALL FOUR brief sections (RL-7); the CLI refuses to render a recommendation without them.'
-                            : 'Inspect the failure findings and re-shape the payload.'
-                ]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            if (err instanceof BriefSectionError) {
-                const briefErr = err;
-                printResult(io, fail('asset.crystallize', 'MISSING_BRIEF_SECTION', briefErr.message, { findings: [...briefErr.findings] }, ['Pass all 4 brief sections (RL-7).']), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            throw err;
-        }
-    });
-    // ---------- peaks asset dispose ----------
-    addJsonOption(asset
-        .command('dispose')
-        .description('M5: dispose a crystallization event. mode=trace_only retires the event but keeps the trace; mode=retain keeps both; mode=destroy retires the event and marks the created/updated assets retired.')
-        .requiredOption('--crystallization-event <id>', 'the crystallization event id (returned by `peaks asset crystallize`)')
-        .requiredOption(`--mode <mode>`, `dispose mode (one of: ${DISPOSE_MODES.join('|')}; default: trace_only)`, 'trace_only')
-        .option('--project <path>', 'project root (default: cwd)')).action((options) => {
-        try {
-            if (!DISPOSE_MODES.includes(options.mode)) {
-                printResult(io, fail('asset.dispose', 'ASSET_INVALID_MODE', `--mode must be one of: ${DISPOSE_MODES.join('|')}`, { mode: options.mode }, ['Pass --mode trace_only / retain / destroy.']), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            const mode = options.mode;
-            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-            if (!existsSync(join(projectRoot, '.peaks'))) {
-                mkdirSync(join(projectRoot, '.peaks'), { recursive: true });
-            }
-            const db = openStateDb(join(projectRoot, '.peaks', 'state.db'));
-            try {
-                const svc = new CrystallizationService(db, {
-                    loopReleaseSchema: LoopReleaseSchema,
-                    loopBeeRelationSchema: LoopBeeRelationSchema,
-                    insertLoopRelease: insertLoopRelease,
-                    insertLoopBeeRelation: insertLoopBeeRelation
-                });
-                const existing = svc.read(options.crystallizationEvent);
-                if (!existing) {
-                    printResult(io, fail('asset.dispose', 'ASSET_EVENT_NOT_FOUND', `crystallization event '${options.crystallizationEvent}' not found`, { eventId: options.crystallizationEvent }, ['Verify the event id.']), options.json);
-                    process.exitCode = 1;
-                    return;
-                }
-                // trace_only → retire the event row; the source traces are
-                // untouched (workflow traces are immutable per spec §4.3).
-                // retain → no DB change; the user wants to keep the event
-                // as historical evidence.
-                // destroy → retire the event + retire the created/updated
-                // assets (no asset delete; retirement only).
-                if (mode === 'retain') {
-                    printResult(io, ok('asset.dispose', {
-                        crystallization_event_id: existing.id,
-                        mode,
-                        lifecycle_status: existing.lifecycle_status,
-                        note: 'no DB change; event retained as-is'
-                    }, [], [
-                        'Run `peaks asset status --loop <id>` to inspect the lifecycle state of the linked assets.'
-                    ]), options.json);
-                    return;
-                }
-                const updated = svc.updateStatus(existing.id, 'retired');
-                if (mode === 'destroy' && updated) {
-                    // Retire the created/updated loop_release rows as well.
-                    // We do NOT delete rows — retirement is a status flip
-                    // (spec §5.6).
-                    const retireLoop = db.prepare("UPDATE loop_release SET lifecycle_status = 'retired' WHERE id IN (?, ?)");
-                    const ids = [
-                        updated.created_loop_release_id ?? null,
-                        updated.updated_loop_release_id ?? null
-                    ].filter((x) => x !== null);
-                    for (const id of ids) {
-                        retireLoop.run(id, id);
-                    }
-                }
-                printResult(io, ok('asset.dispose', {
-                    crystallization_event_id: existing.id,
-                    mode,
-                    lifecycle_status: updated?.lifecycle_status ?? 'retired',
-                    retired_assets: mode === 'destroy' ? 'loop_release retired (no rows deleted)' : 'none',
-                    nextActions: ['Run `peaks asset status` to confirm the lifecycle transition.']
-                }, [], []), options.json);
-            }
-            finally {
-                db.close();
-            }
-        }
-        catch (err) {
-            printResult(io, fail('asset.dispose', 'ASSET_DISPOSE_FAILED', getErrorMessage(err), { eventId: options.crystallizationEvent }, ['Verify the event id and --mode flag.']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // ---------- peaks asset status ----------
-    addJsonOption(asset
-        .command('status')
-        .description('M5: list loop + bee lifecycle state. With --loop, returns the loop + all linked bee_releases + all crystallization events referencing them.')
-        .option('--loop <id>', 'filter by loop_release id')
-        .option('--bee <name>', 'filter by bee_name')
-        .option('--project <path>', 'project root (default: cwd)')).action((options) => {
-        try {
-            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-            if (!existsSync(join(projectRoot, '.peaks'))) {
-                mkdirSync(join(projectRoot, '.peaks'), { recursive: true });
-            }
-            const db = openStateDb(join(projectRoot, '.peaks', 'state.db'));
-            try {
-                const svc = new CrystallizationService(db, {
-                    loopReleaseSchema: LoopReleaseSchema,
-                    loopBeeRelationSchema: LoopBeeRelationSchema,
-                    insertLoopRelease: insertLoopRelease,
-                    insertLoopBeeRelation: insertLoopBeeRelation
-                });
-                let events = [];
-                if (options.loop) {
-                    events = [
-                        ...svc.list({ created_loop_release_id: options.loop }),
-                        ...svc.list({ updated_loop_release_id: options.loop })
-                    ];
-                    // Deduplicate by id.
-                    const seen = new Set();
-                    events = events.filter((e) => {
-                        const key = e?.id ?? '';
-                        if (!key || seen.has(key))
-                            return false;
-                        seen.add(key);
-                        return true;
-                    });
-                }
-                else {
-                    events = svc.list();
-                }
-                // Companion queries: loop lifecycle counts + bee lifecycle
-                // counts. We compute from the DB so the CLI is the single
-                // source of truth.
-                const loopCounts = db
-                    .prepare('SELECT lifecycle_status, COUNT(*) AS n FROM loop_release GROUP BY lifecycle_status')
-                    .all().reduce((acc, r) => {
-                    acc[r.lifecycle_status] = r.n;
-                    return acc;
-                }, {});
-                const beeCounts = db
-                    .prepare('SELECT bee_name, COUNT(*) AS n FROM bee_release GROUP BY bee_name ORDER BY bee_name ASC')
-                    .all().filter((r) => options.bee === undefined || r.bee_name === options.bee);
-                printResult(io, ok('asset.status', {
-                    filters: {
-                        ...(options.loop !== undefined ? { loop: options.loop } : {}),
-                        ...(options.bee !== undefined ? { bee: options.bee } : {})
-                    },
-                    crystallization_events: events.length,
-                    events: events.map((e) => ({
-                        id: e?.id,
-                        trigger: e?.trigger,
-                        lifecycle_status: e?.lifecycle_status,
-                        created_loop_release_id: e?.created_loop_release_id,
-                        created_bee_release_id: e?.created_bee_release_id,
-                        updated_loop_release_id: e?.updated_loop_release_id,
-                        updated_bee_release_id: e?.updated_bee_release_id,
-                        created_at: e?.created_at
-                    })),
-                    loop_release_counts_by_lifecycle: loopCounts,
-                    bee_release_counts_by_name: beeCounts,
-                    nextActions: [
-                        options.loop
-                            ? `Run \`peaks loop show --loop ${options.loop}\` for the loop detail view.`
-                            : "Pass --loop <id> to drill into a specific loop's crystallization history."
-                    ]
-                }, [], []), options.json);
-            }
-            finally {
-                db.close();
-            }
-        }
-        catch (err) {
-            printResult(io, fail('asset.status', 'ASSET_STATUS_FAILED', getErrorMessage(err), { loop: options.loop, bee: options.bee }, ['Verify the loop / bee identifiers.']), options.json);
-            process.exitCode = 1;
-        }
-    });
+    registerAssetCrystallizeCommand(asset, io);
+    registerAssetDisposeCommand(asset, io);
+    registerAssetStatusCommand(asset, io);
 }

package/dist/cli/commands/asset-crystallize-command.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerAssetCrystallizeCommand(asset: Command, io: ProgramIO): void;

package/dist/cli/commands/asset-crystallize-command.js

@@ -0,0 +1,60 @@
+// src/cli/commands/asset-crystallize-command.ts
+//
+// The commander registration for `peaks asset crystallize` — the parent
+// command, its 28 options in their original order, and the action binding.
+// Split out of `asset-commands.ts`; the verb name, every option's flag and
+// description, and the envelope shape are unchanged. The action body lives in
+// `asset-crystallize-runner.ts` and the payload builders in
+// `asset-crystallize-payload.ts`.
+import { CRYSTALLIZATION_TRIGGERS } from '../../services/crystallization/index.js';
+import { addJsonOption } from '../cli-helpers.js';
+import { collectRepeatable } from './asset-command-shared.js';
+import { runAssetCrystallize } from './asset-crystallize-runner.js';
+const CRYSTALLIZE_DESCRIPTION = 'M5: persist a new loop_release + main_bee_release + loop_bee_relation + crystallization_event in a single transaction. Enforces the pre-run gate (task_status=completed AND gates_passed=true AND evidence_collected=true; AC-4 / RL-2) and the brief-section guard (all 4 sections required; AC-15 / RL-7).';
+/** `--from-task` … `--loop-version`: the task + loop_release half. */
+function addLoopPolicyOptions(cmd) {
+    return cmd
+        .requiredOption('--from-task <id>', "the candidate task id (must be 'completed' with gates_passed + evidence_collected)")
+        .requiredOption('--loop-id <id>', 'kebab-case loop id, e.g. loop-onboarding-research')
+        .requiredOption('--loop-name <name>', 'NL display name')
+        .requiredOption('--loop-scenario <text>', 'long-form scenario text (what real problem the loop solves)')
+        .requiredOption('--loop-trigger-policy <text>', 'trigger policy (NL intent match)')
+        .requiredOption('--loop-interaction-policy <text>', 'interaction policy (Human-NL-Choice-Only is the default)')
+        .requiredOption('--loop-feedback-policy <text>', 'feedback policy (what feedback enters long-term memory)')
+        .requiredOption('--loop-evolution-policy <text>', 'evolution policy (Darwin-style ratchet rules)')
+        .requiredOption('--loop-success-criterion <text>', 'declarative success criterion (repeatable)', collectRepeatable, [])
+        .requiredOption('--loop-evaluator-policy <text>', 'evaluator policy line (repeatable)', collectRepeatable, [])
+        .requiredOption('--loop-version <semver>', 'loop version (e.g. 0.1.0)');
+}
+/** `--bee-name` … `--brief-what-action`: the main bee and the 4 brief sections. */
+function addBeeAndBriefOptions(cmd) {
+    return cmd
+        .requiredOption('--bee-name <name>', 'main bee name (kebab-case)')
+        .requiredOption('--bee-version <semver>', 'bee version (e.g. 0.1.0)')
+        .requiredOption('--bee-description <text>', 'main bee description (manifest-level)')
+        .requiredOption('--bee-relation-reason <text>', 'NL reason for the main bee relation')
+        .requiredOption('--brief-what-happened <text>', 'brief section: what_happened (1-2 sentence factual account)')
+        .requiredOption('--brief-why-it-matters <text>', 'brief section: why_it_matters (1-2 sentence explanation)')
+        .requiredOption('--brief-what-learned <text>', 'brief section: what_learned (1-2 sentence learning)')
+        .requiredOption('--brief-what-action <text>', 'brief section: what_action (1 sentence recommended action)');
+}
+/** `--brief-bullet` … `--project`: the repeatable extras and the trigger. */
+function addCrystallizeExtras(cmd) {
+    return cmd
+        .option('--brief-bullet <bullet>', 'structured bullet supporting the brief (repeatable)', collectRepeatable, [])
+        .option('--source-trace <id>', 'workflow trace id backing the brief (repeatable)', collectRepeatable, [])
+        .option('--evaluator-summary <text>', 'evaluator one-liner (independent scorers)', '')
+        .option('--user-decision-summary <text>', 'user decision summary (NL)', '')
+        .option('--bee-intent-raw <text>', 'optional bee user_intent_raw')
+        .option('--bee-parent-version <semver>', 'optional parent_version')
+        .option('--bee-changelog <text>', 'optional changelog')
+        .option('--trigger <name>', `crystallization trigger (one of: ${CRYSTALLIZATION_TRIGGERS.join('|')})`, 'user_explicit')
+        .option('--project <path>', 'project root (default: cwd)');
+}
+export function registerAssetCrystallizeCommand(asset, io) {
+    const cmd = asset.command('crystallize').description(CRYSTALLIZE_DESCRIPTION);
+    addLoopPolicyOptions(cmd);
+    addBeeAndBriefOptions(cmd);
+    addCrystallizeExtras(cmd);
+    addJsonOption(cmd).action((options) => runAssetCrystallize(io, options));
+}