@haystackeditor/cli 0.15.26 → 0.15.27

package/dist/index.js

@@ -30,11 +30,18 @@ import { initCommand } from './commands/init.js';
 import { authListCommand, authUseCommand, loginCommand, logoutCommand, whoamiCommand, } from './commands/login.js';
 import { handleAgenticTool, handleAutoMerge, handleAutoFix, handleWaitForReviewers, isAutoMergeEnabled, isAutoFixEnabled } from './commands/config.js';
 import { installSkills, listSkills } from './commands/skills.js';
+import { cloudVerifierUniverseValidateCommand } from './commands/cloud-verifier-universe.js';
+import { cloudVerifierIdentityCensusCommand } from './commands/cloud-verifier-identity-census.js';
+import { cloudVerifierDataStoreDriftCommand } from './commands/cloud-verifier-data-store-drift.js';
+import { cloudVerifierBehaviorsValidateCommand } from './commands/cloud-verifier-behaviors.js';
+import { prepareUniverseReviewCommand } from './commands/prepare-universe-review.js';
+import { scaffoldProvisionalUniverseCommand } from './commands/scaffold-provisional-universe.js';
 import { hooksInstall, hooksStatus, hooksUpdate } from './commands/hooks.js';
 import { submitCommand } from './commands/submit.js';
 import { installSessionHooks, sessionHooksStatus } from './commands/install-session-hooks.js';
 import { listPolicies, addPolicy, removePolicy, initPolicies, addInstruction } from './commands/policy.js';
 import { triageCommand } from './commands/triage.js';
+import { designVerifyCommand } from './commands/design-verify.js';
 import { dismissCommand, markReviewedCommand, undismissCommand } from './commands/dismiss.js';
 import { requestReviewCommand } from './commands/request-review.js';
 import { reviewCommand } from './commands/review.js';
@@ -43,6 +50,7 @@ import { prReadCommand } from './commands/pr.js';
 import { inboxListCommand } from './commands/inbox.js';
 import { askHaystackCommand } from './commands/ask.js';
 import { tracesGetCommand, tracesListCommand } from './commands/traces.js';
+import { telemetryInstrumentCommand } from './commands/telemetry.js';
 import { setupCommand } from './commands/setup.js';
 import { schemaCommand, listSchemas } from './commands/schema-cmd.js';
 import { registerWebhook, listWebhooks, rotateWebhookSecret, setWebhookEnabled, listDeliveries, replayDelivery, } from './commands/webhooks.js';
@@ -804,6 +812,32 @@ traces
     .option('--limit <count>', 'Chunks per page', '20')
     .option('--json', 'Output as JSON')
     .action((ref, checkpoint, options) => runPublicCommand(() => tracesGetCommand(ref, checkpoint, options), options.json));
+const telemetry = program.command('telemetry').description('Add privacy-safe production telemetry without an application SDK');
+telemetry
+    .command('instrument <dist>')
+    .description('Instrument compiled Node.js output without changing application source')
+    .requiredOption('--entry <file>', 'Entry file relative to the compiled output directory')
+    .option('--source-root <dir>', 'Source directory whose files correspond exactly to compiled output (default: sibling src/)')
+    .option('--include-symbols <file>', 'Experimental JSON allow-list of exact sourcePath + qualifiedName symbols')
+    .option('--json', 'Machine-readable instrumentation manifest')
+    .addHelpText('after', `
+Run this once after the normal application build. It rewrites only compiled
+JavaScript and copies a dependency-free runtime beside it; application source
+does not import Haystack.
+
+At runtime, telemetry stays off unless all three variables are set:
+  HAYSTACK_TELEMETRY=1
+  HAYSTACK_TELEMETRY_ENDPOINT=https://.../v3/telemetry
+  HAYSTACK_TELEMETRY_TOKEN=...
+
+Example:
+  npm run build && haystack telemetry instrument dist --entry index.js
+`)
+    .action((dist, options) => runPublicCommand(() => telemetryInstrumentCommand(dist, {
+    ...options,
+    includeSymbolsFile: options.includeSymbols,
+    includeSymbols: undefined,
+}), options.json));
 program
     .command('dismiss <pr>')
     .description('Dismiss analysis findings for a PR')
