peaks-cli 1.0.21 → 1.0.23

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

@@ -1,5 +1,16 @@
 import { Command } from 'commander';
 import type { PeaksConfig } from '../../services/config/config-types.js';
+import type { CapabilityMapSourceFilter } from '../../services/recommendations/recommendation-types.js';
 import { type ProgramIO } from '../cli-helpers.js';
+type CapabilityMapOptions = {
+    json?: boolean;
+    source: string;
+};
 export declare function registerCapabilityCommands(program: Command, io: ProgramIO): void;
-export declare function getInstalledCapabilityIds(config: PeaksConfig): string[];
+export declare function runCapabilityStatus(io: ProgramIO, options: {
+    json?: boolean;
+}): void;
+export declare function runCapabilityMap(io: ProgramIO, options: CapabilityMapOptions): void;
+export declare function getInstalledCapabilityIds(_config: PeaksConfig): string[];
+export declare function parseCapabilityMapSource(source: string): CapabilityMapSourceFilter | null;
+export {};

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

@@ -7,17 +7,18 @@ import { addJsonOption, printResult } from '../cli-helpers.js';
 const CAPABILITY_SOURCE_FILTERS = new Set(['all', 'access-repo', 'mcp-server']);
 export function registerCapabilityCommands(program, io) {
     const capability = program.command('capability').description('Inspect Peaks capability catalog and runtime availability');
-    addJsonOption(capability.command('status').description('Show seed capability availability')).action((options) => {
-        const availability = resolveCapabilityAvailability(seedCapabilityItems);
-        printResult(io, ok('capability.status', { sources: seedCapabilitySources, items: seedCapabilityItems, availability }), options.json);
-    });
+    addJsonOption(capability.command("status").description("Show seed capability availability")).action((options) => runCapabilityStatus(io, options));
     addCapabilityMapOptions(capability.command('map').description('Show dry-run external capability landing map')).action((options) => runCapabilityMap(io, options));
     addCapabilityMapOptions(program.command('capabilities').description('Show dry-run external capability landing map')).action((options) => runCapabilityMap(io, options));
 }
+export function runCapabilityStatus(io, options) {
+    const availability = resolveCapabilityAvailability(seedCapabilityItems);
+    printResult(io, ok("capability.status", { sources: seedCapabilitySources, items: seedCapabilityItems, availability }), options.json);
+}
 function addCapabilityMapOptions(command) {
     return addJsonOption(command.option('--source <source>', 'Filter source group: all, access-repo, or mcp-server', 'all'));
 }
-function runCapabilityMap(io, options) {
+export function runCapabilityMap(io, options) {
     const source = parseCapabilityMapSource(options.source);
     if (!source) {
         printResult(io, fail('capabilities.map', 'UNSUPPORTED_CAPABILITY_SOURCE', 'Supported capability sources are all, access-repo, and mcp-server', { source: options.source }, ['Rerun with --source all, --source access-repo, or --source mcp-server']), options.json);
@@ -32,13 +33,10 @@ function runCapabilityMap(io, options) {
         ...(config.proxy.httpProxy === undefined ? {} : { httpProxy: config.proxy.httpProxy })
     })), options.json);
 }
