peaks-loop 4.0.0-beta.8 → 4.0.1

package/dist/cli/commands/_register.js

@@ -0,0 +1,139 @@
+import { registerAdapterCommands } from './adapter-commands.js';
+import { registerAdapterS2ACommands } from './adapter-commands-s2a.js';
+import { registerAssetCommands } from './asset-commands.js';
+import { registerAuditCommands } from './audit-commands.js';
+import { registerBeeCommands } from './bee-commands.js';
+import { registerCapabilityWorkerConfigAndSCCommands } from './capability-worker-config-sc-commands.js';
+import { registerCodeCommands } from './code-commands.js';
+import { registerDashboardCommands } from './dashboard-commands.js';
+import { registerCodeReviewCommands } from './code-review-commands.js';
+import { registerCodegraphCommands } from './codegraph-commands.js';
+import { registerCompactCommands } from './compact-command.js';
+import { registerComplexityCommands } from './complexity-commands.js';
+import { registerContextCommands } from './context-commands.js';
+import { registerCoreAndArtifactCommands } from './core-artifact-commands.js';
+import { registerDocCommands } from './doc-commands.js';
+import { registerEccCommands } from './ecc-commands.js';
+import { registerEvolutionCommands } from './evolution-commands.js';
+import { registerFeedbackCommands } from './feedback-commands.js';
+import { registerFinalReviewCommands } from './final-review-commands.js';
+import { registerFixtureCommands } from './fixture-commands.js';
+import { registerForkCommands } from './fork-commands.js';
+import { registerGateCommands } from './gate-commands.js';
+import { registerClassifyCommands, registerContractCommands } from './governance-classify-contract-commands.js';
+import { registerHookHandleCommand } from './hook-handle.js';
+import { registerHeartbeatCommand as registerHeartbeatCommands } from './heartbeat-commands.js';
+import { registerHooksCommands } from './hooks-commands.js';
+import { registerIdeCommands } from './ide-commands.js';
+import { registerImpactCommands } from './impact-commands.js';
+import { registerJobCommands } from './job-commands.js';
+import { registerLegacyCommands } from './legacy-commands.js';
+import { registerLogCommands } from './log-commands.js';
+import { registerLoopCommands } from './loop-commands.js';
+import { registerWorkflowEvalCommands } from './loop-eval-commands.js';
+import { registerMutCommands } from './mut-commands.js';
+import { registerObservabilityCommands } from './observability-commands.js';
+import { registerOpenSpecCommands } from './openspec-commands.js';
+import { registerPerfAuditCommands } from './perf-audit-commands.js';
+import { registerPerfCommands } from './perf-commands.js';
+import { registerPlaywrightCommands } from './playwright-commands.js';
+import { registerPolyrepoCommands } from './polyrepo-commands.js';
+import { registerPrdBlocksCommands } from './prd-blocks-commands.js';
+import { registerPrdCommands } from './prd-commands.js';
+import { registerPreferencesCommands } from './preferences-commands.js';
+import { registerProjectCommands } from './project-commands.js';
+import { registerChangesetCommands } from './changeset-commands.js';
+import { registerQaBusinessReviewCommands } from './qa-business-review-commands.js';
+import { registerQaCommands } from './qa-commands.js';
+import { registerReleaseCommands } from './release-commands.js';
+import { registerRequestCommands } from './request-commands.js';
+import { registerRetrospectiveCommands } from './retrospective-commands.js';
+import { registerReviewerCommands } from './reviewer-commands.js';
+import { registerRoleCommands } from './role-commands.js';
+import { registerRuntimeCommands } from './runtime-commands.js';
+import { registerScanCommands } from './scan-commands.js';
+import { registerSecurityAuditCommands } from './security-audit-commands.js';
+import { registerSedimentCommands } from './sediment-commands.js';
+import { registerSkillConformanceCommands } from './skill-conformance-commands.js';
+import { registerSkillLoopEngineeringReadinessCommands } from './skill-loop-engineering-readiness-commands.js';
+import { registerSliceCommands } from './slice-commands.js';
+import { registerSliceIntegrateCommands } from './slice-integrate-commands.js';
+import { registerSliceReviewCommands } from './slice-review-commands.js';
+import { registerSmokeCommands } from './smoke-commands.js';
+import { registerSopCommands } from './sop-commands.js';
+import { registerStatusLineCommands } from './statusline-commands.js';
+import { registerSpillDemoCommand } from './spill-demo-command.js';
+import { registerSubAgentCommands } from './sub-agent-commands.js';
+import { registerSubAgentDispatchGuard } from './sub-agent-dispatch-guard.js';
+import { registerTestCommands } from './test-commands.js';
+import { registerUnderstandCommands } from './understand-commands.js';
+import { registerUpgradeCommands } from './upgrade-commands.js';
+import { registerUserTouchpointCommands } from './user-touchpoint-commands.js';
+import { registerVerdictAggregateCommands } from './verdict-aggregate-command.js';
+import { registerWorkflowCommands } from './workflow-commands.js';
+import { registerWorkflowPlanCommands } from './workflow-plan-commands.js';
+import { registerWorktreeAuthCommand } from './worktree-auth-commands.js';
+import { registerWorkspaceCommands } from './workspace-commands.js';
+const NON_AUTO = new Set([
+    'core-artifact-commands', 'capability-worker-config-sc-commands',
+    'sub-agent-commands', 'workspace-commands', 'workflow-commands',
+    'sop-commands', 'skill-visibility',
+]);
+const REGISTRATIONS = [
+    ['core-artifact-commands', registerCoreAndArtifactCommands],
+    ['workflow-commands', registerWorkflowCommands],
+    ['capability-worker-config-sc-commands', registerCapabilityWorkerConfigAndSCCommands],
+    ['codegraph-commands', registerCodegraphCommands], ['openspec-commands', registerOpenSpecCommands],
+    ['perf-commands', registerPerfCommands], ['preferences-commands', registerPreferencesCommands],
+    ['project-commands', registerProjectCommands], ['prd-commands', registerPrdCommands],
+    ['request-commands', registerRequestCommands], ['retrospective-commands', registerRetrospectiveCommands],
+    ['scan-commands', registerScanCommands], ['slice-commands', registerSliceCommands],
+    ['sop-commands', registerSopCommands], ['feedback-commands', registerFeedbackCommands],
+    ['fork-commands', registerForkCommands], ['impact-commands', registerImpactCommands],
+    ['smoke-commands', registerSmokeCommands], ['release-commands', registerReleaseCommands],
+    ['changeset-commands', registerChangesetCommands],
+    ['prd-blocks-commands', registerPrdBlocksCommands], ['user-touchpoint-commands', registerUserTouchpointCommands],
+    ['slice-review-commands', registerSliceReviewCommands], ['qa-business-review-commands', registerQaBusinessReviewCommands],
+    ['slice-integrate-commands', registerSliceIntegrateCommands], ['doc-commands', registerDocCommands],
+    ['legacy-commands', registerLegacyCommands], ['role-commands', registerRoleCommands],
+    ['complexity-commands', registerComplexityCommands], ['sub-agent-commands', registerSubAgentCommands],
+    ['governance-classify-contract-commands', registerContractCommands],
+    ['sub-agent-dispatch-guard', registerSubAgentDispatchGuard], ['gate-commands', registerGateCommands],
+    ['hook-handle', registerHookHandleCommand], ['hooks-commands', registerHooksCommands],
+    ['heartbeat-commands', registerHeartbeatCommands], ['statusline-commands', registerStatusLineCommands], ['understand-commands', registerUnderstandCommands],
+    ['workspace-commands', registerWorkspaceCommands], ['workflow-plan-commands', registerWorkflowPlanCommands],
+    ['audit-commands', registerAuditCommands], ['final-review-commands', registerFinalReviewCommands],
+    ['governance-classify-contract-commands', registerClassifyCommands], ['context-commands', registerContextCommands],
+    ['skill-conformance-commands', registerSkillConformanceCommands],
+    ['skill-loop-engineering-readiness-commands', registerSkillLoopEngineeringReadinessCommands],
+    ['loop-commands', registerLoopCommands], ['loop-eval-commands', registerWorkflowEvalCommands],
+    ['evolution-commands', registerEvolutionCommands], ['asset-commands', registerAssetCommands],
+    ['bee-commands', registerBeeCommands], ['ecc-commands', registerEccCommands],
+    ['upgrade-commands', registerUpgradeCommands], ['code-review-commands', registerCodeReviewCommands],
+    ['security-audit-commands', registerSecurityAuditCommands], ['perf-audit-commands', registerPerfAuditCommands],
+    ['verdict-aggregate-command', registerVerdictAggregateCommands], ['log-commands', registerLogCommands],
+    ['qa-commands', registerQaCommands], ['test-commands', registerTestCommands],
+    ['playwright-commands', registerPlaywrightCommands], ['code-commands', registerCodeCommands], ['dashboard-commands', registerDashboardCommands],
+    ['mut-commands', registerMutCommands], ['fixture-commands', registerFixtureCommands],
+    ['reviewer-commands', registerReviewerCommands], ['ide-commands', registerIdeCommands],
+    ['observability-commands', registerObservabilityCommands], ['compact-command', registerCompactCommands],
+    ['job-commands', registerJobCommands], ['sediment-commands', registerSedimentCommands],
+    ['adapter-commands', registerAdapterCommands], ['runtime-commands', registerRuntimeCommands],
+    ['adapter-commands-s2a', registerAdapterS2ACommands], ['polyrepo-commands', registerPolyrepoCommands],
+    ['worktree-auth-commands', registerWorktreeAuthCommand],
+    ['session-spill-demo', registerSpillDemoCommand],
+];
+function dispatchRegister(register, program, io) {
+    if (register.length <= 1) {
+        register(program);
+    }
+    else {
+        register(program, io);
+    }
+}
+export function autoRegisterAllCommands(program, io) {
+    for (const [moduleName, register] of REGISTRATIONS) {
+        if (!NON_AUTO.has(moduleName))
+            dispatchRegister(register, program, io);
+    }
+}