@@ -826,6 +860,31 @@ Examples:
   haystack dismiss acme/widgets#99     # Dismiss for specific repo
 `)
     .action(dismissCommand);
+program
+    .command('design-verify <pr>')
+    // "verification" is a banned word in top-level help (public-contract test
+    // keeps retired auto-fix/verification wording out of the CLI surface).
+    .description('Run a blind design-by-execution review of a PR')
+    .option('--json', 'Machine-readable output')
+    .option('--no-wait', 'Return after the run is admitted instead of waiting for its verdict')
+    .option('--run <run-id>', 'Resume and wait for an existing exact run id')
+    .option('--poll-interval <seconds>', 'Status polling interval', '3')
+    .option('--timeout <seconds>', 'Maximum time to wait; the server run continues after timeout', '7200')
+    .addHelpText('after', `
+Executes the change instead of reading it: infers intent from the diff
+alone, designs pre-registered behavioral test cases, runs them against
+both sides of the PR in isolated sandboxes, and reports a mechanical
+verdict of unexpected behavior changes.
+
+The command waits for a behavioral verdict by default. Use --no-wait to
+return the run id immediately, or --run <run-id> to resume waiting.
+
+PR identifier formats:
+  123                                     PR number (uses current repo)
+  owner/repo#123                          Fully qualified
+  https://github.com/owner/repo/pull/123  GitHub URL
+`)
+    .action(designVerifyCommand);
 program
     .command('mark-reviewed <pr>')
     .description('Mark human review as not needed for a PR')
@@ -1035,32 +1094,95 @@ Examples:
 // Skills subcommands
 const skills = program
     .command('skills')
-    .description('Manage AI skills for Claude Code');
+    .description('Manage AI skills for coding agents');
 skills
     .command('install')
-    .description('Install Haystack skills into your coding CLI')
+    .description('Install portable Haystack skills and optional coding-CLI shims')
     .option('--cli <name>', 'Target CLI: claude, codex, cursor, or manual')
     .addHelpText('after', `
-This registers the Haystack MCP server with your coding CLI, enabling:
-  /setup-haystack         - AI-assisted project setup
+This installs portable skills in the Git repository's .agents/skills directory:
   /submit                 - Submit a PR via Haystack
+  /map-your-system        - Map how Haystack QA can run this system
+  /map-cloud-verifier-universe - Map a production-derived hermetic universe
 Supported CLIs:
-  claude    Claude Code (auto-detected)
-  codex     Codex CLI (auto-detected)
-  cursor    Cursor IDE (auto-detected)
-  manual    Show manual setup instructions
+  claude    Also install Claude Code command shims
+  codex     Use portable .agents/skills discovery only
+  cursor    Use portable .agents/skills discovery only
+  manual    Install portable skills and show their location
 
 Examples:
-  haystack skills install              # Auto-detect and install
+  haystack skills install              # Install portable skills only
   haystack skills install --cli codex  # Install for Codex only
