peaks-loop 4.1.1 → 4.1.3

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

@@ -0,0 +1,116 @@
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { getSessionId } from '../../services/session/session-manager.js';
+import { verifyPipeline } from '../../services/workflow/pipeline-verify-service.js';
+import { applySkip, detectCallerKind } from '../../services/workflow/workflow-skip-service.js';
+const VERIFY_PIPELINE_DESCRIPTION = 'Verify the complete rd→qa pipeline was followed for a request. Scans the v2.17.0 canonical session-axis layout (artifacts under _runtime per-session) and falls back to the legacy v2.16.0 change-axis forms during the 1-minor-release deprecation window.';
+const SKIP_DESCRIPTION = 'Skip specific gates for a request (RD/QA). Use --dry-run to preview without writing. Allowed gate names: QA / RD (phase shortcuts) or specific gate names (rd-request-exists, prd-handoff, bug-analysis, code-review, security-review, perf-baseline, qa-request-exists, test-cases, test-report). Three rules apply: (1) only docs/config/chore slices can skip; (2) skip is one-time per rid; (3) script callers must also pass --i-have-reviewed.';
+/** The action body, lifted to a module-level function so both it and the registrar fit in 50 lines. */
+async function runVerifyPipeline(options, io) {
+    try {
+        const result = await verifyPipeline({
+            projectRoot: options.project,
+            rid: options.rid,
+            ...(options.type ? { requestType: options.type } : {}),
+            ...(options.sessionId ? { sessionId: options.sessionId } : {})
+        });
+        const exitOk = result.complete ? 0 : 1;
+        printResult(io, result.complete
+            ? ok('workflow.verify-pipeline', result)
+            : fail('workflow.verify-pipeline', 'PIPELINE_INCOMPLETE', `${result.violations.length} violation(s): ${result.violations.join('; ')}`, result, result.nextActions), options.json);
+        process.exitCode = exitOk;
+    }
+    catch (error) {
+        printResult(io, fail('workflow.verify-pipeline', 'VERIFY_FAILED', getErrorMessage(error), { acceptedForm: 'none', gateC: 'fail' }, ['Check that --project and --rid are correct.']), options.json);
+        process.exitCode = 1;
+    }
+}
+/** The `no peaks-code session binding` branch, lifted verbatim out of the skip action body. */
+function reportSkipNoActiveSession(io, options) {
+    printResult(io, fail('workflow.skip', 'NO_ACTIVE_SESSION', `project "${options.project}" has no peaks-code session binding; run \`peaks workspace init --project ${options.project} --json\` first`, { applied: false }, [`peaks workspace init --project ${options.project} --json`]), options.json);
+    process.exitCode = 1;
+}
+/**
+ * The applied / idempotent / rejected tail of the skip action, lifted verbatim
+ * out of its body; it runs at the same point in the sequence and the caller
+ * returns where the original returned early.
+ */
+function reportSkipOutcome(io, options, sessionId, result) {
+    if (result.applied) {
+        printResult(io, ok('workflow.skip', result, [], [
+            `Skip applied for rid "${options.rid}": gates [${result.skippedGates.join(', ')}] marked as status: 'skipped' on next verify-pipeline.`,
+            `State file: ${result.persistedTo}`,
+            `Run \`peaks workflow verify-pipeline --rid ${options.rid} --project ${options.project} --session-id ${sessionId} --json\` to confirm.`
+        ]), options.json);
+        return;
+    }
+    if (result.idempotent) {
+        printResult(io, ok('workflow.skip', result, [], [`Skip already applied for rid "${options.rid}"; idempotent no-op.`]), options.json);
+        return;
+    }
+    // applied:false + reason → rejection.
+    printResult(io, fail('workflow.skip', 'SKIP_REJECTED', result.reason ?? 'unknown rejection', result, [
+        'See RD request for the three rules: docs/config/chore only, one-time per rid, script callers need --i-have-reviewed.'
+    ]), options.json);
+    process.exitCode = 1;
+}
+/** The catch branch, lifted verbatim out of the skip action body. */
+function reportSkipFailure(io, error, json) {
+    printResult(io, fail('workflow.skip', 'SKIP_FAILED', getErrorMessage(error), { applied: false }, [
+        'Check that --project and --rid are correct; --reason and --gates are required.'
+    ]), json);
+    process.exitCode = 1;
+}
+/** The action body, lifted to a module-level function so both it and the registrar fit in 50 lines. */
+async function runWorkflowSkip(options, io) {
+    try {
+        // Resolve the session id from the project's current binding
+        // (CLI is the single source of truth per the dev-preference
+        // rules). The skip-state is keyed by session id, so the
+        // operator's current session determines where the marker
+        // lives. Auto-rotation on outer-mismatch is irrelevant here
+        // because we read, not write, the binding.
+        const sessionId = getSessionId(options.project);
+        if (sessionId === null) {
+            reportSkipNoActiveSession(io, options);
+            return;
+        }
+        const callerKind = detectCallerKind(process.env['PEAKS_CALLER_ID']);
+        const skipArgs = {
+            rid: options.rid,
+            gatesRaw: options.gates,
+            reason: options.reason,
+            ...(options.dryRun === true ? { dryRun: true } : {}),
+            ...(options.iHaveReviewed === true ? { iHaveReviewed: true } : {}),
+            callerKind
+        };
+        const result = await applySkip(options.project, sessionId, skipArgs);
+        reportSkipOutcome(io, options, sessionId, result);
+    }
+    catch (error) {
+        reportSkipFailure(io, error, options.json);
+    }
+}
+export function registerWorkflowGateCommands(workflow, io) {
+    addJsonOption(workflow
+        .command('verify-pipeline')
+        .description(VERIFY_PIPELINE_DESCRIPTION)
+        .requiredOption('--rid <rid>', 'request identifier')
+        .requiredOption('--project <path>', 'project root path')
+        .option('--type <type>', 'request type: feature, bugfix, refactor, docs, config, chore', 'feature')
+        .option('--session-id <sid>', 'slice 2026-06-13-peaks-workflow-skip: session id under which to read the skip-state file. When omitted, no skip-state is consulted (legacy behavior).')).action((options) => runVerifyPipeline(options, io));
+    // Mark gates as bypassed for a specific rid, so the next
+    // `verify-pipeline` reports them as `status: 'skipped'` instead of
+    // missing-evidence violations. See RD
+    // for the three-rule classifier (type allowlist, one-time
+    // semantics, role-based auth).
+    addJsonOption(workflow
+        .command('skip')
+        .description(SKIP_DESCRIPTION)
+        .requiredOption('--rid <rid>', 'request identifier')
+        .requiredOption('--project <path>', 'project root path')
+        .requiredOption('--gates <list>', 'comma-separated gate names (e.g. "QA" or "QA,slice-check" or "code-review,security-review")')
+        .requiredOption('--reason <text>', 'free-text justification; persisted in the state file and surfaced in verify-pipeline nextActions')
+        .option('--dry-run', 'preview the skip; do not write the state file')
+        .option('--i-have-reviewed', 'required when caller is a script (CI / postinstall / cron). LLM and human callers do not need this.')).action((options) => runWorkflowSkip(options, io));
+}

