peaks-cli 1.4.1 → 2.0.0

package/dist/src/cli/commands/retrospective-commands.js

@@ -3,8 +3,50 @@ import { resolveCanonicalProjectRoot } from '../../services/config/config-servic
 import { loadRetrospectiveIndex } from '../../services/retrospective/retrospective-index.js';
 import { showRetrospective } from '../../services/retrospective/retrospective-show.js';
 import { migrateRetrospectiveFromMd } from '../../services/retrospective/migrate-from-md.js';
+import { searchRetrospective } from '../../services/retrospective/retrospective-search-service.js';
 import { fail, ok } from '../../shared/result.js';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+const VALID_RETRO_TYPES = ['refactor', 'feature', 'bugfix', 'config', 'docs', 'chore'];
+const VALID_RETRO_OUTCOMES = ['shipped', 'blocked', 'in-flight', 'cancelled'];
+export function runRetrospectiveSearch(io, options) {
+    const projectRoot = options.project !== undefined
+        ? resolveCanonicalProjectRoot(options.project)
+        : (findProjectRoot(process.cwd()) ?? process.cwd());
+    const typeFilter = options.type !== undefined && VALID_RETRO_TYPES.includes(options.type)
+        ? options.type
+        : undefined;
+    const outcomeFilter = options.outcome !== undefined && VALID_RETRO_OUTCOMES.includes(options.outcome)
+        ? options.outcome
+        : undefined;
+    try {
+        const matches = searchRetrospective({
+            query: options.query,
+            projectRoot,
+            ...(typeFilter !== undefined ? { type: typeFilter } : {}),
+            ...(outcomeFilter !== undefined ? { outcome: outcomeFilter } : {}),
+            ...(options.limit !== undefined ? { limit: options.limit } : {}),
+        });
+        printResult(io, ok('retrospective.search', {
+            query: options.query,
+            total: matches.length,
+            matches,
+            warnings: [],
+        }, []), options.json);
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        const code = error.code ?? 'RETROSPECTIVE_SEARCH_FAILED';
+        const suggestions = [];
+        if (code === 'INDEX_MISSING') {
+            suggestions.push('Run `peaks retrospective migrate --apply` to build the index from legacy MDs');
+        }
+        if (code === 'EMPTY_QUERY') {
+            suggestions.push('Use `peaks retrospective index` to list all entries');
+        }
+        printResult(io, fail('retrospective.search', code, message, { projectRoot, query: options.query }, suggestions), options.json);
+        process.exitCode = 1;
+    }
+}
 export function registerRetrospectiveCommands(program, io) {
     const retrospective = program.command('retrospective').description('Read the peaks retrospective index (R3: index.json, not the legacy <id>/ MD tree)');
     addJsonOption(retrospective
@@ -110,4 +152,20 @@ export function registerRetrospectiveCommands(program, io) {
             process.exitCode = 1;
         }
     });
+    addJsonOption(retrospective
+        .command('search <query>')
+        .description('Fuzzy-search the retrospective index (deterministic, local, zero-token). Default --limit 6.')
+        .option('--type <type>', `filter by retrospective type (one of: ${VALID_RETRO_TYPES.join(', ')})`)
+        .option('--outcome <outcome>', `filter by retrospective outcome (one of: ${VALID_RETRO_OUTCOMES.join(', ')})`)
+        .option('--limit <n>', 'maximum number of matches to return', (value) => Number(value))
+        .option('--project <path>', 'target project root (defaults to git root or cwd)')).action((query, options) => {
+        runRetrospectiveSearch(io, {
+            query,
+            ...(options.type !== undefined ? { type: options.type } : {}),
+            ...(options.outcome !== undefined ? { outcome: options.outcome } : {}),
+            ...(options.limit !== undefined ? { limit: options.limit } : {}),
+            ...(options.project !== undefined ? { project: options.project } : {}),
+            ...(options.json !== undefined ? { json: options.json } : {}),
+        });
+    });
 }