package/dist/cli/commands/_super.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from 'commander';
+import type { ProgramIO } from '../cli-helpers.js';
+export interface SuperRouteData {
+    routedSkill: string;
+    confidence: number;
+    alternatives: string[];
+    rationale: string;
+    nextActions: string[];
+}
+export declare function registerSuperCommands(program: Command, io: ProgramIO): void;

package/dist/cli/commands/_super.js

@@ -0,0 +1,97 @@
+const ROUTES = {
+    make: [
+        { skill: 'peaks-code', words: ['code', 'implement', 'refactor', 'cli', 'bug', 'feature'] },
+        { skill: 'peaks-content', words: ['blog', 'article', 'post', 'newsletter', 'copy'] },
+        { skill: 'peaks-doctor', words: ['audit', 'health', 'doctor', 'project health'] },
+        { skill: 'peaks-issue-fix-orchestrator', words: ['fix issues', 'open issues', 'issue sweep'] }
+    ],
+    learn: [
+        { skill: 'peaks-sop', words: ['sop', 'procedure', 'checklist', 'runbook'] },
+        { skill: 'peaks-solo sediment', words: ['lesson', 'memory', 'sediment', 'learn from'] }
+    ],
+    check: [
+        { skill: 'peaks-audit', words: ['red-lines', 'red lines', 'audit'] },
+        { skill: 'peaks-doctor', words: ['doctor', 'health', 'health check'] },
+        { skill: 'peaks-security-audit', words: ['security', 'vulnerability', 'vuln', 'secret'] }
+    ],
+    run: [
+        { skill: 'peaks-workflow', words: ['workflow', 'pipeline', 'flow'] },
+        { skill: 'peaks-job', words: ['job', 'slice', 'batch'] },
+        { skill: 'peaks-dispatch', words: ['dispatch', 'sub-agent', 'sub agent', 'agent'] }
+    ]
+};
+function envelope(command, data) {
+    return JSON.stringify({ ok: true, data, warnings: [], nextActions: data.nextActions });
+}
+function route(command, input) {
+    const normalized = input.trim().toLowerCase();
+    const candidates = ROUTES[command] ?? [];
+    const selected = candidates.find((candidate) => candidate.words.some((word) => normalized.includes(word)));
+    const chosen = selected ?? candidates[0];
+    if (chosen === undefined) {
+        return {
+            routedSkill: 'peaks-solo',
+            confidence: 0,
+            alternatives: [],
+            rationale: 'No route candidates are configured',
+            nextActions: ['LLM: dispatch peaks-solo with this goal']
+        };
+    }
+    const alternatives = candidates.filter((candidate) => candidate !== chosen).map((candidate) => candidate.skill);
+    const confidence = selected === undefined ? 0.25 : 0.92;
+    const rationale = selected === undefined
+        ? 'No route keyword matched; default candidate selected for LLM arbitration'
+        : `Natural-language ${command} intent matches the ${chosen.skill} route`;
+    return {
+        routedSkill: chosen.skill,
+        confidence,
+        alternatives,
+        rationale,
+        nextActions: [`LLM: dispatch ${chosen.skill} sub-agent with this goal`]
+    };
+}
+function registerRouted(program, io, name, argument) {
+    program.command(`${name} <${argument}>`).description(`Route a natural-language ${argument} to the appropriate Peaks skill`).action((value) => {
+        const input = value.trim();
+        if (!input) {
+            io.stdout(JSON.stringify({ ok: false, command: `super.${name}`, code: 'MISSING_ARG', message: `${argument} must not be blank`, data: {}, warnings: [], nextActions: [] }));
+            process.exitCode = 1;
+            return;
+        }
+        const data = route(name, input);
+        io.stdout(envelope(`super.${name}`, data));
+    });
+}
+function registerFixed(program, io, name, skill, description) {
+    program.command(name).description(description).action(() => {
+        const data = {
+            routedSkill: skill,
+            confidence: 1,
+            alternatives: [],
+            rationale: `Fixed operator handoff for ${skill}`,
+            nextActions: [`LLM: dispatch ${skill} sub-agent`]
+        };
+        io.stdout(envelope(`super.${name}`, data));
+    });
+}
+function registerAsk(program, io) {
+    program.command('ask <question>').description('Route a free-form question to the Peaks solo dispatcher').action((question) => {
+        const input = question.trim();
+        if (!input) {
+            io.stdout(JSON.stringify({ ok: false, command: 'super.ask', code: 'MISSING_ARG', message: 'question must not be blank', data: {}, warnings: [], nextActions: [] }));
+            process.exitCode = 1;
+            return;
+        }
+        io.stdout(envelope('super.ask', { routedSkill: 'peaks-solo', confidence: 1, alternatives: [], rationale: 'Free-form question delegated to the Peaks solo dispatcher', nextActions: ['LLM: dispatch peaks-solo with this question'] }));
+    });
+}
+export function registerSuperCommands(program, io) {
+    registerRouted(program, io, 'make', 'goal');
+    registerRouted(program, io, 'learn', 'kind');
+    registerRouted(program, io, 'check', 'target');
+    registerRouted(program, io, 'run', 'workflow');
+    registerFixed(program, io, 'share', 'peaks-sub-agent-share', 'Hand off a sharing operation');
+    registerFixed(program, io, 'version', 'peaks-version', 'Return the current Peaks version');
+    registerAsk(program, io);
+    registerFixed(program, io, 'status', 'peaks-status', 'Show current Peaks workflow status');
+}

