peaks-loop 4.0.0-beta.9 → 4.0.1

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;