peaks-cli 1.0.22 → 1.0.24

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 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);
@@ -35,7 +36,7 @@ function runCapabilityMap(io, options) {
 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/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, isSkillPresenceMode } from '../../services/skills/skill-presence-service.js';
+import { setSkillPresence, clearSkillPresence, getSkillPresence, isSkillPresenceMode, touchSkillHeartbeat } 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) {
@@ -86,6 +86,36 @@ export function registerCoreAndArtifactCommands(program, io) {
         const removed = clearSkillPresence();
         printResult(io, ok('skill.presence:clear', { active: false, removed }), options.json);
     });
+    addJsonOption(skill
+        .command('heartbeat')
+        .description('Show the heartbeat status of the active Peaks skill')).action((options) => {
+        const presence = getSkillPresence();
+        if (presence === null) {
+            printResult(io, ok('skill.heartbeat', { active: false, heartbeat: 'none' }), options.json);
+            return;
+        }
+        printResult(io, ok('skill.heartbeat', {
+            active: true,
+            skill: presence.skill,
+            gate: presence.gate ?? null,
+            lastHeartbeat: presence.lastHeartbeat ?? presence.setAt,
+            setAt: presence.setAt
+        }), options.json);
+    });
+    addJsonOption(skill
+        .command('heartbeat:touch')
+        .description('Update the heartbeat timestamp (called by the LLM each turn to confirm peaks skill context is alive)')).action((options) => {
+        const updated = touchSkillHeartbeat();
+        if (updated === null) {
+            printResult(io, ok('skill.heartbeat:touch', { active: false, heartbeat: 'none' }), options.json);
+            return;
+        }
+        printResult(io, ok('skill.heartbeat:touch', {
+            active: true,
+            skill: updated.skill,
+            lastHeartbeat: updated.lastHeartbeat
+        }), options.json);
+    });
     const profile = program.command('profile').description('Manage runtime profiles');
     addJsonOption(profile.command('list').description('List available profiles')).action((options) => {
         printResult(io, ok('profile.list', { profiles: listProfiles() }), options.json);

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

@@ -10,6 +10,7 @@ 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() {
@@ -303,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/workspace-service.d.ts

@@ -20,7 +20,7 @@ export type SyncResult = {
     error?: string;
 };
 export declare function getLocalArtifactPath(workspace: WorkspaceConfig): string;
-export declare function isArtifactWorkspaceOutsideTarget(workspace: WorkspaceConfig, artifactWorkspacePath?: string): boolean;
+export declare function isArtifactWorkspaceOutsideTarget(_workspace: WorkspaceConfig, _artifactWorkspacePath?: string): boolean;
 export declare function hasValidArtifactWorkspace(workspace: WorkspaceConfig, artifactWorkspacePath?: string): boolean;
 export declare function getArtifactRemoteRepo(workspace: WorkspaceConfig): WorkspaceConfig['artifactRepo'] | null;
 export declare function executeArtifactSync(workspaceId?: string): Promise<SyncResult>;

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

@@ -17,10 +17,8 @@ export function getLocalArtifactPath(workspace) {
     }
     return resolve(workspace.rootPath, '.peaks', 'artifacts');
 }
-export function isArtifactWorkspaceOutsideTarget(workspace, artifactWorkspacePath = getLocalArtifactPath(workspace)) {
-    const targetRoot = canonicalPath(workspace.rootPath);
-    const artifactRoot = canonicalPath(artifactWorkspacePath);
-    return !isInsidePath(artifactRoot, targetRoot);
+export function isArtifactWorkspaceOutsideTarget(_workspace, _artifactWorkspacePath) {
+    return true;
 }
 export function hasValidArtifactWorkspace(workspace, artifactWorkspacePath = getLocalArtifactPath(workspace)) {
     if (!isArtifactWorkspaceOutsideTarget(workspace, artifactWorkspacePath))
@@ -29,7 +27,6 @@ export function hasValidArtifactWorkspace(workspace, artifactWorkspacePath = get
     const peaksRoot = canonicalChildPath(artifactWorkspacePath, '.peaks');
     const changesRoot = canonicalChildPath(artifactWorkspacePath, '.peaks', 'changes');
     const configPath = canonicalChildPath(artifactWorkspacePath, '.peaks', 'config.json');
-    const targetRoot = canonicalPath(workspace.rootPath);
     if (!existsSync(resolve(artifactWorkspacePath, '.peaks', 'config.json')))
         return false;
     if (!isInsidePath(peaksRoot, artifactRoot))
@@ -38,12 +35,6 @@ export function hasValidArtifactWorkspace(workspace, artifactWorkspacePath = get
         return false;
     if (!isInsidePath(configPath, artifactRoot))
         return false;
-    if (isInsidePath(peaksRoot, targetRoot))
-        return false;
-    if (isInsidePath(changesRoot, targetRoot))
-        return false;
-    if (isInsidePath(configPath, targetRoot))
-        return false;
     return true;
 }
 export function getArtifactRemoteRepo(workspace) {

package/dist/src/services/config/config-safety.d.ts

@@ -6,7 +6,7 @@ export declare function getProjectConfigPath(projectRoot: string | null): string
 export declare function getProjectBootstrapConfigPath(projectRoot: string): string;
 export declare function validateProjectBootstrapConfigPathForWrite(projectRoot: string, configPath: string): void;
 export declare function validateUserConfigPathForWrite(configPath: string): void;
-export declare function validateArtifactWorkspaceRoot(artifactRoot: string, workspaceRoot: string): void;
+export declare function validateArtifactWorkspaceRoot(artifactRoot: string, _workspaceRoot: string): void;
 export declare function validateArtifactWorkspaceMarkerPath(artifactRoot: string, peaksPath: string, markerPath: string): void;
 export declare function readConfigFileSafely(configPath: string, errorMessage: string): string;
 export declare function writeConfigFileSafely(configPath: string, content: string, validateBeforeWrite: () => void, errorMessage: string): void;

package/dist/src/services/config/config-safety.js

@@ -54,6 +54,9 @@ export function findProjectRoot(startPath) {
         if (existsSync(resolve(current, '.peaks', 'config.json')) && isSafeProjectConfigMarker(current)) {
             return current;
         }
+        if (existsSync(resolve(current, 'package.json')) || existsSync(resolve(current, '.git'))) {
+            return current;
+        }
         parent = current;
         current = dirname(parent);
     }
@@ -154,16 +157,11 @@ export function validateUserConfigPathForWrite(configPath) {
         }
     }
 }
-export function validateArtifactWorkspaceRoot(artifactRoot, workspaceRoot) {
+export function validateArtifactWorkspaceRoot(artifactRoot, _workspaceRoot) {
     const artifactStats = lstatSync(artifactRoot);
     if (!artifactStats.isDirectory() || artifactStats.isSymbolicLink()) {
         throw new Error('Artifact workspace marker must stay inside the artifact workspace');
     }
-    const artifactRootReal = realpathSync(artifactRoot);
-    const workspaceRootReal = realpathSync(workspaceRoot);
-    if (isInsidePath(artifactRootReal, workspaceRootReal)) {
-        throw new Error('Artifact workspace must stay outside the project root');
-    }
 }
 export function validateArtifactWorkspaceMarkerPath(artifactRoot, peaksPath, markerPath) {
     const artifactStats = lstatSync(artifactRoot);

package/dist/src/services/config/config-service.d.ts

@@ -23,7 +23,7 @@ export declare function readConfig(projectRoot?: string | null): PeaksConfig;
 export declare function writeConfig(partial: Partial<PeaksConfig>, layer?: ConfigLayer): void;
 export declare function getConfig(options?: ConfigGetOptions): unknown;
 export declare function setConfig(options: ConfigSetOptions): void;
-export declare function getWorkspaceConfig(workspaceId: string, projectRoot?: string | null): WorkspaceConfig | null;
+export declare function getWorkspaceConfig(workspaceId: string, _projectRoot?: string | null): WorkspaceConfig | null;
 export declare function addWorkspace(workspace: WorkspaceConfig, layer?: ConfigLayer): void;
 export declare function removeWorkspace(workspaceId: string, layer?: ConfigLayer): boolean;
 export declare function setCurrentWorkspace(workspaceId: string, layer?: ConfigLayer): boolean;

package/dist/src/services/config/config-service.js

@@ -530,8 +530,21 @@ function writeRawWorkspaceData(data, layer) {
         writeUserConfigFile(targetPath, content);
     }
 }
-export function getWorkspaceConfig(workspaceId, projectRoot) {
-    const { workspaces } = readRawWorkspaceData('user');
+function readAllWorkspaces() {
+    const userData = readRawWorkspaceData('user');
+    const projectData = readRawWorkspaceData('project');
+    const mergedWorkspaces = new Map();
+    for (const w of userData.workspaces)
+        mergedWorkspaces.set(w.workspaceId, w);
+    for (const w of projectData.workspaces)
+        mergedWorkspaces.set(w.workspaceId, w);
+    return {
+        currentWorkspace: projectData.currentWorkspace ?? userData.currentWorkspace,
+        workspaces: [...mergedWorkspaces.values()]
+    };
+}
+export function getWorkspaceConfig(workspaceId, _projectRoot) {
+    const { workspaces } = readAllWorkspaces();
     return workspaces.find((w) => w.workspaceId === workspaceId) ?? null;
 }
 function readLayerConfig(layer) {
@@ -574,13 +587,13 @@ export function setCurrentWorkspace(workspaceId, layer = 'user') {
     return true;
 }
 export function getCurrentWorkspaceConfig() {
-    const { currentWorkspace, workspaces } = readRawWorkspaceData('user');
+    const { currentWorkspace, workspaces } = readAllWorkspaces();
     if (!currentWorkspace)
         return null;
     return workspaces.find((w) => w.workspaceId === currentWorkspace) ?? null;
 }
 export function getWorkspaceConfigForPath(path = process.cwd()) {
-    const { workspaces } = readRawWorkspaceData('user');
+    const { workspaces } = readAllWorkspaces();
     return findWorkspaceForPath(workspaces, path);
 }
 function findWorkspaceForPath(workspaces, path) {

package/dist/src/services/scan/acceptance-coverage-service.js

@@ -9,16 +9,13 @@ function extractAcceptanceItems(prdBody) {
         return [];
     }
     // Find the line where the header starts.
-    let headerLine = -1;
+    let headerLine = 0;
     for (let i = 0; i < lines.length; i += 1) {
         if (ACCEPTANCE_SECTION_PATTERN.test((lines[i] ?? '') + '\n')) {
             headerLine = i;
             break;
         }
     }
-    if (headerLine === -1) {
-        return [];
-    }
     const items = [];
     let counter = 0;
     for (let i = headerLine + 1; i < lines.length; i += 1) {

package/dist/src/services/scan/archetype-service.js

@@ -101,13 +101,7 @@ async function countSrcFiles(projectRoot, max = 500) {
         const current = queue.shift();
         if (current === undefined)
             break;
-        let entries;
-        try {
-            entries = await readdir(current, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
+        const entries = await readdir(current, { withFileTypes: true });
         for (const entry of entries) {
             if (entry.name.startsWith('.') || entry.name === 'node_modules')
                 continue;
@@ -129,14 +123,9 @@ async function lockfileAgeDays(projectRoot) {
     for (const candidate of candidates) {
         const full = join(projectRoot, candidate);
         if (await pathExists(full)) {
-            try {
-                const stats = await stat(full);
-                const ageMs = Date.now() - stats.mtimeMs;
-                return Math.floor(ageMs / (1000 * 60 * 60 * 24));
-            }
-            catch {
-                return null;
-            }
+            const stats = await stat(full);
+            const ageMs = Date.now() - stats.mtimeMs;
+            return Math.floor(ageMs / (1000 * 60 * 60 * 24));
         }
     }
     return null;

package/dist/src/services/scan/diff-scope-service.js

@@ -57,9 +57,9 @@ export function globToRegex(pattern) {
     }
     // If the pattern ends with no trailing slash and no extension wildcard, also allow it to match files under the path (treat as dir prefix)
     // E.g. `src/services/login` should match `src/services/login/handler.ts`.
-    if (!trimmed.includes('*') && !trimmed.includes('?') && !trimmed.includes('.')) {
-        body = `${body}(?:/.*)?`;
-    }
+    body = (!trimmed.includes("*") && !trimmed.includes("?") && !trimmed.includes("."))
+        ? `${body}(?:/.*)?`
+        : body;
     return new RegExp(`^${body}$`);
 }
 function classifyPatternLine(raw) {

package/dist/src/services/scan/file-size-scan.js

@@ -15,13 +15,8 @@ function getChangedFiles(projectRoot, baseRef) {
     }
 }
 function countLines(filePath) {
-    try {
-        const content = readFileSync(filePath, 'utf8');
-        return content.split(/\r?\n/).length;
-    }
-    catch {
-        return 0;
-    }
+    const content = readFileSync(filePath, 'utf8');
+    return content.split(/\r?\n/).length;
 }
 export function scanFileSize(options) {
     const baseRef = options.baseRef ?? 'HEAD';

package/dist/src/services/scan/type-sanity-service.js

@@ -78,9 +78,7 @@ function isConsistent(declared, suggested) {
     return suggested.includes(declared);
 }
 function buildRationale(declared, breakdown, suggested, consistent) {
-    const summary = breakdown.length === 0
-        ? 'no changed files detected'
-        : breakdown.map((entry) => `${entry.category}=${entry.count}`).join(', ');
+    const summary = breakdown.map((entry) => `${entry.category}=${entry.count}`).join(', ');
     if (consistent) {
         return `declared --type=${declared} is consistent with the changed files (${summary})`;
     }

package/dist/src/services/skills/skill-presence-service.d.ts

@@ -6,8 +6,10 @@ export type SkillPresence = {
     mode?: SkillPresenceMode;
     gate?: string;
     setAt: string;
+    lastHeartbeat?: string;
 };
 export declare function exportSkillPresence(): string;
 export declare function setSkillPresence(skill: string, mode?: string, gate?: string): SkillPresence;
 export declare function getSkillPresence(): SkillPresence | null;
+export declare function touchSkillHeartbeat(): SkillPresence | null;
 export declare function clearSkillPresence(): boolean;

package/dist/src/services/skills/skill-presence-service.js

@@ -18,11 +18,13 @@ export function exportSkillPresence() {
 }
 export function setSkillPresence(skill, mode, gate) {
     const validatedMode = mode && isSkillPresenceMode(mode) ? mode : undefined;
+    const now = new Date().toISOString();
     const presence = {
         skill,
         ...(validatedMode ? { mode: validatedMode } : {}),
         ...(gate ? { gate } : {}),
-        setAt: new Date().toISOString()
+        setAt: now,
+        lastHeartbeat: now
     };
     const presencePath = resolvePresencePath();
     const presenceDir = dirname(presencePath);
@@ -49,6 +51,25 @@ export function getSkillPresence() {
         return null;
     }
 }
+export function touchSkillHeartbeat() {
+    const presencePath = resolvePresencePath();
+    if (!existsSync(presencePath)) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(presencePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.skill !== 'string' || parsed.skill.length === 0) {
+            return null;
+        }
+        parsed.lastHeartbeat = new Date().toISOString();
+        writeFileSync(presencePath, JSON.stringify(parsed, null, 2), 'utf8');
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
 export function clearSkillPresence() {
     const presencePath = resolvePresencePath();
     if (!existsSync(presencePath)) {

package/dist/src/services/standards/project-standards-service.js

@@ -134,6 +134,27 @@ function renderClaudeMd(language, ctx) {
         '- Read `.claude/rules/common/security.md` before touching filesystem, user input, external calls, auth, or secrets.',
         `- Read .claude/rules/${language}/coding-style.md for language-specific standards when applicable.`,
         '',
+        '<!--',
+        '  Peaks-Cli 心跳检测 (heartbeat check)',
+        '  LLM 每轮回复前必须执行以下步骤，由 CLI 命令强制执行:',
+        '  1. 读取 .peaks/.active-skill.json → 存在则显示 status header',
+        '  2. 扫描当前上下文查找 peaks 技能标记',
+        '     ("Peaks-Cli Gate", "Peaks-Cli Default runbook", "Peaks-Cli Startup sequence")',
+        '  3. 标记存在 → 调用 `peaks skill heartbeat:touch` 记录心跳',
+        '  4. 标记不存在 → 显示警告 + 调用 `peaks skill presence:clear` 关闭心跳',
+        '-->',
+        'Active Peaks-Cli skill presence: at the start of EVERY response, run these steps in order:',
+        '',
+        '1. Read `.peaks/.active-skill.json`. If missing or invalid, skip all remaining steps.',
+        '2. Display the compact status header: `Peaks-Cli Skill: <skill> | Peaks-Cli Gate: <gate> | Next: <one short action>`.',
+        '3. Scan the current conversation context for peaks skill markers: "Peaks-Cli Gate", "Peaks-Cli Default runbook", "Peaks-Cli Startup sequence", "Peaks-Cli Swarm parallel phase".',
+        '4. If at least one marker IS found → run `peaks skill heartbeat:touch` to record a successful heartbeat. The CLI command writes the timestamp and returns JSON — verify it succeeded.',
+        '5. If NO markers are found → the skill context has been lost (context compaction). Run `peaks skill presence:clear` to close the heartbeat, then display this warning:',
+        '',
+        '> ⚠ Peaks-Cli: skill presence file was active but skill context has been lost from the conversation. The workflow can no longer run correctly. Please re-invoke the relevant /peaks-* skill to reload the full skill instructions.',
+        '',
+        'Do NOT skip step 3-5. The CLI heartbeat:touch command is the mechanism that makes heartbeat auditable — failing to call it means the heartbeat is broken.',
+        '',
         'External reference: https://github.com/affaan-m/everything-claude-code is used as a curated reference only. Do not execute or install external content without explicit approval.',
         ''
     ].join('\n');

package/dist/src/services/workflow/pipeline-verify-service.d.ts

@@ -0,0 +1,31 @@
+import type { RequestType } from '../artifacts/artifact-prerequisites.js';
+export type PipelineGate = {
+    name: string;
+    description: string;
+    passed: boolean;
+    detail: string;
+};
+export type PipelineVerification = {
+    rid: string;
+    sessionId: string;
+    requestType: RequestType;
+    complete: boolean;
+    rdPhase: {
+        invoked: boolean;
+        state: string;
+        gates: PipelineGate[];
+    };
+    qaPhase: {
+        invoked: boolean;
+        state: string;
+        gates: PipelineGate[];
+    };
+    violations: string[];
+    nextActions: string[];
+};
+export declare function verifyPipeline(options: {
+    projectRoot: string;
+    rid: string;
+    sessionId: string;
+    requestType?: string;
+}): Promise<PipelineVerification>;