package/dist/cli/commands/adapter-commands-s2a.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `peaks adapter *` — vendor adapter registry CLI surface.
+ *
+ * Slice S2-a of RD-2 (2026-07-08 session). Two subcommands:
+ *
+ *   list     — list registered user adapters (persisted at
+ *              `.peaks/runtime/adapters.json`).
+ *   register — register a new adapter. Vendor verb strings live in
+ *              the binary the user picks, NOT in peaks-loop source.
+ *
+ * This file coexists with the older `adapter-commands.ts` (slice
+ * 2026-07-04-cli-15a) which exposes `peaks skill adapter <verb>` —
+ * a different surface for skill materialization (resolveScratchDir /
+ * materialize / publish). The two surfaces do NOT collide because
+ * one is `peaks skill adapter` and the other is `peaks adapter`.
+ */
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export interface AdapterListOptions {
+    json?: boolean;
+    project?: string;
+}
+export interface AdapterRegisterOptions {
+    json?: boolean;
+    id?: string;
+    /** Display name override (defaults to the id). */
+    name?: string;
+    binary?: string;
+    /** Repeated --arg values. */
+    arg?: string[];
+    force?: boolean;
+    project?: string;
+}
+export declare function registerAdapterS2ACommands(program: Command, io: ProgramIO): void;