package/dist/cli/commands/workflow-plan-commands-actions.js

@@ -1,5 +1,4 @@
 /**
- * Action handlers for the `peaks workflow plan` subcommands (slice 025).
  *
  * Extracted from `workflow-plan-commands.ts` (strict-remediation c1). The
  * command registration re-exports these as its programmatic test entry points.
@@ -14,7 +13,6 @@ import { refreshPlan } from '../../services/workflow/plan-refresher.js';
 import { detectTrigger } from '../../services/workflow/plan-trigger-detector.js';
 import { resolveProjectRoot, resolveSessionId } from './workflow-plan-commands-session.js';
 const VALID_TYPES = ['security', 'perf'];
-// F-1 (slice 025 security): reject rids that contain path separators,
 // null bytes, or traversal sequences.
 const REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 function isPlanType(value) {

package/dist/cli/commands/workflow-plan-commands-session.js

@@ -1,6 +1,5 @@
 /**
  * Shared session-id / project-root resolution for the `peaks workflow plan`
- * command family (slice 025).
  *
  * Extracted from `workflow-plan-commands.ts` (strict-remediation c1) so one
  * implementation backs every plan subcommand instead of the per-command copies
@@ -12,7 +11,6 @@ import { fail } from 'peaks-loop-shared/result';
 import { printResult } from '../cli-helpers.js';
 import { getSessionId } from '../../services/session/session-manager.js';
 import { findProjectRoot } from '../../services/config/config-safety.js';
-// F-1 (slice 025 security): reject session ids that look like path
 // traversal payloads. Canonical pattern is YYYY-MM-DD-<slug>.
 const SESSION_ID_PATTERN = /^\d{4}-\d{2}-\d{2}-[a-z][a-z0-9-]*[a-z0-9]$/;
 export function isValidSessionId(value) {

package/dist/cli/commands/workflow-plan-commands.d.ts

@@ -1,5 +1,4 @@
 /**
- * `peaks workflow plan <read|refresh|detect-trigger>` — slice 025 CLI.
  *
  * Three subcommands under the existing `peaks workflow` verb:
  * - `read <security|perf> --project <repo> --json`

package/dist/cli/commands/workflow-plan-helpers.d.ts

@@ -0,0 +1,48 @@
+import { type ProgramIO } from '../cli-helpers.js';
+import { type CodeMode } from '../../services/workflow/workflow-router-service.js';
+import type { WorkspaceConfig } from '../../services/config/config-types.js';
+export declare function buildDocFetcher(sid: string): import('../../services/context/doc-retriever.js').DocFetcher;
+export declare function ensureContextForRd(goal: string, project: string, sid: string): Promise<void>;
+export interface WorkspaceContext {
+    workspace?: WorkspaceConfig;
+    artifactWorkspacePath?: string;
+    sessionId?: string;
+    sessionDir?: string;
+    projectRoot?: string;
+}
+export interface TechPlanOptions {
+    goal: string;
+    swarm?: boolean;
+    dryRun?: boolean;
+    json?: boolean;
+}
+export interface TechStatusOptions {
+    json?: boolean;
+}
+export interface WorkflowRouteOptions {
+    mode: string;
+    goal: string;
+    codeMode?: string;
+    maxWorkers: string;
+    dryRun?: boolean;
+    json?: boolean;
+}
+export interface SwarmPlanOptions {
+    skill?: string;
+    goal: string;
+    maxWorkers: string;
+    dryRun?: boolean;
+    json?: boolean;
+    strictStandards?: boolean;
+}
+export interface AutonomousResumeInitOptions {
+    goal: string;
+    project: string;
+    apply?: boolean;
+    json?: boolean;
+}
+export declare function getCurrentWorkspaceContext(): WorkspaceContext;
+export declare function getWorkflowWorkspaceContext(): WorkspaceContext;
+export declare function parseMaxWorkers(io: ProgramIO, command: string, value: string, asJson?: boolean): number | null;
+export declare function validatePlanningInput(goal: string): void;
+export declare function parseCodeMode(io: ProgramIO, command: string, mode: string, codeMode: string | undefined, asJson?: boolean): CodeMode | undefined | null;

package/dist/cli/commands/workflow-plan-helpers.js

@@ -0,0 +1,103 @@
+// The planning helpers `peaks refactor | tech | workflow | swarm` share: the workspace
+// context readers, the injected-input parsers, and the pre-step that builds
+// peaks-context before peaks-rd runs. No command is registered here.
+import { printResult } from '../cli-helpers.js';
+import { fail } from 'peaks-loop-shared/result';
+import { isCodeMode } from '../../services/workflow/workflow-router-service.js';
+import { getWorkspaceConfigForPath } from '../../services/config/config-service.js';
+import { getLocalArtifactPath } from '../../services/artifacts/workspace-service.js';
+import { getSessionId } from '../../services/session/session-manager.js';
+import { getSessionDir } from '../../services/session/getSessionDir.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+// Plan 1 / Task 9 — auto-build peaks-context before peaks-rd runs.
+import { buildContext } from '../../services/context/context-builder.js';
+// Plan 1 / Task 10 — production fetcher (replaces mockFetcher).
+import { createDocCacheFetcher } from '../../services/context/doc-cache-fetcher.js';
+export function buildDocFetcher(sid) {
+    return createDocCacheFetcher({
+        cacheDir: `.peaks/_runtime/${sid}/doc-cache`
+        // remoteFetcher wired in a future slice.
+    });
+}
+export async function ensureContextForRd(goal, project, sid) {
+    const out = `.peaks/_runtime/${sid}/context.json`;
+    try {
+        await buildContext({
+            goal,
+            project,
+            audience: 'peaks-rd',
+            depsMode: 'locked',
+            docBudgetTokens: 8000,
+            out,
+            fetcher: buildDocFetcher(sid)
+        });
+    }
+    catch (error) {
+        // Plan 1 / Task 9 — context is a pre-step, not a precondition.
+        // If the Collector (e.g. missing package.json) or DocRetriever
+        // fails, we still want the rd slice to proceed. Task 11
+        // upgrades this to a hard precondition once the rd slice
+        // actually consumes context.json.
+        const message = error instanceof Error ? error.message : 'unknown context build failure';
+        process.stderr.write(`[peaks-context] rd pre-step skipped: ${message}\n`);
+    }
+}
+export function getCurrentWorkspaceContext() {
+    try {
+        const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+        const sessionId = getSessionId(projectRoot);
+        return sessionId ? { sessionId, sessionDir: getSessionDir(projectRoot, sessionId) } : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function getWorkflowWorkspaceContext() {
+    try {
+        const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+        const workspace = getWorkspaceConfigForPath(projectRoot);
+        if (!workspace)
+            return { projectRoot };
+        return { projectRoot, workspace, artifactWorkspacePath: getLocalArtifactPath(workspace) };
+    }
+    catch {
+        return {};
+    }
+}
+export function parseMaxWorkers(io, command, value, asJson) {
+    const maxWorkers = Number(value);
+    if (!Number.isInteger(maxWorkers) || maxWorkers < 1) {
+        printResult(io, fail(command, 'INVALID_MAX_WORKERS', 'max-workers must be a positive integer', {}, [
+            'Use --max-workers with a positive integer value'
+        ]), asJson);
+        process.exitCode = 1;
+        return null;
+    }
+    return maxWorkers;
+}
+export function validatePlanningInput(goal) {
+    // v2.17.0: change-id axis removed. The planning input is now keyed
+    // by the session id (already bound via `peaks workspace init`),
+    // not by a user-supplied change-id. Only the goal is validated.
+    if (!goal.trim()) {
+        throw new Error('Goal must be non-empty');
+    }
+}
+export function parseCodeMode(io, command, mode, codeMode, asJson) {
+    if (mode !== 'code' && codeMode) {
+        printResult(io, fail(command, 'CODE_MODE_REQUIRES_CODE_WORKFLOW', '--code-mode can only be used with --mode code', {}, ['Remove --code-mode or use --mode code']), asJson);
+        process.exitCode = 1;
+        return null;
+    }
+    if (mode !== 'code' || !codeMode) {
+        return undefined;
+    }
+    if (!isCodeMode(codeMode)) {
+        printResult(io, fail(command, 'UNSUPPORTED_CODE_MODE', `Unsupported code mode ${codeMode}`, {}, [
+            'Use --code-mode full-auto, guided, or rnd'
+        ]), asJson);
+        process.exitCode = 1;
+        return null;
+    }
+    return codeMode;
+}

package/dist/cli/commands/workflow-planning-commands.d.ts

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

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

@@ -0,0 +1,56 @@
+import { addJsonOption, failUnsupportedNonDryRun, printResult } from '../cli-helpers.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { createRefactorDryRun } from '../../services/refactor/refactor-service.js';
+// `peaks tech status-change-id`). Additive; the existing session-axis
+// `peaks tech plan` / `peaks tech status` registrations are untouched.
+import { registerTechCommands } from './tech-commands.js';
+import { addTechPlanOptions, addTechStatusOptions, addWorkflowRouteOptions, runAutonomousWorkflow, runTechPlan, runTechStatus, runWorkflowRoute } from './workflow-tech-actions.js';
+import { addAutonomousResumeInitOptions, runAutonomousResumeInit } from './workflow-swarm-actions.js';
+/** The `peaks refactor` registration, lifted verbatim out of the planning registrar. */
+function registerRefactorCommand(program, io) {
+    const refactor = program
+        .command('refactor')
+        .description('Plan a Peaks refactor run without modifying code');
+    addJsonOption(refactor
+        .option('--code', 'use peaks-code orchestration mode')
+        .option('--rd', 'use peaks-rd direct mode')
+        .option('--dry-run', 'print gates and required artifacts', true)
+        .option('--no-dry-run', 'unsupported: do not modify code from this command')).action((options) => {
+        if (options.dryRun === false) {
+            failUnsupportedNonDryRun(io, 'refactor', options.json);
+            return;
+        }
+        if (options.code && options.rd) {
+            printResult(io, fail('refactor', 'CONFLICTING_REFACTOR_MODE', 'Choose either --code or --rd, not both', {}, ['Run peaks refactor --code --dry-run']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        const mode = options.rd ? 'rd' : 'code';
+        printResult(io, ok('refactor', createRefactorDryRun(mode), [], ['This dry run never edits code']), options.json);
+    });
+}
+export function registerWorkflowPlanningCommands(program, io) {
+    registerRefactorCommand(program, io);
+    const tech = program.command('tech').description('Plan and inspect technical dry-run gates');
+    addTechPlanOptions(tech.command('plan')).action((options) => runTechPlan(io, options));
+    addTechStatusOptions(tech.command('status')).action((options) => runTechStatus(io, options));
+    addTechPlanOptions(program.command('tech-plan')).action((options) => runTechPlan(io, options));
+    addTechStatusOptions(program.command('tech-status')).action((options) => runTechStatus(io, options));
+    // (`peaks tech plan-change-id` / `peaks tech status-change-id`).
+    // Additive; the session-axis registrations above are byte-for-byte untouched.
+    registerTechCommands(program, io);
+    const workflow = program.command('workflow').description('Plan workflow routing dry-run graphs');
+    addWorkflowRouteOptions(workflow.command('route'), 'Plan a workflow routing dry-run summary').action((options) => runWorkflowRoute(io, options));
+    addWorkflowRouteOptions(program.command('route'), 'Plan a workflow routing dry-run summary').action((options) => runWorkflowRoute(io, options));
+    addWorkflowRouteOptions(workflow.command('autonomous'), 'Plan an autonomous workflow handoff summary').action((options) => runAutonomousWorkflow(io, options));
+    addWorkflowRouteOptions(program.command('autonomous'), 'Plan an autonomous workflow handoff summary').action((options) => runAutonomousWorkflow(io, options));
+    const autonomousResume = workflow
+        .command('autonomous-resume')
+        .description('Manage autonomous workflow resume artifacts');
+    addAutonomousResumeInitOptions(autonomousResume.command('init')).action((options) => runAutonomousResumeInit(io, options));
+    const autonomousResumeAlias = program
+        .command('autonomous-resume')
+        .description('Manage autonomous workflow resume artifacts');
+    addAutonomousResumeInitOptions(autonomousResumeAlias.command('init')).action((options) => runAutonomousResumeInit(io, options));
+    return workflow;
+}

package/dist/cli/commands/workflow-swarm-actions.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+import { type AutonomousResumeInitOptions, type SwarmPlanOptions } from './workflow-plan-helpers.js';
+export declare function runSwarmPlan(io: ProgramIO, options: SwarmPlanOptions): Promise<void>;
+export declare function runAutonomousResumeInit(io: ProgramIO, options: AutonomousResumeInitOptions): Promise<void>;
+export declare function addSwarmPlanOptions(command: Command, includeSkill: boolean): Command;
+export declare function addAutonomousResumeInitOptions(command: Command): Command;

package/dist/cli/commands/workflow-swarm-actions.js

@@ -0,0 +1,109 @@
+import { createRdSwarmPlan } from '../../services/rd/rd-service.js';
+import { writeAutonomousResumeArtifacts } from '../../services/workflow/autonomous-resume-writer.js';
+import { readConfig } from '../../services/config/config-service.js';
+import { getEconomyAwareExecutionModelId } from '../../services/config/model-routing.js';
+import { getSessionId } from '../../services/session/session-manager.js';
+import { addJsonOption, failUnsupportedNonDryRun, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+// catch site below (swarm.plan) so provider-config errors surface as
+// `INVALID_PROVIDERS` instead of being silently re-labelled `INVALID_GOAL`.
+import { mapServiceError } from './_cli-error-envelope.js';
+import { ensureContextForRd, getWorkflowWorkspaceContext, parseMaxWorkers, validatePlanningInput } from './workflow-plan-helpers.js';
+export async function runSwarmPlan(io, options) {
+    if ((options.skill ?? 'rd') !== 'rd') {
+        printResult(io, fail('swarm.plan', 'UNSUPPORTED_SWARM_SKILL', `Unsupported skill ${options.skill}`, {}, [
+            'Use --skill rd'
+        ]), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    if (options.dryRun === false) {
+        failUnsupportedNonDryRun(io, 'swarm.plan', options.json);
+        return;
+    }
+    const maxWorkers = parseMaxWorkers(io, 'swarm.plan', options.maxWorkers, options.json);
+    if (maxWorkers === null)
+        return;
+    try {
+        validatePlanningInput(options.goal);
+        const workspaceContext = getWorkflowWorkspaceContext();
+        const config = readConfig();
+        // Plan 1 / Task 9 — pre-build peaks-context before peaks-rd runs.
+        const projectRoot = workspaceContext.projectRoot ?? process.cwd();
+        const sid = getSessionId(projectRoot) ?? 'ad-hoc';
+        await ensureContextForRd(options.goal, projectRoot, sid);
+        const plan = createRdSwarmPlan({
+            skill: 'rd',
+            sessionId: '',
+            goal: options.goal,
+            maxWorkers,
+            dryRun: true,
+            swarmMode: config.swarmMode ?? true,
+            executionModelId: getEconomyAwareExecutionModelId(config),
+            ...(options.strictStandards ? { strictStandards: true } : {}),
+            ...workspaceContext
+        });
+        // The service-layer stamps `standardsErrorCode` onto the envelope; the
+        // CLI is responsible for translating it into a non-zero exit.
+        if (plan.gateStatus.standardsErrorCode === 'EPEAKS_NO_STANDARDS') {
+            process.exitCode = 1;
+        }
+        printResult(io, ok('swarm.plan', plan), options.json);
+    }
+    catch (error) {
+        const mapping = mapServiceError(error);
+        printResult(io, fail('swarm.plan', mapping.code, getErrorMessage(error), {}, [...mapping.nextActions]), options.json);
+        process.exitCode = 1;
+    }
+}
+export async function runAutonomousResumeInit(io, options) {
+    try {
+        if (!options.project || !options.project.trim()) {
+            throw new Error('Project path must be non-empty');
+        }
+        // gone. The CLI surfaces a deterministic placeholder
+        // (`session-default`) when the user does not pass a change-id, so
+        // the on-disk session-dir join via `getSessionDir` succeeds (the
+        // writer still requires a safe non-empty string).
+        const result = await writeAutonomousResumeArtifacts({
+            sessionId: 'session-default',
+            goal: options.goal,
+            artifactWorkspacePath: options.project,
+            apply: options.apply === true
+        });
+        const data = {
+            applied: result.applied,
+            files: result.files.map((file) => file.path)
+        };
+        const nextActions = result.applied
+            ? ['Run peaks workflow autonomous --goal "<goal>" --json to verify resumePlan.status']
+            : ['Re-run with --apply to write the resume scaffold to disk'];
+        printResult(io, ok('autonomous-resume.init', data, [], nextActions), options.json);
+    }
+    catch (error) {
+        printResult(io, fail('autonomous-resume.init', 'AUTONOMOUS_RESUME_INIT_FAILED', getErrorMessage(error), {}, [
+            'Use a non-empty goal and a writable project path'
+        ]), options.json);
+        process.exitCode = 1;
+    }
+}
+export function addSwarmPlanOptions(command, includeSkill) {
+    const configured = command
+        .description('Plan an RD swarm dry-run graph')
+        .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 RD planning from this CLI')
+        .option('--strict-standards', 'hard-fail (exit non-zero) when project-local standards are missing; surfaces EPEAKS_NO_STANDARDS in the JSON envelope');
+    if (includeSkill) {
+        configured.requiredOption('--skill <skill>', 'skill to plan for');
+    }
+    return addJsonOption(configured);
+}
+export function addAutonomousResumeInitOptions(command) {
+    return addJsonOption(command
+        .description('Write the autonomous resume artifact scaffold for the active change-id')
+        .requiredOption('--goal <goal>', 'planning goal')
+        .requiredOption('--project <path>', 'artifact workspace path to write under')
+        .option('--apply', 'write the artifacts to disk (default is dry-run preview)'));
+}

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

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

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

@@ -0,0 +1,138 @@
+import { addJsonOption, isRecommendationWorkflow, printResult } from '../cli-helpers.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { createRecommendationPlan } from '../../services/recommendations/recommendation-service.js';
+import { readConfig } from '../../services/config/config-service.js';
+import { registerSwarmCommands } from './swarm-commands.js';
+// `registerTechCommands` registrations are byte-for-byte untouched.
+import { registerAutonomousSwarmCommands } from './autonomous-swarm-commands.js';
+// Slice 4.0.8 — workflow lifecycle (init / graph show / graph list / node
+// prepare / node ack / node mark-lost / terminalize). Registered as a
+// sibling command group, not merged with planning handlers, per RD §4.
+import { registerWorkflowLifecycleCommand } from './workflow-lifecycle-commands.js';
+import { addSwarmPlanOptions, runSwarmPlan } from './workflow-swarm-actions.js';
+/** The `13.2` pipeline placeholder action, lifted verbatim out of the registrar. */
+function runSwarmPipelinePlaceholder(options, io) {
+    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);
+}
+/** The `13.3` speculative-dispatch placeholder action, lifted verbatim out of the registrar. */
+function runSwarmDispatchPlaceholder(options, io) {
+    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);
+}
+/** The `13.4` adversarial-verification placeholder action, lifted verbatim out of the registrar. */
+function runSwarmVerifyPlaceholder(options, io) {
+    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);
+}
+/** The `13.5` loop-until-dry placeholder action, lifted verbatim out of the registrar. */
+function runSwarmLoopPlaceholder(options, io) {
+    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);
+}
+/** The `peaks recommend` action, lifted verbatim out of the registrar. */
+function runRecommendAction(options, io) {
+    if (!isRecommendationWorkflow(options.workflow)) {
+        printResult(io, fail('recommend', 'UNSUPPORTED_RECOMMENDATION_WORKFLOW', `Unsupported recommendation workflow ${options.workflow}`, {}, ['Use --workflow code-refactor, product-refactor, or frontend-design']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    printResult(io, ok('recommend', createRecommendationPlan({
+        workflow: options.workflow,
+        language: options.language ?? readConfig().language ?? 'en'
+    })), options.json);
+}
+/** The four slice-#13 placeholder subcommands of `peaks swarm`, lifted verbatim out of the registrar. */
+function registerSwarmPlaceholderCommands(swarm, io) {
+    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) => runSwarmPipelinePlaceholder(options, io));
+    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) => runSwarmDispatchPlaceholder(options, io));
+    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) => runSwarmVerifyPlaceholder(options, io));
+    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) => runSwarmLoopPlaceholder(options, io));
+}
+export function registerWorkflowSwarmCommands(program, io) {
+    // `registerSwarmCommands` (a thin wrapper around the new
+    // `planRdSwarmGraph` service). The legacy `peaks swarm plan` /
+    // `peaks swarm-plan` registrations above stay in-place for back-compat
+    const swarm = program.command('swarm').description('Plan RD swarm dry-run graphs');
+    addSwarmPlanOptions(swarm.command('plan'), true).action(async (options) => {
+        await runSwarmPlan(io, options);
+    });
+    addSwarmPlanOptions(program.command('swarm-plan'), false).action(async (options) => {
+        await runSwarmPlan(io, options);
+    });
+    registerSwarmCommands(program, io);
+    // above are byte-for-byte untouched.
+    registerAutonomousSwarmCommands(program, io);
+    // Slice 4.0.8 — workflow lifecycle CLI (init / graph show / graph list /
+    // node prepare / node ack / node mark-lost / terminalize). Registered
+    // sibling to planning handlers per RD §4.
+    registerWorkflowLifecycleCommand(program, io);
+    // Slice #13 Swarm Algorithm Upgrade — 4 additional subcommands.
+    // (peaks swarm plan above is slice #13.1; the 4 below are 13.2-13.5).
+    registerSwarmPlaceholderCommands(swarm, io);
+    addJsonOption(program
+        .command('recommend')
+        .description('Create a dry-run recommendation plan for a workflow')
+        .requiredOption('--workflow <workflow>', 'workflow: code-refactor, product-refactor, or frontend-design')
+        .option('--language <language>', 'human presentation language')).action((options) => runRecommendAction(options, io));
+}

package/dist/cli/commands/workflow-tech-actions.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+import { type TechPlanOptions, type TechStatusOptions, type WorkflowRouteOptions } from './workflow-plan-helpers.js';
+export declare function runTechPlan(io: ProgramIO, options: TechPlanOptions): void;
+export declare function runTechStatus(io: ProgramIO, options: TechStatusOptions): void;
+export declare function runWorkflowRoute(io: ProgramIO, options: WorkflowRouteOptions): void;
+export declare function runAutonomousWorkflow(io: ProgramIO, options: WorkflowRouteOptions): void;
+export declare function addTechPlanOptions(command: Command): Command;
+export declare function addTechStatusOptions(command: Command): Command;
+export declare function addWorkflowRouteOptions(command: Command, description: string): Command;