-export function getInstalledCapabilityIds(config) {
-    const currentWorkspace = config.workspaces.find((workspace) => workspace.workspaceId === config.currentWorkspace);
-    if (!currentWorkspace)
-        return [];
-    return [...currentWorkspace.installedCapabilityIds];
+export function getInstalledCapabilityIds(_config) {
+    return [];
 }
-function parseCapabilityMapSource(source) {
+export function parseCapabilityMapSource(source) {
     if (CAPABILITY_SOURCE_FILTERS.has(source)) {
         return source;
     }

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

@@ -1,12 +1,11 @@
-import { addWorkspace, getConfig, getMiniMaxProviderConfig, getMiniMaxProviderStatus, isSensitiveConfigPath, readConfig, redactConfigSecrets, removeWorkspace, setConfig, setCurrentWorkspace, setMiniMaxProviderConfig } from '../../services/config/config-service.js';
+import { getConfig, getMiniMaxProviderConfig, getMiniMaxProviderStatus, isSensitiveConfigPath, redactConfigSecrets, setConfig, setMiniMaxProviderConfig } from '../../services/config/config-service.js';
 import { testMiniMaxProvider } from '../../services/providers/minimax-provider-service.js';
 import { fail, ok } from '../../shared/result.js';
-import { addJsonOption, getErrorMessage, isArtifactProvider, isArtifactRepoSegment, isMiniMaxHttpsUrl, parseConfigLayer, printInvalidConfigLayer, printResult, redactSensitiveErrorMessage, summarizeMiniMaxSmokeResult } from '../cli-helpers.js';
+import { addJsonOption, getErrorMessage, isMiniMaxHttpsUrl, parseConfigLayer, printInvalidConfigLayer, printResult, redactSensitiveErrorMessage, summarizeMiniMaxSmokeResult } from '../cli-helpers.js';
 export function registerConfigCommands(program, io) {
     const config = program.command('config').description('Manage Peaks configuration');
     registerConfigGetSetCommands(config, io);
     registerMiniMaxProviderCommands(config, io);
-    registerWorkspaceCommands(config, io);
 }
 function registerConfigGetSetCommands(config, io) {
     addJsonOption(config.command('get').description('Get current config or a specific key').option('--key <path>', 'dot-notation key path').option('--layer <layer>', 'user or project')).action((options) => {
@@ -129,85 +128,3 @@ function printMiniMaxProviderSetError(io, error, asJson) {
     printResult(io, fail('config.provider.minimax.set', 'MINIMAX_PROVIDER_SET_FAILED', getErrorMessage(error), {}, ['Check MiniMax provider settings and retry']), asJson);
     process.exitCode = 1;
 }
-function registerWorkspaceCommands(config, io) {
-    const configWorkspace = config.command('workspace').description('Manage workspaces');
-    addJsonOption(configWorkspace.command('list').description('List all workspaces')).action((options) => {
-        const cfg = readConfig();
-        printResult(io, ok('config.workspace.list', { currentWorkspace: cfg.currentWorkspace, workspaces: cfg.workspaces }), options.json);
-    });
-    addJsonOption(configWorkspace.command('add').description('Add a workspace').requiredOption('--id <id>', 'workspace identifier').requiredOption('--name <name>', 'workspace display name').requiredOption('--path <path>', 'workspace root path').option('--provider <provider>', 'artifact repo provider: github or gitlab').option('--repo-owner <owner>', 'artifact repo owner').option('--repo-name <name>', 'artifact repo name').option('--layer <layer>', 'user or project')).action((options) => {
-        const layer = parseConfigLayer(options.layer);
-        if (layer === null) {
-            printInvalidConfigLayer(io, 'config.workspace.add', options.json);
-            return;
-        }
-        const artifactRepo = parseArtifactRepoInput(io, options, options.json);
-        if (artifactRepo === null)
-            return;
-        const artifactStorage = artifactRepo ? { mode: 'local-with-remote-sync', remote: artifactRepo } : { mode: 'local' };
-        const workspace = { workspaceId: options.id, name: options.name, rootPath: options.path, installedCapabilityIds: [], artifactStorage };
-        const configLayer = layer ?? 'user';
-        if (artifactRepo) {
-            addWorkspace({ ...workspace, artifactRepo }, configLayer);
-        }
-        else {
-            addWorkspace(workspace, configLayer);
-        }
-        printResult(io, ok('config.workspace.add', { workspaceId: options.id, name: options.name, rootPath: options.path, artifactRepo, artifactStorage }), options.json);
-    });
-    addJsonOption(configWorkspace.command('remove').description('Remove a workspace').requiredOption('--id <id>', 'workspace identifier').option('--layer <layer>', 'user or project')).action((options) => {
-        const layer = parseConfigLayer(options.layer);
-        if (layer === null) {
-            printInvalidConfigLayer(io, 'config.workspace.remove', options.json);
-            return;
-        }
-        const configLayer = layer ?? 'user';
-        const removed = removeWorkspace(options.id, configLayer);
-        if (removed) {
-            printResult(io, ok('config.workspace.remove', { workspaceId: options.id }), options.json);
-        }
-        else {
-            printWorkspaceNotFound(io, 'config.workspace.remove', `Workspace ${options.id} not found`, options.json);
-        }
-    });
-    addJsonOption(configWorkspace.command('switch').description('Switch current workspace').requiredOption('--id <id>', 'workspace identifier').option('--layer <layer>', 'user or project')).action((options) => {
-        const layer = parseConfigLayer(options.layer);
-        if (layer === null) {
-            printInvalidConfigLayer(io, 'config.workspace.switch', options.json);
-            return;
-        }
-        const configLayer = layer ?? 'user';
-        const switched = setCurrentWorkspace(options.id, configLayer);
-        if (switched) {
-            printResult(io, ok('config.workspace.switch', { currentWorkspace: options.id }), options.json);
-        }
-        else {
-            printWorkspaceNotFound(io, 'config.workspace.switch', `Workspace ${options.id} not found`, options.json);
-        }
-    });
-}
-function parseArtifactRepoInput(io, options, asJson) {
-    const hasArtifactRepoInput = options.provider !== undefined || options.repoOwner !== undefined || options.repoName !== undefined;
-    if (!hasArtifactRepoInput)
-        return undefined;
-    if (!options.provider || !options.repoOwner || !options.repoName) {
-        printResult(io, fail('config.workspace.add', 'INVALID_ARTIFACT_REPO_CONFIG', 'Artifact repo config requires --provider, --repo-owner, and --repo-name together', {}, ['Provide all three artifact repo options together, or omit them all']), asJson);
-        process.exitCode = 1;
-        return null;
-    }
-    if (!isArtifactProvider(options.provider)) {
-        printResult(io, fail('config.workspace.add', 'UNSUPPORTED_ARTIFACT_PROVIDER', `Unsupported provider ${options.provider}`, {}, ['Use --provider github or --provider gitlab']), asJson);
-        process.exitCode = 1;
-        return null;
-    }
-    if (!isArtifactRepoSegment(options.repoOwner) || !isArtifactRepoSegment(options.repoName)) {
-        printResult(io, fail('config.workspace.add', 'INVALID_ARTIFACT_REPO_CONFIG', 'Artifact repo owner and name must use safe GitHub/GitLab path segments', {}, ['Use letters, numbers, dots, underscores, or hyphens without path traversal']), asJson);
-        process.exitCode = 1;
-        return null;
-    }
-    return { provider: options.provider, owner: options.repoOwner, name: options.repoName };
-}
-function printWorkspaceNotFound(io, command, message, asJson) {
-    printResult(io, fail(command, 'WORKSPACE_NOT_FOUND', message, {}, ['List workspaces with: peaks config workspace list']), asJson);
-    process.exitCode = 1;
-}

package/dist/src/cli/commands/core-artifact-commands.js

@@ -7,7 +7,7 @@ import { planProxyTest } from '../../services/proxy/proxy-service.js';
 import { runDoctor } from '../../services/doctor/doctor-service.js';
 import { listSkills } from '../../services/skills/skill-registry.js';
 import { inspectSkillRunbook } from '../../services/skills/skill-runbook-service.js';
-import { setSkillPresence, clearSkillPresence, getSkillPresence } from '../../services/skills/skill-presence-service.js';
+import { setSkillPresence, clearSkillPresence, getSkillPresence, isSkillPresenceMode } from '../../services/skills/skill-presence-service.js';
 import { fail, ok } from '../../shared/result.js';
 import { addJsonOption, failUnsupportedNonDryRun, getErrorMessage, isArtifactProvider, isArtifactSetupStep, printResult } from '../cli-helpers.js';
 export function registerCoreAndArtifactCommands(program, io) {
@@ -72,6 +72,11 @@ export function registerCoreAndArtifactCommands(program, io) {
         .description('Set the currently active Peaks skill for session-wide visibility')
         .option('--mode <mode>', 'execution mode')
         .option('--gate <gate>', 'current gate')).action((name, options) => {
+        if (options.mode !== undefined && !isSkillPresenceMode(options.mode)) {
+            printResult(io, fail('skill.presence:set', 'INVALID_MODE', `Invalid mode: ${options.mode} (expected one of: full-auto, assisted, swarm, strict)`, { name, mode: options.mode }, ['Use a valid mode: full-auto, assisted, swarm, or strict']), options.json);
+            process.exitCode = 1;
+            return;
+        }
         const presence = setSkillPresence(name, options.mode, options.gate);
         printResult(io, ok('skill.presence:set', { active: true, ...presence }), options.json);
     });

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

@@ -1,5 +1,7 @@
 import { InvalidArgumentError } from 'commander';
-import { allowedStatesForRole, createRequestArtifact, listRequestArtifacts, showRequestArtifact, transitionRequestArtifact, PrerequisitesNotSatisfiedError, VALID_REQUEST_TYPES, isRequestType } from '../../services/artifacts/request-artifact-service.js';
+import { allowedStatesForRole, createRequestArtifact, listRequestArtifacts, showRequestArtifact, transitionRequestArtifact, PrerequisitesNotSatisfiedError, LintGateError, TypeSanityViolationError, FileSizeViolationError, VALID_REQUEST_TYPES, isRequestType } from '../../services/artifacts/request-artifact-service.js';
+import { ConfirmationRequiredError } from '../../services/mode/mode-enforcement.js';
+import { recordBypass, isBypassLimitReached, MAX_BYPASSES_PER_SESSION } from '../../services/mode/bypass-tracker.js';
 import { lintRequestArtifact } from '../../services/artifacts/artifact-lint-service.js';
 import { getRepairCycleStatus } from '../../services/artifacts/repair-cycle-service.js';
 import { fail, ok } from '../../shared/result.js';
@@ -118,7 +120,9 @@ export function registerRequestCommands(program, io) {
         .requiredOption('--project <path>', 'target project root')
         .option('--session-id <session>', 'restrict to a specific session id')
         .option('--reason <text>', 'reason appended as a transition note; required when --allow-incomplete is set')
-        .option('--allow-incomplete', 'bypass artifact prerequisite checks; requires --reason and records the bypass in the artifact')).action(async (requestId, options) => {
+        .option('--allow-incomplete', 'bypass artifact prerequisite checks; requires --reason and records the bypass in the artifact')
+        .option('--confirm', 'skip interactive confirmation prompt (for non-interactive / LLM contexts)')
+        .option('--force-confirm', 'bypass mode-enforced confirmation (use with caution)')).action(async (requestId, options) => {
         try {
             const role = options.role;
             const newState = parseStateForRole(role, options.state);
@@ -127,6 +131,26 @@ export function registerRequestCommands(program, io) {
                 process.exitCode = 1;
                 return;
             }
+            // Restrict --allow-incomplete in assisted/strict modes: require --confirm
+            if (options.allowIncomplete === true && options.forceConfirm !== true) {
+                const { getSkillPresence } = await import('../../services/skills/skill-presence-service.js');
+                const presence = getSkillPresence();
+                if (presence?.mode === 'assisted' || presence?.mode === 'strict') {
+                    if (options.confirm !== true) {
+                        printResult(io, fail('request.transition', 'ALLOW_INCOMPLETE_RESTRICTED', `--allow-incomplete requires --confirm in ${presence.mode} mode`, { role, requestId, mode: presence.mode }, ['Add --confirm to proceed non-interactively, or run in an interactive terminal.']), options.json);
+                        process.exitCode = 1;
+                        return;
+                    }
+                    // Check bypass count
+                    const sessionRoot = (await import('node:path')).join(options.project, '.peaks', options.sessionId ?? 'default');
+                    if (isBypassLimitReached(sessionRoot)) {
+                        printResult(io, fail('request.transition', 'BYPASS_LIMIT_REACHED', `--allow-incomplete limit reached (${MAX_BYPASSES_PER_SESSION} per session)`, { role, requestId, limit: MAX_BYPASSES_PER_SESSION }, ['Produce the missing artifacts instead of bypassing.']), options.json);
+                        process.exitCode = 1;
+                        return;
+                    }
+                    recordBypass(sessionRoot);
+                }
+            }
             const transitionOptions = {
                 role,
                 requestId,
@@ -142,6 +166,28 @@ export function registerRequestCommands(program, io) {
             if (options.allowIncomplete === true) {
                 transitionOptions.allowIncomplete = true;
             }
+            if (options.confirm === true) {
+                transitionOptions.confirmed = true;
+            }
+            if (options.forceConfirm === true) {
+                transitionOptions.forceConfirm = true;
+            }
+            // Type sanity check for PRD handoff
+            if (role === 'prd' && newState === 'handed-off') {
+                const { showRequestArtifact: showForType } = await import('../../services/artifacts/request-artifact-service.js');
+                const showTypeOptions = {
+                    projectRoot: options.project,
+                    role: 'prd',
+                    requestId
+                };
+                if (options.sessionId !== undefined) {
+                    showTypeOptions.sessionId = options.sessionId;
+                }
+                const existing = await showForType(showTypeOptions);
+                if (existing !== null) {
+                    transitionOptions.typeSanityCheck = { projectRoot: options.project, declaredType: existing.requestType };
+                }
+            }
             const result = await transitionRequestArtifact(transitionOptions);
             if (result === null) {
                 printResult(io, fail('request.transition', 'REQUEST_NOT_FOUND', `No artifact found for role=${role} requestId=${requestId}`, { role, requestId }, ['Verify the request id, role, and session id']), options.json);
@@ -163,6 +209,40 @@ export function registerRequestCommands(program, io) {
                 process.exitCode = 1;
                 return;
             }
+            if (error instanceof LintGateError) {
+                printResult(io, fail('request.transition', error.code, error.message, { role: error.role, newState: error.newState, errorCount: error.errorCount }, [
+                    'Fix lint errors in the artifact before transitioning.',
+                    'Run `peaks request lint --role <role> --id <rid> --project <path>` to see details.',
+                    'Or bypass with: --allow-incomplete --reason "<justification>"'
+                ]), options.json);
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof TypeSanityViolationError) {
+                printResult(io, fail('request.transition', error.code, error.message, { declaredType: error.declaredType, suggestedTypes: error.suggestedTypes, rationale: error.rationale }, [
+                    `Re-classify the request — likely correct type: ${error.suggestedTypes.join(' | ')}`,
+                    'Or, if the declared type is correct, surface the mismatch reason to the user.'
+                ]), options.json);
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof FileSizeViolationError) {
+                printResult(io, fail('request.transition', error.code, error.message, { violations: error.violations, threshold: error.threshold }, [
+                    ...error.violations.map((v) => `Split ${v.file} (${v.lines} lines) into smaller modules (< ${error.threshold} lines)`),
+                    'Or bypass with: --allow-incomplete --reason "<justification>"'
+                ]), options.json);
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof ConfirmationRequiredError) {
+                printResult(io, fail('request.transition', 'CONFIRMATION_REQUIRED', error.message, { role: options.role, requestId }, [
+                    'Add --confirm to proceed non-interactively.',
+                    'Or run in an interactive terminal.',
+                    'In assisted/strict mode, major workflow boundaries require explicit user approval.'
+                ]), options.json);
+                process.exitCode = 1;
+                return;
+            }
             printResult(io, fail('request.transition', 'REQUEST_TRANSITION_FAILED', getErrorMessage(error), { role: options.role, requestId }, ['Check role, request id, state, and project path before retrying']), options.json);
             process.exitCode = 1;
         }

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

@@ -4,6 +4,7 @@ import { scanExistingSystem } from '../../services/scan/existing-system-service.
 import { checkTypeSanity } from '../../services/scan/type-sanity-service.js';
 import { getAcceptanceCoverage, isAcceptanceCoverageError } from '../../services/scan/acceptance-coverage-service.js';
 import { getDiffVsScope, isDiffScopeError } from '../../services/scan/diff-scope-service.js';
+import { scanFileSize, DEFAULT_FILE_SIZE_THRESHOLD } from '../../services/scan/file-size-scan.js';
 import { isRequestType, VALID_REQUEST_TYPES } from '../../services/artifacts/artifact-prerequisites.js';
 import { fail, ok } from '../../shared/result.js';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
@@ -191,4 +192,33 @@ export function registerScanCommands(program, io) {
             process.exitCode = 1;
         }
     });
+    addJsonOption(scan
+        .command('file-size')
+        .description('Check git diff for files exceeding a line count threshold (karpathy-skills "Simplicity First")')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--base-ref <ref>', 'compare working tree against this git ref (default: HEAD)')
+        .option('--threshold <n>', `line count threshold (default: ${DEFAULT_FILE_SIZE_THRESHOLD})`)).action((options) => {
+        try {
+            const threshold = options.threshold !== undefined && /^\d+$/.test(options.threshold)
+                ? Number(options.threshold)
+                : undefined;
+            const result = scanFileSize({
+                projectRoot: options.project,
+                ...(options.baseRef !== undefined ? { baseRef: options.baseRef } : {}),
+                ...(threshold !== undefined ? { threshold } : {})
+            });
+            const nextActions = [];
+            if (!result.ok) {
+                nextActions.push(`${result.violations.length} file(s) exceed ${result.threshold} lines. Split into smaller modules.`);
+            }
+            printResult(io, ok('scan.file-size', result, [], nextActions), options.json);
+            if (!result.ok) {
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            printResult(io, fail('scan.file-size', 'FILE_SIZE_SCAN_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Verify the project path is a git repository']), options.json);
+            process.exitCode = 1;
+        }
+    });
 }

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

@@ -5,21 +5,26 @@ import { createAutonomousWorkflowPlan } from '../../services/workflow/workflow-a
 import { writeAutonomousResumeArtifacts } from '../../services/workflow/autonomous-resume-writer.js';
 import { createRecommendationPlan } from '../../services/recommendations/recommendation-service.js';
 import { createRefactorDryRun } from '../../services/refactor/refactor-service.js';
-import { ensureWorkspaceConfigForCurrentPath, getCurrentWorkspaceConfig, readConfig } from '../../services/config/config-service.js';
+import { getWorkspaceConfigForPath, readConfig } from '../../services/config/config-service.js';
 import { validateChangeIdOrThrow } from '../../shared/change-id.js';
 import { getEconomyAwareExecutionModelId } from '../../services/config/model-routing.js';
 import { getLocalArtifactPath } from '../../services/artifacts/workspace-service.js';
+import { getSessionId } from '../../services/session/session-manager.js';
+import { verifyPipeline } from '../../services/workflow/pipeline-verify-service.js';
 import { fail, ok } from '../../shared/result.js';
 import { addJsonOption, failUnsupportedNonDryRun, getErrorMessage, isRecommendationWorkflow, printResult } from '../cli-helpers.js';
 function getCurrentWorkspaceContext() {
-    const workspace = getCurrentWorkspaceConfig();
-    if (!workspace)
+    try {
+        const sessionId = getSessionId(process.cwd());
+        return sessionId ? { sessionId, sessionDir: `.peaks/${sessionId}` } : {};
+    }
+    catch {
         return {};
-    return { workspace, artifactWorkspacePath: getLocalArtifactPath(workspace) };
+    }
 }
 function getWorkflowWorkspaceContext() {
     try {
-        const workspace = ensureWorkspaceConfigForCurrentPath() ?? getCurrentWorkspaceConfig();
+        const workspace = getWorkspaceConfigForPath(process.cwd());
         if (!workspace)
             return {};
         return { workspace, artifactWorkspacePath: getLocalArtifactPath(workspace) };
@@ -299,6 +304,31 @@ export function registerWorkflowCommands(program, io) {
     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));
+    addJsonOption(workflow
+        .command('verify-pipeline')
+        .description('Verify the complete rd→qa pipeline was followed for a request')
+        .requiredOption('--rid <rid>', 'request identifier')
+        .requiredOption('--project <path>', 'project root path')
+        .requiredOption('--session-id <id>', 'session identifier')
+        .option('--type <type>', 'request type: feature, bugfix, refactor, docs, config, chore', 'feature')).action(async (options) => {
+        try {
+            const result = await verifyPipeline({
+                projectRoot: options.project,
+                rid: options.rid,
+                sessionId: options.sessionId,
+                ...(options.type ? { requestType: options.type } : {})
+            });
+            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), {}, ['Check that --project, --rid, and --session-id are correct']), options.json);
+            process.exitCode = 1;
+        }
+    });
     const swarm = program.command('swarm').description('Plan RD swarm dry-run graphs');
     addSwarmPlanOptions(swarm.command('plan'), true).action((options) => runSwarmPlan(io, options));
     addSwarmPlanOptions(program.command('swarm-plan'), false).action((options) => runSwarmPlan(io, options));

package/dist/src/services/artifacts/artifact-prerequisites.js

@@ -14,14 +14,42 @@ export function isRequestType(value) {
     return VALID_REQUEST_TYPES.includes(value);
 }
 // Shared prerequisite fragments
-const TECH_DOC = { relativePath: 'rd/tech-doc.md', description: 'RD technical design doc (architecture, files changed, data flow)' };
-const BUG_ANALYSIS = { relativePath: 'rd/bug-analysis.md', description: 'Bug root-cause analysis (reproduction, affected paths, fix approach, regression test plan)' };
-const CODE_REVIEW = { relativePath: 'rd/code-review.md', description: 'Code review evidence (CRITICAL/HIGH must be fixed before handoff)' };
+const TECH_DOC = {
+    relativePath: 'rd/tech-doc.md',
+    description: 'RD technical design doc (architecture, files changed, data flow)',
+    mustContain: ['## Red-line scope', '## Implementation evidence']
+};
+const BUG_ANALYSIS = {
+    relativePath: 'rd/bug-analysis.md',
+    description: 'Bug root-cause analysis (reproduction, affected paths, fix approach, regression test plan)',
+    mustContain: ['## Root cause', '## Fix approach']
+};
+const CODE_REVIEW = {
+    relativePath: 'rd/code-review.md',
+    description: 'Code review evidence (CRITICAL/HIGH must be fixed before handoff)',
+    mustContain: ['## Findings', 'CRITICAL']
+};
 const SECURITY_REVIEW = { relativePath: 'rd/security-review.md', description: 'Security review evidence for the changed surface' };
-const TEST_CASES = { relativePath: 'qa/test-cases/<rid>.md', description: 'Generated test cases (unit / integration / UI regression)' };
-const TEST_REPORT = { relativePath: 'qa/test-reports/<rid>.md', description: 'Test execution report with actual pass/fail/coverage results' };
-const SECURITY_FINDINGS = { relativePath: 'qa/security-findings.md', description: 'Security test findings (record "no findings" inside if truly clean)' };
-const PERFORMANCE_FINDINGS = { relativePath: 'qa/performance-findings.md', description: 'Performance test findings (record baseline/after numbers or explicit "not applicable" rationale)' };
+const TEST_CASES = {
+    relativePath: 'qa/test-cases/<rid>.md',
+    description: 'Generated test cases (unit / integration / UI regression)',
+    mustContain: ['## Test cases']
+};
+const TEST_REPORT = {
+    relativePath: 'qa/test-reports/<rid>.md',
+    description: 'Test execution report with actual pass/fail/coverage results',
+    mustContain: ['## Test execution']
+};
+const SECURITY_FINDINGS = {
+    relativePath: 'qa/security-findings.md',
+    description: 'Security test findings (record "no findings" inside if truly clean)',
+    mustContain: ['## Findings']
+};
+const PERFORMANCE_FINDINGS = {
+    relativePath: 'qa/performance-findings.md',
+    description: 'Performance test findings (record baseline/after numbers or explicit "not applicable" rationale)',
+    mustContain: ['## Baseline']
+};
 // PRD content prereq: ensures the PRD artifact has actual scope/acceptance content
 // before handoff to RD/UI/QA. The SKILL says "Handoff to RD/UI/QA is blocked while
 // the artifact is missing or in `draft` state" — this gives that claim a CLI gate.
@@ -30,10 +58,19 @@ const PRD_CONTENT = {
     description: 'PRD artifact must contain Goal and Acceptance criteria sections before handoff',
     mustContain: ['## Goals', '## Acceptance']
 };
+const UNIT_TESTS = {
+    relativePath: 'qa/test-cases/<rid>.md',
+    description: 'Unit test files for the implemented changes (enforces peaks-rd Gate B2)',
+    mustContain: ['## Test cases', 'test(']
+};
+const QA_INITIATED = {
+    relativePath: 'qa/.initiated',
+    description: 'QA skill must be invoked before RD handoff (run peaks request init --role qa)'
+};
 const FEATURE_TABLE = {
     'prd:handed-off': [PRD_CONTENT],
     'rd:implemented': [TECH_DOC],
-    'rd:qa-handoff': [TECH_DOC, CODE_REVIEW, SECURITY_REVIEW],
+    'rd:qa-handoff': [TECH_DOC, CODE_REVIEW, SECURITY_REVIEW, UNIT_TESTS, QA_INITIATED],
     'qa:running': [TEST_CASES],
     'qa:verdict-issued': [TEST_CASES, TEST_REPORT, SECURITY_FINDINGS, PERFORMANCE_FINDINGS]
 };
@@ -42,14 +79,17 @@ const FEATURE_TABLE = {
 const BUGFIX_TABLE = {
     'prd:handed-off': [PRD_CONTENT],
     'rd:implemented': [BUG_ANALYSIS],
-    'rd:qa-handoff': [BUG_ANALYSIS, CODE_REVIEW, SECURITY_REVIEW],
+    'rd:qa-handoff': [BUG_ANALYSIS, CODE_REVIEW, SECURITY_REVIEW, UNIT_TESTS, QA_INITIATED],
     'qa:running': [TEST_CASES],
     'qa:verdict-issued': [TEST_CASES, TEST_REPORT, SECURITY_FINDINGS]
 };
 // Refactor: same as feature; refactor hard gates (coverage ≥ 95%) are enforced separately in peaks-rd SKILL.
 const REFACTOR_TABLE = FEATURE_TABLE;
-// Docs / chore: no artifact gates. Use sparingly — for genuinely doc-only or formatter-only changes.
-const NO_GATES = {};
+// Docs / chore: minimal gate — require PRD content before proceeding.
+// Prevents jumping to implementation without planning.
+const MINIMAL_TABLE = {
+    'prd:handed-off': [PRD_CONTENT]
+};
 // Config: security review is the only mandatory check (config changes can break auth, CORS, CSP, secrets handling).
 const CONFIG_TABLE = {
     'prd:handed-off': [PRD_CONTENT],
@@ -60,9 +100,9 @@ const PREREQUISITES_BY_TYPE = {
     feature: FEATURE_TABLE,
     bugfix: BUGFIX_TABLE,
     refactor: REFACTOR_TABLE,
-    docs: NO_GATES,
+    docs: MINIMAL_TABLE,
     config: CONFIG_TABLE,
-    chore: NO_GATES
+    chore: MINIMAL_TABLE
 };
 export function getPrerequisitesFor(role, newState, requestType = DEFAULT_REQUEST_TYPE) {
     const table = PREREQUISITES_BY_TYPE[requestType];

package/dist/src/services/artifacts/artifact-service.js

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
-import { getCurrentWorkspaceConfig } from '../config/config-service.js';
+import { getWorkspaceConfigForPath } from '../config/config-service.js';
 import { getArtifactRemoteRepo, getLocalArtifactPath } from './workspace-service.js';
 function getRemoteUrl(artifactRepo) {
     if (!artifactRepo)
@@ -45,7 +45,7 @@ export function createArtifactInitPlan(options) {
     };
 }
 export function createGuidedArtifactSetup() {
-    const workspace = getCurrentWorkspaceConfig();
+    const workspace = getWorkspaceConfigForPath(process.cwd());
     const artifactRepo = workspace ? getArtifactRemoteRepo(workspace) : null;
     const validationResult = {
         workspaceExists: workspace !== null,

package/dist/src/services/artifacts/request-artifact-service.d.ts

@@ -54,6 +54,12 @@ export type TransitionRequestArtifactOptions = {
     sessionId?: string;
     reason?: string;
     allowIncomplete?: boolean;
+    confirmed?: boolean;
+    forceConfirm?: boolean;
+    typeSanityCheck?: {
+        projectRoot: string;
+        declaredType: RequestType;
+    };
     clock?: () => string;
 };
 export type TransitionRequestArtifactResult = RequestArtifactSummary & {
@@ -69,4 +75,30 @@ export declare class PrerequisitesNotSatisfiedError extends Error {
     readonly missing: PrerequisiteCheckResult['missing'];
     constructor(role: RequestArtifactRole, newState: RequestArtifactState, sessionId: string, missing: PrerequisiteCheckResult['missing']);
 }
+export declare class LintGateError extends Error {
+    readonly code = "LINT_GATE_FAILED";
+    readonly role: RequestArtifactRole;
+    readonly newState: RequestArtifactState;
+    readonly errorCount: number;
+    constructor(role: RequestArtifactRole, newState: RequestArtifactState, errorCount: number);
+}
+export declare class TypeSanityViolationError extends Error {
+    readonly code = "TYPE_SANITY_VIOLATION";
+    readonly declaredType: RequestType;
+    readonly suggestedTypes: ReadonlyArray<RequestType>;
+    readonly rationale: string;
+    constructor(declaredType: RequestType, suggestedTypes: ReadonlyArray<RequestType>, rationale: string);
+}
+export declare class FileSizeViolationError extends Error {
+    readonly code = "FILE_SIZE_VIOLATION";
+    readonly violations: Array<{
+        file: string;
+        lines: number;
+    }>;
+    readonly threshold: number;
+    constructor(violations: Array<{
+        file: string;
+        lines: number;
+    }>, threshold: number);
+}
 export declare function transitionRequestArtifact(options: TransitionRequestArtifactOptions): Promise<TransitionRequestArtifactResult | null>;