package/dist/cli/commands/adapter-commands-s2a.js

@@ -0,0 +1,92 @@
+import { existsSync } from 'node:fs';
+import { addJsonOption, printResult } from '../cli-helpers.js';
+import { fail, ok, getErrorMessage } from 'peaks-loop-shared/result';
+import { AdapterRegistry } from '../../services/adapter/adapter-registry.js';
+import { registryFileFor } from './runtime-commands.js';
+function resolveProjectRoot(explicit) {
+    if (explicit !== undefined && explicit.length > 0)
+        return explicit;
+    return process.cwd();
+}
+export function registerAdapterS2ACommands(program, io) {
+    const adapter = program
+        .command('adapter')
+        .description('Vendor adapter registry (user-registered, persisted to .peaks/runtime/adapters.json)');
+    // -----------------------------------------------------------------
+    // 1. peaks adapter list [--json] [--project <root>]
+    // -----------------------------------------------------------------
+    addJsonOption(adapter
+        .command('list')
+        .description('List user-registered vendor adapters')
+        .option('--project <path>', 'project root (defaults to cwd)')).action((options) => {
+        try {
+            const projectRoot = resolveProjectRoot(options.project);
+            const file = registryFileFor(projectRoot);
+            const reg = new AdapterRegistry();
+            if (existsSync(file))
+                reg.load(file);
+            const records = reg.list();
+            printResult(io, ok('adapter.list', { projectRoot, file, records, count: records.length }, [], [
+                records.length === 0
+                    ? 'No adapters registered yet. Run `peaks adapter register --id <vendor> --binary <cmd>` to add one.'
+                    : `Run \`peaks runtime compact --via <id>\` to invoke a registered adapter.`
+            ]), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('adapter.list', 'ADAPTER_LIST_FAILED', getErrorMessage(error), {}, []), options.json);
+            process.exitCode = 1;
+        }
+    });
+    // -----------------------------------------------------------------
+    // 2. peaks adapter register --id <id> --binary <cmd> [--arg <a>]... [--force]
+    // -----------------------------------------------------------------
+    addJsonOption(adapter
+        .command('register')
+        .description('Register a new vendor adapter; persists to .peaks/runtime/adapters.json')
+        .requiredOption('--id <id>', 'vendor adapter id (lowercase, e.g. my-cli)')
+        .option('--name <name>', 'human-readable display name (defaults to <id>)')
+        .requiredOption('--binary <cmd>', 'binary name to invoke for compact (e.g. my-cli)')
+        .option('--arg <value>', 'extra arg appended before --force (repeatable)', (value, previous = []) => [...previous, value])
+        .option('--force', 'overwrite an existing adapter with the same id')
+        .option('--project <path>', 'project root (defaults to cwd)')).action((options) => {
+        try {
+            const projectRoot = resolveProjectRoot(options.project);
+            const file = registryFileFor(projectRoot);
+            const reg = new AdapterRegistry();
+            if (existsSync(file))
+                reg.load(file);
+            const id = options.id ?? '';
+            const record = options.arg !== undefined
+                ? { id, displayName: options.name ?? id, binary: options.binary ?? '', args: options.arg }
+                : { id, displayName: options.name ?? id, binary: options.binary ?? '' };
+            let result;
+            try {
+                result = reg.register(record, { force: options.force === true });
+            }
+            catch (validationError) {
+                printResult(io, fail('adapter.register', 'INVALID_ADAPTER_RECORD', getErrorMessage(validationError), { id }, [
+                    'Use --id with /^[a-z0-9][a-z0-9._-]*$/, --binary as a binary name (no path separators).'
+                ]), options.json);
+                process.exitCode = 1;
+                return;
+            }
+            reg.persist(file);
+            const warnings = [];
+            if (!result.created && options.force !== true) {
+                warnings.push(`adapter "${id}" already registered; pass --force to overwrite`);
+            }
+            printResult(io, ok('adapter.register', {
+                projectRoot,
+                file,
+                adapter: result.record,
+                created: result.created
+            }, warnings, [
+                `Run \`peaks runtime compact --via ${id}\` to invoke it.`
+            ]), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('adapter.register', 'ADAPTER_REGISTER_FAILED', getErrorMessage(error), {}, []), options.json);
+            process.exitCode = 1;
+        }
+    });
+}

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