-  haystack skills install --cli manual # Show manual instructions
+  haystack skills install --cli claude # Also install Claude command shims
 `)
-    .action(installSkills);
+    .action(async (opts) => {
+    try {
+        await installSkills(opts);
+    }
+    catch (err) {
+        console.error(chalk.red('skills install failed:'), err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
 skills
     .command('list')
     .description('List available Haystack skills')
     .action(listSkills);
-// Hooks subcommands
+skills
+    .command('census-universe')
+    .description('Deterministically census Cloud Verifier source identities before mapping')
+    .option('--json', 'Machine-readable result')
+    .option('--root <path>', 'Repository root (default: current Git worktree)')
+    .action((opts) => runPublicCommand(async () => cloudVerifierIdentityCensusCommand(opts), opts.json));
+skills
+    .command('data-store-drift')
+    .description('Check whether the detected data stores still match the checked-in map (per-PR drift gate)')
+    .option('--json', 'Machine-readable result')
+    .option('--root <path>', 'Repository root (default: current Git worktree)')
+    .option('--baseline <path>', 'Baseline map path (default: .haystack/cloud-verifier/data-stores.json)')
+    .option('--base-ref <ref>', 'Only run when the diff against this ref touches a store-relevant file')
+    .option('--update', 'Write the current detected stores as the new baseline')
+    .action((opts) => runPublicCommand(async () => cloudVerifierDataStoreDriftCommand(opts), opts.json));
+skills
+    .command('validate-universe')
+    .description('Validate Cloud Verifier universe artifacts and stable-ID references')
+    .option('--json', 'Machine-readable result')
+    .action(async (opts) => {
+    try {
+        await cloudVerifierUniverseValidateCommand(opts);
+    }
+    catch (err) {
+        console.error(chalk.red('validate-universe failed:'), err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+skills
+    .command('validate-behaviors')
+    .description('Validate customer actions and their exact runtime identities')
+    .option('--json', 'Machine-readable result')
+    .action(async (opts) => {
+    try {
+        await cloudVerifierBehaviorsValidateCommand(opts);
+    }
+    catch (err) {
+        console.error(chalk.red('validate-behaviors failed:'), err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+skills
+    .command('scaffold-provisional-universe')
+    .description('Create a compact missing-authority receipt from strict JSON facts')
+    .requiredOption('--input <path>', 'Strict provisional-universe JSON input file')
+    .action((opts) => runPublicCommand(async () => scaffoldProvisionalUniverseCommand(opts), true));
+skills
+    .command('prepare-universe-review')
+    .description('Create a tracked-source snapshot with conventional test paths removed')
+    .option('--json', 'Machine-readable isolation result and snapshot manifest')
+    .option('--exclude-inactive-submodule <path...>', 'Omit exact tracked gitlink paths explicitly known to be inactive')
+    .option('--omit-unscannable-files', 'Omit files whose test content cannot be ruled out, instead of blocking the review. '
+    + 'The reviewer still never sees a test; the omissions are recorded as uncovered scope')
+    .option('--full-receipt', 'Include complete non-blocking path receipts in JSON output')
+    .action((opts) => runPublicCommand(() => prepareUniverseReviewCommand(opts), opts.json));
 const hooks = program
     .command('hooks')
     .description('Manage git hooks for AI agent quality checks');

package/dist/triage/runner.js

@@ -101,7 +101,13 @@ export function buildCommand(cli, prompt, maxTurns) {
         case 'codex':
             return {
                 command: 'codex',
-                args: ['exec', prompt, '--full-auto'],
+                args: [
+                    '--sandbox', 'workspace-write',
+                    '--ask-for-approval', 'never',
+                    'exec',
+                    '--ephemeral',
+                    prompt,
+                ],
             };
         case 'gemini':
             return {
@@ -119,17 +125,12 @@ function spawnChecker(cli, config, cwd, timeoutMs) {
         const { command, args } = buildCommand(cli, config.prompt, config.maxTurns);
         let stdout = '';
         let stderr = '';
-        const codexHome = join(cwd, '.haystack', 'triage', 'codex-home');
-        if (cli === 'codex') {
-            mkdirSync(codexHome, { recursive: true });
-        }
         const proc = spawn(command, args, {
             cwd,
             stdio: ['ignore', 'pipe', 'pipe'],
             env: {
                 ...process.env,
                 CLAUDECODE: undefined,
-                CODEX_HOME: cli === 'codex' ? codexHome : process.env.CODEX_HOME,
             },
         });
         proc.stdout?.on('data', (data) => {

package/dist/utils/design-verifier-api.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Client for the design-verifier trigger route on the auth worker.
+ *
+ * The worker owns everything sensitive: it authenticates the CLI token,
+ * enforces hsk_live repo scope, resolves the PR's base/head SHAs via the
+ * GitHub App install token, and forwards to the AWS design-verifier API with
+ * the server-side shared secret. This client just POSTs and interprets the
+ * response.
+ */
+export type DesignVerifierTriggerResult = {
+    status: 'started' | 'queued' | 'duplicate';
+    runId: string;
+} | {
+    status: 'denied';
+    message: string;
+} | {
+    status: 'rate_limited';
+    message: string;
+} | {
+    status: 'unavailable';
+    message: string;
+} | {
+    status: 'error';
+    message: string;
+};
+export interface DesignVerifierCommandSpec {
+    cwd: string;
+    argv: string[];
+    env: Record<string, string>;
+    timeoutMs?: number;
+}
+export interface DesignVerifierExecutionDiagnostic {
+    diagnosticId: string;
+    kind: string;
+    message: string;
+    type?: string;
+    code?: string;
+}
+export interface DesignVerifierExecutionSummary {
+    side: 'base1' | 'base2' | 'head';
+    status: 'completed' | 'failed' | 'missing';
+    commandExitCode: number | null;
+    durationMs: number | null;
+    scenarioError: string | null;
+    diagnostics: DesignVerifierExecutionDiagnostic[];
+    diagnosticsOmitted: number;
+    outputExcerpt: Array<{
+        stream: 'stdout' | 'stderr' | 'system' | 'output';
+        text: string;
+    }>;
+    outputLinesOmitted: number;
+    traceArtifact: string;
+    outputArtifact: string;
+}
+export interface DesignVerifierStageTiming {
+    stage: 'prepare' | 'bake' | 'blast-radius' | 'prefetch' | 'case-design' | 'verdict';
+    status: string;
+    durationMs: number | null;
+    completedAt: string | null;
+    source: 'phase-artifact' | 'phase-artifact-clock' | 'cache-hit' | 'missing';
+    breakdownMs: Record<string, number>;
+    pollCount?: number;
+}
+export interface DesignVerifierTimingSummary {
+    admissionMs: number | null;
+    pipelineDurationMs: number | null;
+    recordedStageMs: number;
+    unattributedMs: number | null;
+    stages: DesignVerifierStageTiming[];
+}
+export interface DesignVerifierStatusResult {
+    version: 'dv-cli-status-v1';
+    runId: string;
+    owner: string;
+    repo: string;
+    pr: number;
+    baseSha: string | null;
+    headSha: string | null;
+    status: string;
+    stage: string | null;
+    createdAt: string | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+    durationMs: number | null;
+    error: string | null;
+    result?: {
+        verdict: Record<string, any>;
+        cases: Array<Record<string, any>>;
+        scenarios: Array<Record<string, any> & {
+            executions?: DesignVerifierExecutionSummary[];
+        }>;
+        changedFiles: string[];
+        timings?: DesignVerifierTimingSummary;
+        probes: Array<{
+            caseId: string;
+            title: string;
+            files: string[];
+            validate: DesignVerifierCommandSpec | null;
+            run: DesignVerifierCommandSpec | null;
+        }>;
+        replay: {
+            artifactPrefix: string;
+            keys: Record<string, string>;
+        };
+    };
+}
+export type DesignVerifierStatusFetchResult = {
+    status: 'ok';
+    run: DesignVerifierStatusResult;
+} | {
+    status: 'not_found' | 'denied' | 'unavailable' | 'error';
+    message: string;
+};
+export declare function triggerDesignVerifier(owner: string, repo: string, prNumber: number, token: string): Promise<DesignVerifierTriggerResult>;
+export declare function getDesignVerifierStatus(owner: string, repo: string, prNumber: number, runId: string, token: string): Promise<DesignVerifierStatusFetchResult>;
+export declare function waitForDesignVerifier(owner: string, repo: string, prNumber: number, runId: string, token: string, options?: {
+    intervalMs?: number;
+    timeoutMs?: number;
+    onProgress?: (run: DesignVerifierStatusResult) => void;
+    sleep?: (ms: number) => Promise<void>;
+}): Promise<{
+    status: 'terminal';
+    run: DesignVerifierStatusResult;
+} | {
+    status: 'timeout';
+} | {
+    status: 'error';
+    message: string;
+}>;

package/dist/utils/design-verifier-api.js

@@ -0,0 +1,175 @@
+/**
+ * Client for the design-verifier trigger route on the auth worker.
+ *
+ * The worker owns everything sensitive: it authenticates the CLI token,
+ * enforces hsk_live repo scope, resolves the PR's base/head SHAs via the
+ * GitHub App install token, and forwards to the AWS design-verifier API with
+ * the server-side shared secret. This client just POSTs and interprets the
+ * response.
+ */
+import { haystackApiUrl } from './haystack-api.js';
+function isDuration(value) {
+    return value === null || (typeof value === 'number' && Number.isFinite(value) && value >= 0);
+}
+function isTimestamp(value) {
+    return value === null || (typeof value === 'string' && Number.isFinite(Date.parse(value)));
+}
+function isTimingSummary(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const timing = value;
+    if (!isDuration(timing.admissionMs) || !isDuration(timing.pipelineDurationMs) ||
+        typeof timing.recordedStageMs !== 'number' || !isDuration(timing.recordedStageMs) ||
+        !isDuration(timing.unattributedMs) ||
+        !Array.isArray(timing.stages))
+        return false;
+    const expectedStages = ['prepare', 'bake', 'blast-radius', 'prefetch', 'case-design', 'verdict'];
+    return timing.stages.length === expectedStages.length && timing.stages.every((stage, index) => stage && typeof stage === 'object' && stage.stage === expectedStages[index] &&
+        typeof stage.status === 'string' && isDuration(stage.durationMs) && isTimestamp(stage.completedAt) &&
+        ['phase-artifact', 'phase-artifact-clock', 'cache-hit', 'missing'].includes(stage.source) &&
+        stage.breakdownMs && typeof stage.breakdownMs === 'object' && !Array.isArray(stage.breakdownMs) &&
+        Object.values(stage.breakdownMs).every((duration) => typeof duration === 'number' && isDuration(duration)));
+}
+function isDesignVerifierStatusResult(value, expected) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const run = value;
+    if (run.version !== 'dv-cli-status-v1' || run.runId !== expected.runId ||
+        run.owner !== expected.owner || run.repo !== expected.repo || run.pr !== expected.pr ||
+        typeof run.status !== 'string')
+        return false;
+    if (run.status !== 'succeeded')
+        return true;
+    return !!run.result && typeof run.result === 'object' &&
+        run.result.verdict && typeof run.result.verdict === 'object' &&
+        Array.isArray(run.result.cases) && Array.isArray(run.result.scenarios) &&
+        Array.isArray(run.result.changedFiles) && Array.isArray(run.result.probes) &&
+        (run.result.timings === undefined || isTimingSummary(run.result.timings)) &&
+        run.result.replay && typeof run.result.replay === 'object';
+}
+function apiHeaders(token) {
+    return {
+        'Cache-Control': 'no-cache',
+        'User-Agent': 'Haystack-CLI',
+        Authorization: `Bearer ${token}`,
+    };
+}
+export async function triggerDesignVerifier(owner, repo, prNumber, token) {
+    const url = haystackApiUrl(`/api/design-verifier/trigger/${owner}/${repo}/${prNumber}`);
+    let response;
+    try {
+        response = await fetch(url, {
+            method: 'POST',
+            headers: { ...apiHeaders(token), 'Content-Type': 'application/json' },
+            body: '{}',
+        });
+    }
+    catch (err) {
+        return { status: 'error', message: err.message };
+    }
+    let data = {};
+    let parseFailed = false;
+    try {
+        data = await response.json();
+    }
+    catch {
+        // Recorded, not swallowed: non-OK statuses are classified below; a 2xx
+        // with an unparseable body becomes an explicit error rather than a
+        // silently-empty success.
+        parseFailed = true;
+    }
+    if (parseFailed && response.ok) {
+        return { status: 'error', message: `Trigger endpoint returned invalid JSON (HTTP ${response.status})` };
+    }
+    if (response.ok) {
+        const outcome = data.outcome === 'queued' || data.outcome === 'duplicate' ? data.outcome : 'started';
+        if (!data.runId) {
+            return { status: 'error', message: `Trigger succeeded but no runId was returned (HTTP ${response.status})` };
+        }
+        return { status: outcome, runId: data.runId };
+    }
+    const message = data.message || data.error || `HTTP ${response.status}`;
+    // API Gateway answers 403 "Missing Authentication Token" for routes that
+    // do not exist — which is exactly what the flag-gated backend looks like
+    // before enable_design_verifier is on. The worker's own denials carry
+    // specific error codes/messages, so this signature is unambiguous.
+    if (response.status === 403 && data.message === 'Missing Authentication Token') {
+        return { status: 'unavailable', message: 'Design verifier is not enabled in this environment yet.' };
+    }
+    if (response.status === 401 || response.status === 403)
+        return { status: 'denied', message };
+    if (response.status === 429)
+        return { status: 'rate_limited', message };
+    if (response.status === 404) {
+        // Two distinct 404s share this status: the worker's own pr_not_found
+        // (carries an error code and a specific message) versus the AWS gateway
+        // 404 for the flag-gated /v3/design-verifier route not being enabled
+        // yet. Only the latter means "feature unavailable".
+        if (data.error === 'pr_not_found') {
+            return { status: 'error', message };
+        }
+        return { status: 'unavailable', message: 'Design verifier is not enabled in this environment yet.' };
+    }
+    return { status: 'error', message };
+}
+export async function getDesignVerifierStatus(owner, repo, prNumber, runId, token) {
+    const url = haystackApiUrl(`/api/design-verifier/status/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/${prNumber}/${encodeURIComponent(runId)}`);
+    let response;
+    try {
+        response = await fetch(url, { method: 'GET', headers: apiHeaders(token) });
+    }
+    catch (err) {
+        return { status: 'error', message: err.message };
+    }
+    let data = {};
+    try {
+        data = await response.json();
+    }
+    catch {
+        return { status: 'error', message: `Status endpoint returned invalid JSON (HTTP ${response.status})` };
+    }
+    if (response.ok) {
+        if (!isDesignVerifierStatusResult(data, { owner, repo, pr: prNumber, runId })) {
+            return { status: 'error', message: `Status endpoint returned an invalid or mismatched result (HTTP ${response.status})` };
+        }
+        return { status: 'ok', run: data };
+    }
+    const message = data.message || data.error || `HTTP ${response.status}`;
+    if (response.status === 401 || response.status === 403)
+        return { status: 'denied', message };
+    if (response.status === 404)
+        return { status: 'not_found', message };
+    if (response.status === 502 || response.status === 503)
+        return { status: 'unavailable', message };
+    return { status: 'error', message };
+}
+export async function waitForDesignVerifier(owner, repo, prNumber, runId, token, options = {}) {
+    const intervalMs = options.intervalMs ?? 3000;
+    const timeoutMs = options.timeoutMs ?? 2 * 60 * 60 * 1000;
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const deadline = Date.now() + timeoutMs;
+    let consecutiveErrors = 0;
+    let lastStage;
+    for (;;) {
+        const loaded = await getDesignVerifierStatus(owner, repo, prNumber, runId, token);
+        if (loaded.status !== 'ok') {
+            consecutiveErrors += 1;
+            if (loaded.status === 'denied' || loaded.status === 'not_found' || consecutiveErrors >= 3) {
+                return { status: 'error', message: loaded.message };
+            }
+        }
+        else {
+            consecutiveErrors = 0;
+            if (loaded.run.stage !== lastStage) {
+                lastStage = loaded.run.stage;
+                options.onProgress?.(loaded.run);
+            }
+            if (['succeeded', 'failed', 'failed-stale'].includes(loaded.run.status)) {
+                return { status: 'terminal', run: loaded.run };
+            }
+        }
+        if (Date.now() >= deadline)
+            return { status: 'timeout' };
+        await sleep(intervalMs);
+    }
+}

package/dist/utils/design-verifier-result.d.ts

@@ -0,0 +1,52 @@
+import type { DesignVerifierCommandSpec, DesignVerifierExecutionSummary, DesignVerifierStatusResult, DesignVerifierTimingSummary } from './design-verifier-api.js';
+export type DesignVerifierAgentVerdict = 'fix_confirmed' | 'fix_needed' | 'no_unexpected_change' | 'inconclusive';
+export interface DesignVerifierAgentCase {
+    id: string;
+    title: string;
+    story: string;
+    expectedHead: string;
+    verdict: 'confirmed' | 'finding' | 'clean' | 'inconclusive';
+    findingKind: string | null;
+    baseStable: boolean | null;
+    observations: Array<{
+        path: string;
+        base: unknown;
+        baseRepeat: unknown;
+        head: unknown;
+    }>;
+    generatedFiles: string[];
+    executedCommand: DesignVerifierCommandSpec | null;
+    executions: DesignVerifierExecutionSummary[];
+    infrastructure: {
+        verified: boolean;
+        recipeId: string | null;
+        freshInstances: number;
+        baseRepeat: string | null;
+        errors: string[];
+    } | null;
+}
+export interface DesignVerifierAgentReport {
+    ok: boolean;
+    status: 'complete' | 'failed';
+    verdict: DesignVerifierAgentVerdict;
+    headline: string;
+    explanation: string;
+    runId: string;
+    repository: string;
+    pullRequest: number;
+    revisions: {
+        base: string | null;
+        head: string | null;
+    };
+    durationMs: number | null;
+    timings: DesignVerifierTimingSummary | null;
+    changedFiles: string[];
+    cases: DesignVerifierAgentCase[];
+    inspectCommand: string;
+    replay: Record<string, unknown> | null;
+    error: string | null;
+    exitCode: 0 | 1 | 2;
+}
+export declare function buildDesignVerifierAgentReport(run: DesignVerifierStatusResult): DesignVerifierAgentReport;
+export declare function formatDesignVerifierAgentReport(report: DesignVerifierAgentReport): string;
+export declare function designVerifierStageLabel(stage: string | null): string;