@haystackeditor/cli 0.15.26 → 0.15.28

package/dist/types.d.ts

@@ -709,14 +709,14 @@ declare const SecretDeclarationSchema: z.ZodObject<{
 }>;
 declare const TriageConfigSchema: z.ZodObject<{
     /** Per-checker max agentic turns. Unspecified checkers use built-in defaults. */
-    maxTurns: z.ZodOptional<z.ZodRecord<z.ZodEnum<["code-review", "rules-validator", "intent-drift"]>, z.ZodNumber>>;
+    maxTurns: z.ZodOptional<z.ZodRecord<z.ZodEnum<["code-review", "rules-validator"]>, z.ZodNumber>>;
     /** Wall-clock timeout per checker, in milliseconds. */
     timeoutMs: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    maxTurns?: Partial<Record<"code-review" | "rules-validator" | "intent-drift", number>> | undefined;
+    maxTurns?: Partial<Record<"code-review" | "rules-validator", number>> | undefined;
     timeoutMs?: number | undefined;
 }, {
-    maxTurns?: Partial<Record<"code-review" | "rules-validator" | "intent-drift", number>> | undefined;
+    maxTurns?: Partial<Record<"code-review" | "rules-validator", number>> | undefined;
     timeoutMs?: number | undefined;
 }>;
 declare const PreferencesSchema: z.ZodObject<{
@@ -1315,14 +1315,14 @@ export declare const HaystackConfigSchema: z.ZodObject<{
     /** Pre-PR triage configuration (turn budgets, timeouts) */
     triage: z.ZodOptional<z.ZodObject<{
         /** Per-checker max agentic turns. Unspecified checkers use built-in defaults. */
-        maxTurns: z.ZodOptional<z.ZodRecord<z.ZodEnum<["code-review", "rules-validator", "intent-drift"]>, z.ZodNumber>>;
+        maxTurns: z.ZodOptional<z.ZodRecord<z.ZodEnum<["code-review", "rules-validator"]>, z.ZodNumber>>;
         /** Wall-clock timeout per checker, in milliseconds. */
         timeoutMs: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
-        maxTurns?: Partial<Record<"code-review" | "rules-validator" | "intent-drift", number>> | undefined;
+        maxTurns?: Partial<Record<"code-review" | "rules-validator", number>> | undefined;
         timeoutMs?: number | undefined;
     }, {
-        maxTurns?: Partial<Record<"code-review" | "rules-validator" | "intent-drift", number>> | undefined;
+        maxTurns?: Partial<Record<"code-review" | "rules-validator", number>> | undefined;
         timeoutMs?: number | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
@@ -1455,7 +1455,7 @@ export declare const HaystackConfigSchema: z.ZodObject<{
         description?: string | undefined;
     }> | undefined;
     triage?: {
-        maxTurns?: Partial<Record<"code-review" | "rules-validator" | "intent-drift", number>> | undefined;
+        maxTurns?: Partial<Record<"code-review" | "rules-validator", number>> | undefined;
         timeoutMs?: number | undefined;
     } | undefined;
 }, {
@@ -1588,7 +1588,7 @@ export declare const HaystackConfigSchema: z.ZodObject<{
         description?: string | undefined;
     }> | undefined;
     triage?: {
-        maxTurns?: Partial<Record<"code-review" | "rules-validator" | "intent-drift", number>> | undefined;
+        maxTurns?: Partial<Record<"code-review" | "rules-validator", number>> | undefined;
         timeoutMs?: number | undefined;
     } | undefined;
 }>;

package/dist/types.js

@@ -272,7 +272,7 @@ const SecretDeclarationSchema = z.object({
 // =============================================================================
 // TRIAGE CONFIGURATION
 // =============================================================================
-const TriageCheckerNameSchema = z.enum(['code-review', 'rules-validator', 'intent-drift']);
+const TriageCheckerNameSchema = z.enum(['code-review', 'rules-validator']);
 const TriageConfigSchema = z.object({
     /** Per-checker max agentic turns. Unspecified checkers use built-in defaults. */
     maxTurns: z.record(TriageCheckerNameSchema, z.number().int().positive()).optional(),

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

@@ -0,0 +1,200 @@
+/**
+ * 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 type DesignVerifierUniverseRole = 'control-before' | 'before' | 'after';
+export interface DesignVerifierUniverseSummary {
+    version: 'dv-case-universe-summary-v1';
+    universeId: string;
+    caseRunId: string;
+    caseId: string;
+    role: DesignVerifierUniverseRole;
+    revision: string;
+    capabilities: Array<'inspect' | 'query' | 'replay' | 'exec'>;
+    lease: {
+        state: 'leased' | 'released';
+        expiresAt: string | null;
+        available: boolean;
+    };
+}
+export interface DesignVerifierUniverseAction {
+    version: 'dv-universe-action-v1';
+    actionId: string;
+    runId: string;
+    caseId: string;
+    universe: DesignVerifierUniverseRole;
+    universeId: string;
+    action: 'replay' | 'exec';
+    command: {
+        cwd: string;
+        argv: string[];
+        timeoutMs: number;
+    };
+    status: 'queued' | 'running' | 'completed' | 'failed';
+    createdAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+    result: {
+        exitCode: number | null;
+        stdout: string;
+        stderr: string;
+        stdoutOmittedBytes: number;
+        stderrOmittedBytes: number;
+        durationMs: number;
+    } | null;
+    error: string | null;
+}
+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[];
+            universes?: DesignVerifierUniverseSummary[];
+        }>;
+        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 type DesignVerifierUniverseActionFetchResult = {
+    status: 'ok';
+    action: DesignVerifierUniverseAction;
+} | {
+    status: 'not_found' | 'denied' | 'unavailable' | 'error';
+    message: string;
+};
+export declare function startDesignVerifierUniverseAction(owner: string, repo: string, prNumber: number, runId: string, token: string, request: {
+    caseId: string;
+    universe: DesignVerifierUniverseRole;
+    action: 'replay' | 'exec';
+    argv?: string[];
+    cwd?: string;
+    timeoutMs?: number;
+}): Promise<DesignVerifierUniverseActionFetchResult>;
+export declare function getDesignVerifierUniverseAction(owner: string, repo: string, prNumber: number, runId: string, actionId: string, token: string): Promise<DesignVerifierUniverseActionFetchResult>;
+export declare function waitForDesignVerifierUniverseAction(owner: string, repo: string, prNumber: number, runId: string, actionId: string, token: string, options?: {
+    intervalMs?: number;
+    timeoutMs?: number;
+}): Promise<{
+    status: 'terminal';
+    action: DesignVerifierUniverseAction;
+} | {
+    status: 'timeout';
+} | {
+    status: '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,271 @@
+/**
+ * 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}`,
+    };
+}
+function isUniverseAction(value, expected) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const action = value;
+    return action.version === 'dv-universe-action-v1' && action.runId === expected.runId &&
+        (expected.actionId === undefined || action.actionId === expected.actionId) &&
+        (expected.caseId === undefined || action.caseId === expected.caseId) &&
+        (expected.universe === undefined || action.universe === expected.universe) &&
+        /^action-[0-9a-f-]{36}$/.test(action.actionId || '') &&
+        /^universe-[0-9a-f]{24}$/.test(action.universeId || '') &&
+        ['control-before', 'before', 'after'].includes(action.universe) &&
+        ['replay', 'exec'].includes(action.action) &&
+        ['queued', 'running', 'completed', 'failed'].includes(action.status) &&
+        action.command && Array.isArray(action.command.argv) && typeof action.command.cwd === 'string';
+}
+function universeActionPath(owner, repo, prNumber, runId) {
+    return `/api/design-verifier/universe/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/${prNumber}/${encodeURIComponent(runId)}`;
+}
+async function parseUniverseActionResponse(response, expected) {
+    let data = {};
+    try {
+        data = await response.json();
+    }
+    catch {
+        return { status: 'error', message: `Universe endpoint returned invalid JSON (HTTP ${response.status})` };
+    }
+    if (response.ok) {
+        if (!isUniverseAction(data, expected)) {
+            return { status: 'error', message: `Universe endpoint returned an invalid or mismatched result (HTTP ${response.status})` };
+        }
+        return { status: 'ok', action: 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 || response.status === 410)
+        return { status: 'not_found', message };
+    if (response.status === 502 || response.status === 503)
+        return { status: 'unavailable', message };
+    return { status: 'error', message };
+}
+export async function startDesignVerifierUniverseAction(owner, repo, prNumber, runId, token, request) {
+    let response;
+    try {
+        response = await fetch(haystackApiUrl(universeActionPath(owner, repo, prNumber, runId)), {
+            method: 'POST',
+            headers: { ...apiHeaders(token), 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
+        });
+    }
+    catch (err) {
+        return { status: 'error', message: err.message };
+    }
+    return parseUniverseActionResponse(response, {
+        runId,
+        caseId: request.caseId,
+        universe: request.universe,
+    });
+}
+export async function getDesignVerifierUniverseAction(owner, repo, prNumber, runId, actionId, token) {
+    const path = universeActionPath(owner, repo, prNumber, runId);
+    let response;
+    try {
+        response = await fetch(haystackApiUrl(`${path}?actionId=${encodeURIComponent(actionId)}`), {
+            method: 'GET',
+            headers: apiHeaders(token),
+        });
+    }
+    catch (err) {
+        return { status: 'error', message: err.message };
+    }
+    return parseUniverseActionResponse(response, { runId, actionId });
+}
+export async function waitForDesignVerifierUniverseAction(owner, repo, prNumber, runId, actionId, token, options = {}) {
+    const intervalMs = options.intervalMs ?? 1_000;
+    const deadline = Date.now() + (options.timeoutMs ?? 10 * 60_000);
+    let consecutiveErrors = 0;
+    for (;;) {
+        const loaded = await getDesignVerifierUniverseAction(owner, repo, prNumber, runId, actionId, token);
+        if (loaded.status === 'ok') {
+            consecutiveErrors = 0;
+            if (['completed', 'failed'].includes(loaded.action.status)) {
+                return { status: 'terminal', action: loaded.action };
+            }
+        }
+        else {
+            consecutiveErrors += 1;
+            if (loaded.status === 'denied' || loaded.status === 'not_found' || consecutiveErrors >= 3) {
+                return { status: 'error', message: loaded.message };
+            }
+        }
+        if (Date.now() >= deadline)
+            return { status: 'timeout' };
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}
+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,57 @@
+import type { DesignVerifierCommandSpec, DesignVerifierExecutionSummary, DesignVerifierStatusResult, DesignVerifierTimingSummary, DesignVerifierUniverseSummary } from './design-verifier-api.js';
+export type DesignVerifierAgentVerdict = 'fix_confirmed' | 'anomaly_candidate' | 'no_unexpected_change' | 'inconclusive';
+export interface DesignVerifierAgentCase {
+    id: string;
+    title: string;
+    story: string;
+    expectedHead: string;
+    verdict: 'confirmed' | 'finding' | 'clean' | 'inconclusive';
+    findingKind: string | null;
+    findingKinds: string[];
+    baseStable: boolean | null;
+    observations: Array<{
+        path: string;
+        base: unknown;
+        baseRepeat: unknown;
+        head: unknown;
+        controlObservedAtSamePath: boolean;
+        controlObservedAtAncestorPath: boolean;
+        controlObservedAtDescendantPath: boolean;
+    }>;
+    generatedFiles: string[];
+    executedCommand: DesignVerifierCommandSpec | null;
+    executions: DesignVerifierExecutionSummary[];
+    universes: DesignVerifierUniverseSummary[];
+    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;