@@ -0,0 +1,30 @@
+/**
+ * `peaks skill adapter <verb>` — adapter selection + detection CLI.
+ *
+ * Slice 2026-07-04-cli-15a (Task 15a of the 18-verb plan). Two verbs:
+ *
+ *   list        — return the known adapter id list
+ *   set-active  — record which adapter is currently active
+ *
+ * Unknown verbs return an empty result so program.ts can render a
+ * NOT_FOUND envelope without throwing.
+ */
+import type { Command } from "commander";
+import type { ProgramIO } from "../cli-helpers.js";
+export interface AdapterResult {
+    adapters?: string[];
+    active?: string;
+}
+/** Dispatch an adapter verb. `home` is accepted for API symmetry
+ *  with runSediment, but the in-scope verbs don't read from disk yet. */
+export declare function runAdapter(argv: string[], { home: _home }: {
+    home: string;
+}): Promise<AdapterResult>;
+/** Register the `peaks skill adapter <verb>` subcommand group.
+ *
+ *  Matches the pattern used by sediment-commands.ts: the `skill`
+ *  parent command is reused when present, created lazily otherwise.
+ *  See src/cli/commands/workflow-plan-commands.ts:179 for the
+ *  precedent.
+ */
+export declare function registerAdapterCommands(program: Command, io: ProgramIO): void;

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

