peaks-loop 4.0.0-beta.9 → 4.0.3

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.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { addJsonOption, printResult } from '../cli-helpers.js';
-import { fail, ok, getErrorMessage } from '../../shared/result.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) {

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

@@ -43,12 +43,14 @@
 import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { openStateDb } from "../../services/skillhub/sqlite-store.js";
-import { CrystallizationService, CrystallizationIntegrityError, } from "../../services/crystallization/crystallization-service.js";
-import { CRYSTALLIZATION_TRIGGERS, parseEvidenceBrief, } from "../../services/crystallization/crystallization-types.js";
-import { BriefSectionError, safeRenderRecommendationPayload, } from "../../services/crystallization/evidence-brief-builder.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 "../../shared/result.js";
+import { fail, ok } from 'peaks-loop-shared/result';
 function collectRepeatable(value, previous) {
     if (Array.isArray(previous))
         return [...previous, value];
@@ -120,7 +122,8 @@ export function registerAssetCommands(program, io) {
             }
             catch (err) {
                 if (err instanceof BriefSectionError) {
-                    printResult(io, fail("asset.crystallize", "MISSING_BRIEF_SECTION", err.message, { findings: [...err.findings], flagsProvided: Object.keys(candidateBrief) }, [
+                    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);
@@ -155,7 +158,12 @@ export function registerAssetCommands(program, io) {
             }
             const db = openStateDb(join(projectRoot, ".peaks", "state.db"));
             try {
-                const svc = new CrystallizationService(db);
+                const svc = new CrystallizationService(db, {
+                    loopReleaseSchema: LoopReleaseSchema,
+                    loopBeeRelationSchema: LoopBeeRelationSchema,
+                    insertLoopRelease: insertLoopRelease,
+                    insertLoopBeeRelation: insertLoopBeeRelation,
+                });
                 const result = svc.crystallize({
                     task: {
                         task_id: options.fromTask,
@@ -217,10 +225,11 @@ export function registerAssetCommands(program, io) {
         }
         catch (err) {
             if (err instanceof CrystallizationIntegrityError) {
-                printResult(io, fail("asset.crystallize", err.code, err.message, { findings: [...err.findings] }, [
-                    err.code === "CRYSTALLIZATION_PRE_RUN"
+                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)."
-                        : err.code === "MISSING_BRIEF_SECTION"
+                        : 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);
@@ -228,14 +237,12 @@ export function registerAssetCommands(program, io) {
                 return;
             }
             if (err instanceof BriefSectionError) {
-                printResult(io, fail("asset.crystallize", "MISSING_BRIEF_SECTION", err.message, { findings: [...err.findings] }, ["Pass all 4 brief sections (RL-7)."]), options.json);
+                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;
             }
-            printResult(io, fail("asset.crystallize", "ASSET_CRYSTALLIZE_FAILED", getErrorMessage(err), {}, [
-                "Verify the brief flags and the loop/bee identifiers are valid.",
-            ]), options.json);
-            process.exitCode = 1;
+            throw err;
         }
     });
     // ---------- peaks asset dispose ----------
@@ -258,7 +265,12 @@ export function registerAssetCommands(program, io) {
             }
             const db = openStateDb(join(projectRoot, ".peaks", "state.db"));
             try {
-                const svc = new CrystallizationService(db);
+                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);
@@ -331,7 +343,12 @@ export function registerAssetCommands(program, io) {
             }
             const db = openStateDb(join(projectRoot, ".peaks", "state.db"));
             try {
-                const svc = new CrystallizationService(db);
+                const svc = new CrystallizationService(db, {
+                    loopReleaseSchema: LoopReleaseSchema,
+                    loopBeeRelationSchema: LoopBeeRelationSchema,
+                    insertLoopRelease: insertLoopRelease,
+                    insertLoopBeeRelation: insertLoopBeeRelation,
+                });
                 let events = [];
                 if (options.loop) {
                     events = [

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

@@ -12,7 +12,7 @@ import { resolve } from 'node:path';
 import { runRedLinesAudit } from '../../services/audit/red-lines-service.js';
 import { runStaticAudit } from '../../services/audit/static-service.js';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
-import { fail, ok } from '../../shared/result.js';
+import { fail, ok } from 'peaks-loop-shared/result';
 import { writeAuditDecision } from '../../services/audit/decision-writer.js';
 import { computeProseRatio } from '../../services/audit/prose-ratio-calculator.js';
 import { writeMachineOutput, writeNarrative, writePrompt, } from '../../services/audit/artifact-writer.js';
@@ -49,7 +49,7 @@ function validateProjectRoot(projectArg) {
 }
 export function registerAuditCommands(program, io) {
     const audit = program
-        .command('audit')
+        .command('audit', { hidden: true })
         .description('Audit a project for compliance with peaks-loop red lines (P0 / P1 / P2 tiers)');
     addJsonOption(audit
         .command('red-lines')

package/dist/cli/commands/autonomous-swarm-commands.d.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export type AutonomousPlanOptions = {
+    mode: string;
+    changeId: string;
+    goal: string;
+    maxWorkers?: string;
+    dryRun?: boolean;
+    json?: boolean;
+};
+export declare function runAutonomousSwarmPlan(io: ProgramIO, options: AutonomousPlanOptions): void;
+export declare function registerAutonomousSwarmCommands(program: Command, io: ProgramIO): void;

package/dist/cli/commands/autonomous-swarm-commands.js

@@ -0,0 +1,120 @@
+import { fail, ok } from 'peaks-loop-shared/result';
+import { getWorkspaceConfigForPath } from '../../services/config/config-service.js';
+import { getLocalArtifactPath } from '../../services/artifacts/workspace-service.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+import { planAutonomousRdSwarm, buildAutonomousGoalPackage, buildResumeInstructions, } from '../../services/autonomous-swarm/autonomous-swarm-service.js';
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { mapServiceError } from './_cli-error-envelope.js';
+const SUPPORTED_AUTONOMOUS_MODES = ['code', 'team'];
+function isAutonomousMode(value) {
+    return SUPPORTED_AUTONOMOUS_MODES.includes(value);
+}
+function projectContext() {
+    const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+    const workspace = getWorkspaceConfigForPath(projectRoot);
+    return {
+        workspaceRoot: workspace ? getLocalArtifactPath(workspace) : projectRoot,
+    };
+}
+function autonomousWorkspaceRoot() {
+    return projectContext().workspaceRoot;
+}
+export function runAutonomousSwarmPlan(io, options) {
+    if (options.dryRun === false) {
+        printResult(io, fail('workflow.autonomous', 'NON_DRY_RUN_UNSUPPORTED', 'Only dry-run planning is supported', {}, ['Rerun with --dry-run or omit --no-dry-run']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    if (!isAutonomousMode(options.mode)) {
+        printResult(io, fail('workflow.autonomous', 'UNSUPPORTED_AUTONOMOUS_MODE', `Unsupported autonomous mode ${options.mode}`, {}, ['Use --mode code or --mode team']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    const maxWorkers = Number(options.maxWorkers ?? '40');
+    if (!Number.isInteger(maxWorkers) || maxWorkers < 1) {
+        printResult(io, fail('workflow.autonomous', 'INVALID_MAX_WORKERS', 'max-workers must be a positive integer', {}, ['Use --max-workers with a positive integer value']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    const workspaceRoot = autonomousWorkspaceRoot();
+    try {
+        // Validate inputs that the service enforces as throws so we surface
+        // them as typed envelope codes rather than generic INTERNAL_ERROR.
+        if (!options.goal.trim()) {
+            throw new Error('Goal must be non-empty');
+        }
+        const goalPackage = buildAutonomousGoalPackage({
+            changeId: options.changeId,
+            goal: options.goal,
+            mode: options.mode,
+            maxWorkers,
+            dryRun: true,
+            workspaceRoot,
+        });
+        const plan = planAutonomousRdSwarm({
+            changeId: options.changeId,
+            goal: options.goal,
+            mode: options.mode,
+            maxWorkers,
+            dryRun: true,
+            workspaceRoot,
+            requiresTechApproval: false,
+        });
+        const resumeInstructions = buildResumeInstructions(plan);
+        printResult(io, ok('workflow.autonomous', {
+            goalPackage,
+            capabilityReuse: plan.capabilityReuse,
+            checkpoints: plan.checkpoints,
+            workerQueue: plan.workerQueue,
+            evidence: plan.evidence,
+            artifactRoot: plan.artifactRoot,
+            gateStatus: plan.gateStatus,
+            blockedReasons: plan.blockedReasons,
+            nextActions: plan.nextActions,
+            resumeInstructions,
+            autonomyMode: plan.autonomyMode,
+            available: plan.available,
+        }), options.json);
+    }
+    catch (error) {
+        const mapping = mapServiceError(error);
+        // Re-label change-id validation errors so the envelope code matches
+        // the typed `code` we want to surface to the user (rather than the
+        // generic INTERNAL_ERROR fallback).
+        if (error instanceof Error && /changeId|change-id/.test(error.message)) {
+            if (error.message.includes('empty')) {
+                printResult(io, fail('workflow.autonomous', 'change-id-empty', error.message, {}, ['Provide a change-id matching [A-Za-z0-9][A-Za-z0-9._-]*']), options.json);
+            }
+            else {
+                printResult(io, fail('workflow.autonomous', 'change-id-format', error.message, {}, ['Provide a change-id matching [A-Za-z0-9][A-Za-z0-9._-]*']), options.json);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        printResult(io, fail('workflow.autonomous', mapping.code, getErrorMessage(error), {}, [...mapping.nextActions]), options.json);
+        process.exitCode = 1;
+    }
+}
+function addAutonomousPlanOptions(command) {
+    return addJsonOption(command
+        .description('Plan an autonomous RD swarm dry-run (slice rid-014).')
+        .requiredOption('--mode <mode>', 'autonomous mode: code or team')
+        .requiredOption('--change-id <id>', 'change id matching [A-Za-z0-9][A-Za-z0-9._-]*')
+        .requiredOption('--goal <goal>', 'planning goal')
+        .option('--max-workers <count>', 'maximum worker count', '40')
+        .option('--dry-run', 'preview without writing files', true)
+        .option('--no-dry-run', 'unsupported: do not execute autonomous planning from this CLI'));
+}
+export function registerAutonomousSwarmCommands(program, io) {
+    // Register the new rid-014 dry-run planner under
+    // `peaks workflow autonomous-swarm` (the existing `peaks workflow
+    // autonomous` registration owns the bare `autonomous` name and is
+    // untouched). The legacy `registerSwarmCommands` and
+    // `registerTechCommands` calls in `workflow-commands.ts` are
+    // byte-for-byte untouched.
+    const workflow = program.commands.find((candidate) => candidate.name() === 'workflow');
+    if (workflow) {
+        addAutonomousPlanOptions(workflow.command('autonomous-swarm')).action((options) => runAutonomousSwarmPlan(io, options));
+    }
+    addAutonomousPlanOptions(program.command('autonomous-swarm')).action((options) => runAutonomousSwarmPlan(io, options));
+}

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

@@ -24,7 +24,7 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
-import { fail, ok } from '../../shared/result.js';
+import { fail, ok } from 'peaks-loop-shared/result';
 import { findProjectRoot } from '../../services/config/config-safety.js';
 import { openStateDb } from '../../services/skillhub/sqlite-store.js';
 import { writeBundle, BundleNotShareableError, BundleAssetNotFoundError, } from '../../services/share/bundle-writer.js';

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

@@ -2,7 +2,7 @@ import { readConfig } from '../../services/config/config-service.js';
 import { resolveCapabilityAvailability } from '../../services/recommendations/capability-availability.js';
 import { createCapabilityMapPlan } from '../../services/recommendations/capability-map-service.js';
 import { seedCapabilityItems, seedCapabilitySources } from '../../services/recommendations/seed-capability-catalog.js';
-import { fail, ok } from '../../shared/result.js';
+import { fail, ok } from 'peaks-loop-shared/result';
 import { addJsonOption, printResult } from '../cli-helpers.js';
 const CAPABILITY_SOURCE_FILTERS = new Set(['all', 'access-repo', 'mcp-server']);
 export function registerCapabilityCommands(program, io) {

package/dist/cli/commands/capability-worker-config-sc-commands.js

@@ -1,10 +1,8 @@
 import { registerCapabilityCommands } from './capability-commands.js';
 import { registerConfigCommands } from './config-commands.js';
 import { registerSCCommands } from './sc-commands.js';
-import { registerWorkerCommands } from './worker-commands.js';
 export function registerCapabilityWorkerConfigAndSCCommands(program, io) {
     registerCapabilityCommands(program, io);
-    registerWorkerCommands(program, io);
     registerConfigCommands(program, io);
     registerSCCommands(program, io);
 }

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

@@ -0,0 +1,13 @@
+/**
+ * rid-011 — peaks changeset check (Phase 4 slice 2).
+ *
+ *   - `peaks changeset check` — hard gate, exit non-zero if any staged
+ *     .changeset/*.md exists. No warning mode, no --strict, no
+ *     --skip-changeset-check.
+ *
+ * Wired into `_register.ts` via the rid-007 auto-registration barrel;
+ * do NOT add a second registration call in `program.ts`.
+ */
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerChangesetCommands(program: Command, io: ProgramIO): void;

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

@@ -0,0 +1,46 @@
+/**
+ * rid-011 — peaks changeset check (Phase 4 slice 2).
+ *
+ *   - `peaks changeset check` — hard gate, exit non-zero if any staged
+ *     .changeset/*.md exists. No warning mode, no --strict, no
+ *     --skip-changeset-check.
+ *
+ * Wired into `_register.ts` via the rid-007 auto-registration barrel;
+ * do NOT add a second registration call in `program.ts`.
+ */
+import { findProjectRoot } from '../../services/config/config-safety.js';
+import { runChangesetHardGate } from '../../services/changeset/changeset-check-service.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { addJsonOption, printResult } from '../cli-helpers.js';
+export function registerChangesetCommands(program, io) {
+    const changeset = program
+        .command('changeset')
+        .description('rid-011 — changeset hard gate (no warning mode, no skip).');
+    addJsonOption(changeset
+        .command('check')
+        .description('Hard-gate check: exit non-zero if any .changeset/*.md file is staged ' +
+        '(excluding README.md). Mirrors publish.yml gate-changeset step.')
+        .option('--project <path>', 'project root (default: cwd)')).action((opts) => {
+        const projectRoot = opts.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+        const gate = runChangesetHardGate(projectRoot);
+        if (gate.ok) {
+            printResult(io, ok('changeset.check', {
+                root: gate.root,
+                state: gate.state,
+                stagedFiles: gate.stagedFiles,
+                snapshotAt: gate.snapshotAt
+            }, [], []), opts.json ?? false);
+            return;
+        }
+        process.exitCode = 1;
+        printResult(io, fail('changeset.check', 'CHANGESET_BLOCKED', `${gate.stagedFiles.length} staged .changeset/*.md file(s) — refusing to proceed`, {
+            root: gate.root,
+            state: gate.state,
+            stagedFiles: gate.stagedFiles,
+            snapshotAt: gate.snapshotAt
+        }, [
+            `Drain pending changesets before proceeding: drain `.concat(gate.stagedFiles.join(', '), ' via the coordinating LLM (e.g. `pnpm changeset version` or `peaks changeset publish` if installed).'),
+            'Then re-run `peaks changeset check` to confirm a clean state.'
+        ]), opts.json ?? false);
+    });
+}

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

@@ -14,9 +14,16 @@
  * v2.11.0 Group F (Tier 9) — D5 / D7 additions:
  *   - `peaks code should-pause --step <step> --mode <mode>` (D5)
  *   - `peaks code post-compact-detect --project <path>` (D7)
+ *
+ * rid-024: 7 sub-commands extracted into 3 sibling files:
+ *   - code-mode-gate-commands.ts (plan + should-pause)
+ *   - code-job-shape-commands.ts (detect-job + read-job-shape)
+ *   - code-runtime-commands.ts (post-compact-detect + auto-compact + context-now + gate-step-08 + emit-handoff)
+ * This file keeps the public API: types, buildCodePlan, runCodeFast,
+ * registerCodeCommands (now a thin orchestrator).
  */
 import type { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
+import type { ProgramIO } from '../cli-helpers.js';
 export type CodeStepKind = 'memory' | 'preflight' | 'rd' | 'qa' | 'emit';
 export interface CodeStep {
     readonly id: 'load-memory' | 'standards-preflight' | 'rd-cycle' | 'qa-cycle' | 'emit-txt';
@@ -76,5 +83,8 @@ export declare function runCodeFast(opts: {
  * LLM-side orchestration is driven by the SKILL.md (LLM-side), so this
  * CLI command is a thin surface that builds the plan and emits a JSON
  * envelope for downstream tooling.
+ *
+ * rid-024: this function is now a thin orchestrator that delegates to 3
+ * sibling register functions + the rid-020b run register.
  */
 export declare function registerCodeCommands(program: Command, io: ProgramIO): void;