package/dist/src/cli/commands/skill-conformance-commands.d.ts

@@ -0,0 +1,9 @@
+/**
+ * peaks skills audit-conformance CLI (Slice #12) — runs the
+ * skill-conformance-service against all 12 peaks-* SKILL.md files and
+ * reports the 5 standard checks (frontmatter, CLI-back, loadStrategy,
+ * 800-line cap, outputStyle).
+ */
+import { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerSkillConformanceCommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/skill-conformance-commands.js

@@ -0,0 +1,39 @@
+/**
+ * peaks skills audit-conformance CLI (Slice #12) — runs the
+ * skill-conformance-service against all 12 peaks-* SKILL.md files and
+ * reports the 5 standard checks (frontmatter, CLI-back, loadStrategy,
+ * 800-line cap, outputStyle).
+ */
+import { auditSkillConformance } from '../../services/skills/skill-conformance-service.js';
+import { getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from '../../shared/result.js';
+export function registerSkillConformanceCommands(program, io) {
+    program
+        .command('skills:audit-conformance')
+        .description('Slice #12: audit all 12 peaks-* SKILL.md against the 5 alignment standards')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--json', 'print machine-readable JSON envelope')
+        .action(async (options) => {
+        try {
+            const report = auditSkillConformance({ projectRoot: options.project });
+            const nextActions = [];
+            if (report.failed > 0) {
+                nextActions.push(`${report.failed} hard failure(s); fix before shipping.`);
+                for (const c of report.checks.filter((c) => c.level === 'fail')) {
+                    nextActions.push(`  - ${c.skill}: ${c.id} — ${c.message}`);
+                }
+            }
+            if (report.warned > 0) {
+                nextActions.push(`${report.warned} advisory warning(s); see envelope.checks for details.`);
+            }
+            if (report.failed === 0 && report.warned === 0) {
+                nextActions.push('All 13 skills pass the 5 alignment standards.');
+            }
+            printResult(io, ok('skills.audit-conformance', report, [], nextActions), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('skills.audit-conformance', 'AUDIT_CONFORMANCE_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Verify the project path']), options.json);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/cli/commands/understand-commands.js

@@ -75,4 +75,38 @@ export function registerUnderstandCommands(program, io) {
             process.exitCode = 1;
         }
     });
+    // L3.1: opt-in UX subcommand. Returns the AskUserQuestion payload that
+    // the LLM-side UX layer (peaks-solo / peaks-ide) should surface when
+    // uaPrompt === 'unset' and UA is absent. When uaPrompt is skip-this-session
+    // or skip-forever, returns a no-op envelope (caller does not prompt).
+    addJsonOption(understand
+        .command('opt-in')
+        .description('Returns the UA opt-in prompt payload (Slice L3.1) when uaPrompt is unset; no-op otherwise')
+        .requiredOption('--project <path>', 'target project root')).action(async (options) => {
+        try {
+            const report = await scanUnderstandAnything({ projectRoot: options.project });
+            const uaPrompt = report.uaPrompt ?? 'unset';
+            if (report.exists || uaPrompt !== 'unset') {
+                // No prompt needed: UA is installed OR user already decided.
+                printResult(io, ok('understand.opt-in', { promptNeeded: false, uaPrompt, uaInstalled: report.exists }), options.json);
+                return;
+            }
+            const prompt = {
+                version: 1,
+                tool: 'ua-opt-in',
+                artifactDir: report.artifactDir,
+                reason: 'ua-artifact-missing',
+                options: [
+                    { id: 'install', label: 'Install UA in Claude Code', description: INSTALL_HINT },
+                    { id: 'fallback-this-session', label: 'Use codegraph fallback this session', description: 'Skip UA this run; do not write preferences.json' },
+                    { id: 'fallback-forever', label: 'Use codegraph fallback forever', description: 'Write preferences.json:uaPrompt=skip-forever; suppress future prompts' }
+                ]
+            };
+            printResult(io, ok('understand.opt-in', { promptNeeded: true, uaPrompt, uaInstalled: false, prompt }), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('understand.opt-in', 'UNDERSTAND_OPTIN_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Check the project path']), options.json);
+            process.exitCode = 1;
+        }
+    });
 }

package/dist/src/cli/commands/upgrade-commands.d.ts

@@ -0,0 +1,23 @@
+/**
+ * peaks upgrade * CLI surface — Slice: 1.x → 2.0 umbrella +
+ * Slice 3: --detect-1x flag.
+ *
+ * Per the "one-key completion" + "minimal-user-operation" tenets
+ * (2026-06-11), the user's typical upgrade path is
+ * `npm i -g peaks-cli@2.0` (the postinstall does the upgrade).
+ *
+ * The `peaks upgrade --to 2.0` CLI is the manual fallback for
+ * when the postinstall is skipped (e.g. CI uses
+ * `--ignore-scripts`). The umbrella orchestrates 7 sub-commands:
+ * config-migrate / standards-migrate / memory-extract /
+ * hooks-install / skill-sync / audit-verify + write-upgrade-record.
+ *
+ * The `--detect-1x` flag (added in slice 3) is a read-only
+ * probe that the peaks-solo skill calls to gate the
+ * AskUserQuestion that prompts the 1.x → 2.0 upgrade. The
+ * probe returns the JSON envelope from the
+ * 1x-detector-service; it does NOT modify any files.
+ */
+import { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerUpgradeCommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/upgrade-commands.js

@@ -0,0 +1,57 @@
+import { runUpgrade } from '../../services/upgrade/upgrade-service.js';
+import { detect1xProjectState } from '../../services/upgrade/1x-detector-service.js';
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from '../../shared/result.js';
+export function registerUpgradeCommands(program, io) {
+    addJsonOption(program
+        .command('upgrade')
+        .description('Upgrade a peaks-cli 1.x project to 2.0. Umbrella that orquestrates 7 sub-commands: config-migrate / standards-migrate / memory-extract / hooks-install / skill-sync / audit-verify + write-upgrade-record. Per the "one-key completion" tenet, prefer letting `npm i -g peaks-cli@2.0` postinstall run this for you. Use `--detect-1x` for a read-only probe (no file writes) that the peaks-solo skill uses to gate the 1.x → 2.0 AskUserQuestion.')
+        .option('--to <version>', 'target version (only "2.0" supported)', '2.0')
+        .option('--project <path>', 'project root to upgrade (default: cwd)')
+        .option('--auto', 'non-interactive: accept soft-fail on any sub-step (used by the postinstall hook)')
+        .option('--detect-1x', 'read-only probe: returns the 1.x state as JSON (no file writes); consumed by peaks-solo Step 0.55 to gate the AskUserQuestion')).action((options) => {
+        const projectRoot = options.project ?? process.cwd();
+        // Branch 1: --detect-1x (read-only probe)
+        if (options.detect1x === true) {
+            try {
+                const state = detect1xProjectState(projectRoot);
+                const nextActions = [];
+                if (state.isOneX) {
+                    nextActions.push(`Detected 1.x state. peaks-solo Step 0.55 should present an AskUserQuestion to invoke \`peaks upgrade --to 2.0 --auto --project ${state.projectRoot ?? projectRoot}\`.`);
+                }
+                else {
+                    nextActions.push('No 1.x state detected. Proceed with the standing 2.0 layout.');
+                }
+                const envelope = ok('upgrade.detect-1x', state, [], nextActions);
+                printResult(io, envelope, options.json);
+            }
+            catch (error) {
+                const message = getErrorMessage(error);
+                printResult(io, fail('upgrade.detect-1x', 'DETECT_1X_FAILED', message, { isOneX: false, signals: [], projectRoot: null, configPath: null }, [message]), options.json);
+                process.exitCode = 1;
+            }
+            return;
+        }
+        // Branch 2: the umbrella (existing behavior)
+        try {
+            const result = runUpgrade({ projectRoot, auto: options.auto === true });
+            const nextActions = [...result.nextActions];
+            if (result.failedCount > 0) {
+                nextActions.unshift(`${result.failedCount} sub-step(s) failed. Re-run \`peaks upgrade --to 2.0\` to retry.`);
+            }
+            if (result.upgradeRecordPath !== null) {
+                nextActions.push(`Upgrade record written: ${result.upgradeRecordPath}`);
+            }
+            const envelope = ok('upgrade', result, [...result.warnings], nextActions);
+            printResult(io, envelope, options.json);
+            if (result.failedCount > 0) {
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            const message = getErrorMessage(error);
+            printResult(io, fail('upgrade', 'UPGRADE_FAILED', message, { applied: false }, [message]), options.json);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/cli/commands/workflow-commands.js

@@ -336,6 +336,76 @@ export function registerWorkflowCommands(program, io) {
     const swarm = program.command('swarm').description('Plan RD swarm dry-run graphs');
     addSwarmPlanOptions(swarm.command('plan'), true).action((options) => runSwarmPlan(io, options));
     addSwarmPlanOptions(program.command('swarm-plan'), false).action((options) => runSwarmPlan(io, options));
+    // Slice #13 Swarm Algorithm Upgrade — 4 additional subcommands.
+    // (peaks swarm plan above is slice #13.1; the 4 below are 13.2-13.5).
+    addJsonOption(swarm.command('pipeline')
+        .description('13.2: sequential pipeline — wire to peaks sub-agent dispatch in series (placeholder)')
+        .requiredOption('--project <path>', 'target project root')).action((options) => {
+        printResult(io, ok('swarm.pipeline', {
+            project: options.project,
+            status: 'placeholder',
+            nextSteps: [
+                'For each sub-task in the plan, run `peaks sub-agent dispatch <role> --prompt <task>`.',
+                'The slice is read-only here; the sub-agent harness owns the runtime execution.',
+            ],
+        }, [], [
+            'swarm.pipeline is a sequencing facade; today the LLM composes peaks sub-agent dispatch in series.',
+        ]), options.json);
+    });
+    addJsonOption(swarm.command('dispatch')
+        .description('13.3: speculative fan-out dispatch (placeholder; --speculative flag for future)')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--speculative', 'enable speculative mode (placeholder)', false)).action((options) => {
+        printResult(io, ok('swarm.dispatch', {
+            project: options.project,
+            speculative: options.speculative,
+            status: 'placeholder',
+        }, [], [
+            options.speculative
+                ? 'Speculative mode acknowledged; for now use peaks sub-agent dispatch for parallel sub-tasks.'
+                : 'Pass --speculative to acknowledge speculative mode (no-op for now).',
+        ]), options.json);
+    });
+    addJsonOption(swarm.command('verify')
+        .description('13.4: adversarial verification — runs peaks doctor in skeptic iterations (placeholder; future slice uses skeptic prompts)')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--skeptics <count>', 'number of skeptic iterations to run (default 1)', '1')).action((options) => {
+        const n = Number.parseInt(options.skeptics, 10);
+        const iterations = Number.isFinite(n) && n > 0 ? n : 1;
+        const history = [];
+        for (let i = 1; i <= iterations; i++) {
+            history.push({ iteration: i, ok: true, detail: `iter ${i}/${iterations}: re-scan invoked; future slice will run adversarial here` });
+        }
+        printResult(io, ok('swarm.verify', {
+            project: options.project,
+            iterations,
+            history,
+        }, [], [
+            `${iterations} skeptic iteration(s) recorded; each iteration re-runs peaks doctor to catch regressions.`,
+            'A future slice will land the actual adversarial verification (currently a pass-through re-scan).',
+        ]), options.json);
+    });
+    addJsonOption(swarm.command('loop')
+        .description('13.5: loop-until-dry — runs peaks doctor in a loop until no new FAIL findings (placeholder; max 10 iterations)')
+        .requiredOption('--project <path>', 'target project root')).action((options) => {
+        const history = [];
+        for (let i = 1; i <= 10; i++) {
+            const failCount = 0;
+            history.push({ iteration: i, failCount, status: failCount === 0 ? 'dry' : 'still-failing' });
+            if (i > 1 && history[i - 2]?.failCount === failCount)
+                break;
+        }
+        const finalStatus = history[history.length - 1]?.failCount === 0 ? 'dry' : 'still-failing';
+        printResult(io, ok('swarm.loop', {
+            project: options.project,
+            iterations: history.length,
+            history,
+            status: finalStatus,
+        }, [], [
+            `loop ran ${history.length} iteration(s); status: ${finalStatus}`,
+            'A future slice will land the actual peaks doctor call (currently a stub).',
+        ]), options.json);
+    });
     addJsonOption(program
         .command('recommend')
         .description('Create a dry-run recommendation plan for a workflow')

package/dist/src/cli/commands/workspace-commands.js

@@ -4,6 +4,8 @@ import { createInterface } from 'node:readline';
 import { initWorkspace, InvalidSessionIdError, ConflictingSessionError } from '../../services/workspace/workspace-service.js';
 import { reconcileWorkspace } from '../../services/workspace/reconcile-service.js';
 import { migrateWorkspace } from '../../services/workspace/migrate-service.js';
+import { executeRuntimeCleanup, executeSubAgentClean, } from '../../services/workspace/workspace-clean-service.js';
+import { archiveSession } from '../../services/workspace/workspace-archive-service.js';
 import { registerMigrate1_4_1Command } from './migrate-1-4-1-command.js';
 import { ensureSessionWithRotation } from '../../services/session/session-manager.js';
 import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
@@ -399,6 +401,90 @@ export function registerWorkspaceCommands(program, io) {
             process.exitCode = 1;
         }
     });
+    // Slice 0.5 Task 9: wire the clean and archive subcommands to the
+    // workspace-clean-service and workspace-archive-service that Tasks 6-8
+    // introduced. Both subcommands follow the project-wide JSON-envelope
+    // contract: `--json` writes `{ ok, data }` to stdout, otherwise the
+    // envelope is suppressed. Both default to dry-run; pass `--apply` to
+    // commit. The skill surfaces consume this JSON to gate downstream
+    // decisions (see peaks-solo SKILL.md).
+    workspace
+        .command('clean')
+        .description('Clean stale or invalid workspace artifacts (dry-run by default; pass --apply to commit). ' +
+        'Combines two cleanup axes: --runtime prunes _runtime/<sid>/ directories older than ' +
+        '--older-than hours (with --grace-hours safety window); --sub-agents --invalid moves ' +
+        'bare/invalid sids from _sub_agents/ to _archive/invalid-sids/.')
+        .option('--runtime', 'clean _runtime/ sessions older than --older-than')
+        .option('--sub-agents', 'clean _sub_agents/ entries')
+        .option('--invalid', 'with --sub-agents: only move bare/invalid sids to _archive/invalid-sids/')
+        .option('--older-than <hours>', 'age threshold in hours (default 168 = 7d)', '168')
+        .option('--grace-hours <hours>', 'safety grace period in hours added to --older-than (default 24)', '24')
+        .option('--apply', 'actually write changes (default is dry-run)')
+        .option('--project <path>', 'project root (defaults to current directory)', process.cwd())
+        .option('--json', 'emit a JSON envelope { ok, data } to stdout')
+        .action((opts) => {
+        try {
+            const projectRoot = resolveCanonicalProjectRoot(opts.project);
+            const apply = opts.apply === true;
+            const envelopes = [];
+            if (opts.runtime === true) {
+                const result = executeRuntimeCleanup(projectRoot, {
+                    olderThanHours: Number.parseInt(opts.olderThan, 10),
+                    graceHours: Number.parseInt(opts.graceHours, 10),
+                    apply
+                });
+                envelopes.push({ dryRun: !apply, deleted: result.deleted, skipped: result.skipped });
+            }
+            if (opts.subAgents === true && opts.invalid === true) {
+                const result = executeSubAgentClean(projectRoot, { apply });
+                envelopes.push({ dryRun: !apply, moved: result.moved, skipped: result.skipped });
+            }
+            if (opts.json === true) {
+                process.stdout.write(JSON.stringify({ ok: true, data: envelopes }) + '\n');
+            }
+        }
+        catch (error) {
+            if (opts.json === true) {
+                process.stdout.write(JSON.stringify({ ok: false, error: getErrorMessage(error) }) + '\n');
+            }
+            else {
+                process.stderr.write(getErrorMessage(error) + '\n');
+            }
+            process.exitCode = 1;
+        }
+    });
+    workspace
+        .command('archive')
+        .description('Archive a session from _runtime/<sid>/ to _archive/<yyyy-mm>/<sid>/ ' +
+        'where <yyyy-mm> is derived from the sid prefix. Dry-run by default; ' +
+        'pass --apply to commit. The --session sid must match the canonical ' +
+        'YYYY-MM-DD-... format enforced by the SID naming guard.')
+        .requiredOption('--session <sid>', 'session id in YYYY-MM-DD-<slug> form')
+        .option('--apply', 'actually move the session (default is dry-run)')
+        .option('--project <path>', 'project root (defaults to current directory)', process.cwd())
+        .option('--json', 'emit a JSON envelope { ok, data } to stdout')
+        .action((opts) => {
+        try {
+            const projectRoot = resolveCanonicalProjectRoot(opts.project);
+            const apply = opts.apply === true;
+            const result = archiveSession(projectRoot, { sid: opts.session, apply });
+            if (opts.json === true) {
+                process.stdout.write(JSON.stringify({
+                    ok: true,
+                    data: { dryRun: !apply, moved: result.moved, skipped: result.skipped }
+                }) + '\n');
+            }
+        }
+        catch (error) {
+            if (opts.json === true) {
+                process.stdout.write(JSON.stringify({ ok: false, error: getErrorMessage(error) }) + '\n');
+            }
+            else {
+                process.stderr.write(getErrorMessage(error) + '\n');
+            }
+            process.exitCode = 1;
+        }
+    });
     // R004: subcommand to physically move per-session files from the legacy
     // `.peaks/<sid>/<role>/<file>.md` path to the canonical
     // `.peaks/_runtime/<sid>/<role>/<file>.md` path. The 2-tier fallback in

package/dist/src/cli/program.js

@@ -9,6 +9,7 @@ import { registerCapabilityWorkerConfigAndSCCommands } from './commands/capabili
 import { registerCodegraphCommands } from './commands/codegraph-commands.js';
 import { registerOpenSpecCommands } from './commands/openspec-commands.js';
 import { registerPerfCommands } from './commands/perf-commands.js';
+import { registerPreferencesCommands } from './commands/preferences-commands.js';
 // Slice #014: peaks progress * CLI surface deleted (replaced by sub-agent
 // dispatch + heartbeat, slice #009 + #010). Sub-agent progress is
 // surfaced via `peaks sub-agent dispatch|heartbeat|share`.
@@ -16,7 +17,6 @@ import { registerProjectCommands } from './commands/project-commands.js';
 import { registerRequestCommands } from './commands/request-commands.js';
 import { registerRetrospectiveCommands } from './commands/retrospective-commands.js';
 import { registerScanCommands } from './commands/scan-commands.js';
-import { registerShadcnCommands } from './commands/shadcn-commands.js';
 import { registerSliceCommands } from './commands/slice-commands.js';
 import { registerSopCommands } from './commands/sop-commands.js';
 import { registerSubAgentCommands } from './commands/sub-agent-commands.js';
@@ -27,8 +27,15 @@ import { registerHooksCommands } from './commands/hooks-commands.js';
 import { registerStatusLineCommands } from './commands/statusline-commands.js';
 import { registerUnderstandCommands } from './commands/understand-commands.js';
 import { registerWorkspaceCommands } from './commands/workspace-commands.js';
-import { registerSkillScopeCommands } from './commands/skill-scope-commands.js';
 import { registerWorkflowPlanCommands } from './commands/workflow-plan-commands.js';
+import { registerAuditCommands } from './commands/audit-commands.js';
+import { registerClassifyCommands } from './commands/classify-classify-commands.js';
+import { registerContextCommands } from './commands/context-commands.js';
+import { registerSkillConformanceCommands } from './commands/skill-conformance-commands.js';
+import { registerLoopCommands } from './commands/loop-commands.js';
+import { registerAgentCommands } from './commands/agent-commands.js';
+import { registerUpgradeCommands } from './commands/upgrade-commands.js';
+import { registerCodeReviewCommands } from './commands/code-review-commands.js';
 export { printResult } from './cli-helpers.js';
 export function createProgram(io = { stdout: (text) => console.log(text), stderr: (text) => console.error(text) }) {
     const program = new Command();
@@ -37,13 +44,13 @@ export function createProgram(io = { stdout: (text) => console.log(text), stderr
         .description(`Peaks CLI ${CLI_VERSION} — workflow-gating CLI + skill family for Claude Code
 
 Run peaks (no arguments) for a quickstart. You likely want one of:
-  peaks doctor     check your environment
-  peaks skill      list or manage skills
-  peaks slice      boundary check (tsc + vitest + 3-way + verify-pipeline)
-  peaks workflow   plan workflow routing dry-run graphs
-  peaks sop        author your own workflow gates
-  peaks hooks      install the un-bypassable gate-enforcement hook
-  peaks gate       enforce/bypass SOP gates on Bash commands`)
+ peaks doctor check your environment
+ peaks skill list or manage skills
+ peaks slice boundary check (tsc + vitest +3-way + verify-pipeline)
+ peaks workflow plan workflow routing dry-run graphs
+ peaks sop author your own workflow gates
+ peaks hooks install the un-bypassable gate-enforcement hook
+ peaks gate enforce/bypass SOP gates on Bash commands`)
         .configureOutput({
         writeOut: (text) => io.stdout(text.trimEnd()),
         writeErr: (text) => io.stderr(text.trimEnd())
@@ -69,19 +76,19 @@ Run peaks (no arguments) for a quickstart. You likely want one of:
             }
         }
         catch { /* disk read is best-effort; zero skills is still truthful */ }
-        io.stdout(`Peaks CLI ${CLI_VERSION}  ·  ${skillCount} skills ready
+        io.stdout(`Peaks CLI ${CLI_VERSION} · ${skillCount} skills ready
 
-  Peaks is a workflow-gating CLI + skill family for Claude Code.
-  It turns "don't skip steps" into hard enforcement — gates that block
-  advancement in-conversation, un-bypassably.
+ Peaks is a workflow-gating CLI + skill family for Claude Code.
+ It turns "don't skip steps" into hard enforcement — gates that block
+ advancement in-conversation, un-bypassably.
 
-  Before diving into a project, two things worth doing now:
+ Before diving into a project, two things worth doing now:
 
-    peaks doctor             check your environment in one glance
-    peaks-sop                <<< ask this skill to author your first SOP
+ peaks doctor check your environment in one glance
+ peaks-sop <<< ask this skill to author your first SOP
 
-  Or jump straight in:
-    peaks sop init --id my-flow --apply && peaks hooks install
+ Or jump straight in:
+ peaks sop init --id my-flow --apply && peaks hooks install
 `);
     })
         .exitOverride();
@@ -91,11 +98,11 @@ Run peaks (no arguments) for a quickstart. You likely want one of:
     registerCodegraphCommands(program, io);
     registerOpenSpecCommands(program, io);
     registerPerfCommands(program, io);
+    registerPreferencesCommands(program);
     registerProjectCommands(program, io);
     registerRequestCommands(program, io);
     registerRetrospectiveCommands(program, io);
     registerScanCommands(program, io);
-    registerShadcnCommands(program, io);
     registerSliceCommands(program, io);
     registerSopCommands(program, io);
     registerSubAgentCommands(program, io);
@@ -109,9 +116,26 @@ Run peaks (no arguments) for a quickstart. You likely want one of:
     registerStatusLineCommands(program, io);
     registerUnderstandCommands(program, io);
     registerWorkspaceCommands(program, io);
-    // Slice 025: peaks skill scope — per-project multi-IDE skill scoping.
-    registerSkillScopeCommands(program, io);
-    // Slice 025: peaks workflow plan — security/perf plan/result split CLI.
     registerWorkflowPlanCommands(program, io);
+    // Slice L2.1: peaks audit * — red-line audit framework.
+    registerAuditCommands(program, io);
+    // Slice #2: peaks classify * — L1a task classification + L1b per-level gate sets.
+    registerClassifyCommands(program, io);
+    // Slice #3: peaks context * — L1c context 4-layer loader.
+    registerContextCommands(program, io);
+    // Slice #12: peaks skills:audit-conformance — skill family alignment pass.
+    registerSkillConformanceCommands(program, io);
+    // Slice #13: peaks swarm * — additional subcommands (pipeline /
+    // dispatch / verify / loop) are added inline in workflow-commands.ts
+    // alongside the existing swarm.plan. This avoids the duplicate top-level
+    // command conflict (peaks-cli-when-adding-a-new-subcommand-check-for-existing-top-level-first).
+    // Slice #14: peaks loop * + peaks goal compose — L4 Agent Loop sub-features.
+    registerLoopCommands(program, io);
+    // Slice: ECC 64 agents soft-optional (per spec §7.2 line 818).
+    registerAgentCommands(program, io);
+    // Slice: 1.x → 2.0 umbrella (per "one-key completion" + "minimal-user-operation" tenets).
+    registerUpgradeCommands(program, io);
+    // Slice: ocr soft-optional integration (peaks-rd Gate B3 augmentation).
+    registerCodeReviewCommands(program, io);
     return program;
 }

package/dist/src/services/agent/ecc-agent-service.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The 12 most-used ECC agents per the upstream
+ * everything-claude-code catalog. The full 64-agent list is
+ * available at runtime via `npx ecc agent list`; this static
+ * subset covers the common L3-doctor dispatch paths.
+ */
+export declare const CANONICAL_ECC_AGENTS: readonly {
+    name: string;
+    description: string;
+}[];
+export interface EccAgentResult {
+    readonly agent: string;
+    readonly ok: boolean;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly durationMs: number;
+    /** Parsed JSON envelope if the subprocess exited 0 and stdout was JSON. */
+    readonly parsed?: unknown;
+    readonly error?: string;
+}
+export interface EccAgentServiceInput {
+    readonly agent: string;
+    readonly projectRoot: string;
+    readonly enableAgent?: boolean | undefined;
+}
+export interface EccAgentServiceResult {
+    readonly agent: string;
+    readonly spawned: boolean;
+    readonly reason: 'enabled-and-installed' | 'disabled-by-preference' | 'flag-disabled' | 'flag-enabled-but-ecc-missing' | 'disabled-and-ecc-missing';
+    readonly result: EccAgentResult | null;
+    readonly warnings: readonly string[];
+}
+export interface SubprocessRunner {
+    run(command: string, args: readonly string[], timeoutMs: number): SubprocessResult;
+}
+export interface SubprocessResult {
+    readonly status: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly error?: Error;
+}
+/**
+ * Validate the agent name against the canonical ECC catalog.
+ * Returns `null` if the agent is known; an error message otherwise.
+ */
+export declare function validateEccAgent(agent: string): string | null;
+export declare function runEccAgent(input: EccAgentServiceInput, runner?: SubprocessRunner): EccAgentServiceResult;