@@ -0,0 +1,35 @@
+/** Dispatch an adapter verb. `home` is accepted for API symmetry
+ *  with runSediment, but the in-scope verbs don't read from disk yet. */
+export async function runAdapter(argv, { home: _home }) {
+    const verb = argv[0];
+    if (verb === "list") {
+        return { adapters: ["claude", "codex", "copilot"] };
+    }
+    if (verb === "set-active") {
+        const name = argv[1];
+        if (name === undefined)
+            return {};
+        return { active: name };
+    }
+    return {};
+}
+/** Register the `peaks skill adapter <verb>` subcommand group.
+ *
+ *  Matches the pattern used by sediment-commands.ts: the `skill`
+ *  parent command is reused when present, created lazily otherwise.
+ *  See src/cli/commands/workflow-plan-commands.ts:179 for the
+ *  precedent.
+ */
+export function registerAdapterCommands(program, io) {
+    const existingSkill = program.commands.find((c) => c.name() === "skill");
+    const skill = existingSkill ??
+        program.command("skill").description("Manage Peaks skills");
+    skill
+        .command("adapter <args...>")
+        .description("Adapter selection and detection")
+        .action(async (args) => {
+        const home = process.env.HOME ?? process.env.USERPROFILE ?? process.cwd();
+        const r = await runAdapter(args, { home });
+        io.stdout(JSON.stringify(r));
+    });
+}

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

@@ -0,0 +1,45 @@
+/**
+ * peaks asset * CLI — M5 / spec §5 / §7.4
+ *
+ * Adds the umbrella verbs for the post-run crystallization flow:
+ *
+ *   peaks asset crystallize --from-task <id> --loop-name <name> \
+ *     --loop-scenario <text> --bee-name <name> \
+ *     --bee-version <semver> --bee-description <text> \
+ *     --brief-what-happened <text> --brief-why-it-matters <text> \
+ *     --brief-what-learned <text> --brief-what-action <text> \
+ *     [--bee-relation-reason <text>] [--brief-bullet <bullet>]... \
+ *     [--source-trace <id>]... [--evaluator-summary <text>] \
+ *     [--user-decision-summary <text>] \
+ *     [--trigger <user_explicit|llm_suggested|success_default_prompt|similar_task_recurrence>] \
+ *     [--project <root>] [--json]
+ *   peaks asset dispose --crystallization-event <id> --mode <trace_only|retain|destroy> \
+ *     [--project <root>] [--json]
+ *   peaks asset status [--loop <id>] [--bee <name>] [--project <root>] [--json]
+ *
+ * The crystallize verb prints the 4-section brief in the
+ * user-facing recommendation; refuses to proceed if any brief
+ * section is missing (EvidenceBriefSchema.refine guard +
+ * CrystallizationService pre-run gate).
+ *
+ * The dispose verb handles trace-only / retain / destroy. trace_only
+ * retires the crystallization event but keeps the source trace;
+ * retain is a no-op on the asset (the user wants to keep it as
+ * evidence); destroy hard-retires both the event and (if the
+ * user opts in) the created/updated assets. The CLI defaults to
+ * trace-only disposal for safety.
+ *
+ * The status verb lists loop + bee lifecycle state plus any
+ * crystallization events that reference them.
+ *
+ * Each verb prints a structured JSON envelope (`printResult` with
+ * `asJson=true`). The user never types a JSON manifest / form
+ * field; the LLM runs the CLI on the user's behalf.
+ *
+ * Defense in depth: the CrystallizationService enforces the
+ * pre-run gate and the brief-section guard; the CLI only
+ * translates flags into the service payload.
+ */
+import { Command } from "commander";
+import { type ProgramIO } from "../cli-helpers.js";
+export declare function registerAssetCommands(program: Command, io: ProgramIO): void;