@haystackeditor/cli 0.15.31 → 0.16.0

package/dist/commands/verify-mcp.js

@@ -1,517 +0,0 @@
-// MCP server for the cloud verifier: `haystack verify mcp`.
-//
-// Design intent (mirrors the CLI):
-// - Tools return FINDINGS, not run.json. The raw file holds evidence arrays per
-//   universe per cell; an agent asking "what broke" gets the sentence, the
-//   readings that changed, and the SDK log lines. Raw blobs sit behind `raw`.
-// - `verify_wait` is the primitive: start → wait → read. Its terminal predicate
-//   is the RUN status only — a cell can sit in `provisioning` for minutes while
-//   sandbox creation retries, and that must not end a wait.
-// - A test passes or it fails. `infra_error` means the verifier could not run
-//   it; it is surfaced under `problems`/`could_not_run`, never as a verdict.
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { cellDetail, discoverVerifyRoot, findCell, findCellByStableSelector, listRunRows, loadRunAuto, resolveServer, runDir, setVerifyToken, summarizeRun, verifyAuthHeaders, waitForTerminal, } from './verify-core.js';
-import { resolveInventory } from './verify-sandboxes.js';
-const runInput = {
-    type: 'string',
-    description: 'Run selector: a run id (run-…), a chapter id (e.g. posthog-js-3191) for its newest run, or "latest". Default "latest".',
-};
-export const VERIFY_TOOLS = [
-    {
-        name: 'verify_start',
-        description: 'Start a cloud verifier run for a specimen. Returns run_id immediately; call verify_wait next — do not poll yourself.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                specimen: { type: 'string', description: 'Specimen/chapter id (e.g. posthog-js-3191, posthog-js-478, analytics-js-255, bootstrap-text-muted, or "all").' },
-                intent_transcript: { type: 'string', description: 'Optional coding-agent transcript used as intent evidence when judging differences.' },
-            },
-            required: ['specimen'],
-        },
-    },
-    {
-        name: 'verify_status',
-        description: 'Current state of a run: per-test verdicts, counts, a findings digest (what failed and which readings moved), live environment URLs with expiry, and anything that could not run (reported as verifier defects, never as findings).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run: runInput,
-                raw: { type: 'boolean', description: 'Return the full run.json instead of the summary. It is very large; only use when the summary is insufficient.' },
-            },
-        },
-    },
-    {
-        name: 'verify_wait',
-        description: 'Block until the run reaches a terminal state (complete/failed), then return the same summary as verify_status plus outcome. Use this instead of polling: cells legitimately sit in "provisioning" for minutes while sandbox creation retries.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run: runInput,
-                timeout_seconds: { type: 'integer', minimum: 10, description: 'Give up waiting after this long (default 1800). A timeout returns the current summary with timed_out=true; the run keeps going.' },
-            },
-        },
-    },
-    {
-        name: 'verify_findings',
-        description: 'Just the problems a run found: each failing test with its verdict, the readings that moved (base → head), the judge\'s explanation, and live environment links. Lighter than verify_status when "what broke" is the only question.',
-        inputSchema: {
-            type: 'object',
-            properties: { run: runInput },
-        },
-    },
-    {
-        name: 'verify_diff',
-        description: 'Build the base-vs-head screenshot differ for one test (the same viewer as the results page: 1 what changed / 2 before / 3 after). Returns the page path plus per-step byte-identical verdicts — use those verdicts to answer "did the pixels change"; give the page path to a human.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run: runInput,
-                cell: { type: 'string', description: 'Test selector: ordinal (1-based), riskCellId, planner cellKey, or a title substring.' },
-                step: { type: 'integer', minimum: 1, description: 'Compare only the screenshot captured after this replay step.' },
-                out_dir: { type: 'string', description: 'Where to build the page (default: a temp directory).' },
-            },
-            required: ['cell'],
-        },
-    },
-    {
-        name: 'verify_list',
-        description: 'List verifier runs on disk, newest first: run id, chapters, status, verdict counts, age.',
-        inputSchema: {
-            type: 'object',
-            properties: { limit: { type: 'integer', minimum: 1, maximum: 200, description: 'Max runs to return (default 20).' } },
-        },
-    },
-    {
-        name: 'verify_cell',
-        description: 'One test in full: the finding, oracle readings that changed (base → head), request timelines, SDK log lines, artifacts, and the live environment if one is still up.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run: runInput,
-                cell: { type: 'string', description: 'Test selector: ordinal (1-based), riskCellId (cell-…), planner cellKey, or a title substring.' },
-                raw: { type: 'boolean', description: 'Return the raw RiskCell JSON (all evidence) instead of the summary.' },
-            },
-            required: ['cell'],
-        },
-    },
-    {
-        name: 'verify_universe',
-        description: 'Get or open a live universe for one test: returns the running environment when one is still live, otherwise reopens the retained state onto fresh compute (reusing an existing attachment when present).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run: runInput,
-                cell: { type: 'string', description: 'Stable test selector: ordinal (1-based), riskCellId, or exact planner cellKey.' },
-                side: { type: 'string', enum: ['base', 'head'], description: 'Matched universe side (default head).' },
-            },
-            required: ['cell'],
-        },
-    },
-    {
-        name: 'verify_cleanup',
-        description: 'Read retained-state cleanup for one test universe by its exact fork ID: shared references, provider deletion attempts, and the durable cleanup-SLO verdict.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run: runInput,
-                cell: { type: 'string', description: 'Stable test selector: ordinal (1-based), riskCellId, or exact planner cellKey.' },
-                side: { type: 'string', enum: ['base', 'head'], description: 'Matched universe side (default head).' },
-            },
-            required: ['cell'],
-        },
-    },
-    {
-        name: 'verify_reopen',
-        description: 'Attach fresh compute to retained Archil state selected by an exact fork ID or a stable run/test/side coordinate. Returns the exact sandbox ID for inspection or mutation.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                fork_id: { type: 'string', description: 'Exact structured Archil fork ID. Use this instead of run/cell to reopen a reforked child.' },
-                run: runInput,
-                cell: { type: 'string', description: 'Stable test selector: ordinal (1-based), riskCellId, or exact planner cellKey.' },
-                side: { type: 'string', enum: ['base', 'head'], description: 'Matched universe side (default head; run/cell only).' },
-            },
-            anyOf: [{ required: ['fork_id'] }, { required: ['cell'] }],
-        },
-    },
-    {
-        name: 'verify_refork',
-        description: 'Quiesce a reopened Archil universe and checkpoint it into a durable child. Select the parent by exact fork ID or stable run/test/side coordinate; child_key is a caller-supplied stable identifier.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                fork_id: { type: 'string', description: 'Exact structured Archil parent fork ID. Use this for nested reforks.' },
-                run: runInput,
-                cell: { type: 'string', description: 'Stable test selector: ordinal (1-based), riskCellId, or exact planner cellKey.' },
-                side: { type: 'string', enum: ['base', 'head'], description: 'Matched universe side (default head; run/cell only).' },
-                child_key: { type: 'string', description: 'Stable child identifier, 1-128 characters (letters, numbers, dot, underscore, colon, hyphen).' },
-            },
-            required: ['child_key'],
-            anyOf: [{ required: ['fork_id'] }, { required: ['cell'] }],
-        },
-    },
-    {
-        name: 'verify_artifact',
-        description: 'Fetch one run artifact (screenshot .png, DOM snapshot .html, video .webm, stage .json) to a local file. Small text artifacts are also returned inline.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run: runInput,
-                path: { type: 'string', description: 'Artifact path as shown by verify_cell — "<chapter>/artifacts/<file>" or a bare file name.' },
-                out_path: { type: 'string', description: 'Where to write the file (default: a temp directory).' },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'sandbox_list',
-        description: 'Inventory of running E2B sandboxes with verifier attribution (which run/test each belongs to) and staleness. The account is shared with other workstreams — "other" sandboxes are not ours.',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'sandbox_kill',
-        description: 'Kill one E2B sandbox by id. Refuses sandboxes that cannot be attributed to the verifier (the account is shared) unless force=true.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sandbox_id: { type: 'string' },
-                force: { type: 'boolean', description: 'Kill even without verifier attribution. Only when the operator has confirmed the sandbox is theirs.' },
-            },
-            required: ['sandbox_id'],
-        },
-    },
-];
-export async function runVerifyMcpServer(options) {
-    setVerifyToken(options.token);
-    const server = resolveServer(options.server);
-    const repoRoot = discoverVerifyRoot(options.repoRoot);
-    const mcp = new Server({ name: 'haystack-verify', version: '1.0.0' }, { capabilities: { tools: {} } });
-    mcp.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: VERIFY_TOOLS }));
-    mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        const input = (args ?? {});
-        const ok = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
-        const fail = (message) => ({ isError: true, content: [{ type: 'text', text: message }] });
-        const selector = typeof input.run === 'string' && input.run ? input.run : 'latest';
-        try {
-            if (name === 'verify_start') {
-                if (typeof input.specimen !== 'string')
-                    return fail('specimen required');
-                let response;
-                try {
-                    response = await fetch(`${server}/api/cloud-verifier/runs`, {
-                        method: 'POST',
-                        headers: { 'content-type': 'application/json', ...verifyAuthHeaders() },
-                        body: JSON.stringify({
-                            specimen: input.specimen,
-                            intentTranscript: typeof input.intent_transcript === 'string' ? input.intent_transcript : undefined,
-                        }),
-                    });
-                }
-                catch (error) {
-                    return fail(`Control plane at ${server} is unreachable (${error instanceof Error ? error.message : error}). Start it with \`pnpm dev\` in the repository.`);
-                }
-                const body = await response.text();
-                if (!response.ok) {
-                    let reason = body;
-                    try {
-                        reason = JSON.parse(body).error || body;
-                    }
-                    catch { /* non-JSON error body */ }
-                    return fail(`Run rejected (${response.status}): ${reason}`);
-                }
-                const started = JSON.parse(body);
-                return ok({
-                    run_id: started.runId,
-                    status: started.status,
-                    results_url: started.resultsUrl,
-                    next: `Call verify_wait with run="${started.runId}".`,
-                });
-            }
-            if (name === 'verify_status') {
-                const loaded = await loadRunAuto({ server, repoRoot, selector });
-                if (input.raw === true)
-                    return ok(loaded.run);
-                return ok(summarizeRun(loaded, server));
-            }
-            if (name === 'verify_wait') {
-                const timeoutSeconds = typeof input.timeout_seconds === 'number' ? input.timeout_seconds : 1800;
-                const result = await waitForTerminal({
-                    server,
-                    repoRoot,
-                    selector,
-                    timeoutMs: timeoutSeconds * 1000,
-                    intervalMs: 3000,
-                });
-                const summary = summarizeRun(result.loaded, server);
-                const outcome = result.timedOut ? 'timed_out'
-                    : summary.stale ? 'stale'
-                        : summary.counts.could_not_run > 0 ? 'completed_with_unrunnable_tests'
-                            : summary.status === 'failed' && summary.counts.total === 0 ? 'run_failed'
-                                : summary.counts.failed > 0 ? 'tests_failed'
-                                    : 'all_passed';
-                return ok({ outcome, timed_out: result.timedOut, ...summary });
-            }
-            if (name === 'verify_findings') {
-                const loaded = await loadRunAuto({ server, repoRoot, selector });
-                const summary = summarizeRun(loaded, server);
-                return ok({
-                    run_id: summary.run_id,
-                    status: summary.status,
-                    counts: summary.counts,
-                    findings: summary.findings,
-                    problems: summary.problems,
-                });
-            }
-            if (name === 'verify_diff') {
-                if (typeof input.cell !== 'string')
-                    return fail('cell required');
-                const { buildScreenshotDiff } = await import('./verify-ops.js');
-                const result = await buildScreenshotDiff({
-                    server,
-                    repoRoot,
-                    runSelector: selector,
-                    cellSelector: input.cell,
-                    step: typeof input.step === 'number' ? input.step : undefined,
-                    outDir: typeof input.out_dir === 'string' ? input.out_dir : undefined,
-                });
-                return ok({
-                    run_id: result.detail.run_id,
-                    ordinal: result.detail.ordinal,
-                    title: result.detail.title,
-                    html: result.html,
-                    steps: result.steps,
-                    differing: result.differing,
-                    identical: result.identical,
-                    note: 'Open the html in a browser for the visual compare (keys: 1 what changed, 2 before, 3 after, arrows step).',
-                });
-            }
-            if (name === 'verify_list') {
-                const limit = typeof input.limit === 'number' ? input.limit : 20;
-                const { rows, source, total } = await listRunRows({ server, repoRoot, limit });
-                return ok({ source, total, returned: rows.length, runs: rows });
-            }
-            if (name === 'verify_cell') {
-                if (typeof input.cell !== 'string')
-                    return fail('cell required');
-                const loaded = await loadRunAuto({ server, repoRoot, selector });
-                const match = findCell(loaded.run, input.cell);
-                if (input.raw === true)
-                    return ok(match.cell);
-                return ok(cellDetail(loaded.run, match));
-            }
-            if (name === 'verify_universe') {
-                if (typeof input.cell !== 'string')
-                    return fail('cell required');
-                if (input.side !== undefined
-                    && input.side !== 'base'
-                    && input.side !== 'head') {
-                    return fail('side must be base or head');
-                }
-                const loaded = await loadRunAuto({ server, repoRoot, selector });
-                const match = findCellByStableSelector(loaded.run, input.cell);
-                const side = input.side === 'base' ? 'base' : 'head';
-                const universe = side === 'base' ? match.cell.base : match.cell.head;
-                const expired = universe.expiresAt
-                    ? Date.parse(universe.expiresAt) < Date.now()
-                    : false;
-                if (universe.browserUrl && universe.status === 'running' && !expired) {
-                    return ok({
-                        schema_version: '1.0.0',
-                        run_id: loaded.run.runId,
-                        ordinal: match.cell.ordinal,
-                        side,
-                        source: 'running',
-                        url: universe.browserUrl,
-                        expires_at: universe.expiresAt ?? null,
-                    });
-                }
-                if (!universe.forkId) {
-                    return fail(`Test ${match.cell.ordinal}'s ${side} universe is not running and `
-                        + 'has no durable fork ID to reopen.');
-                }
-                const { requestUniverseReopen } = await import('./verify-ops.js');
-                const reopened = await requestUniverseReopen(server, universe.forkId);
-                return ok({
-                    schema_version: '1.0.0',
-                    run_id: loaded.run.runId,
-                    ordinal: match.cell.ordinal,
-                    side,
-                    source: 'reopened',
-                    url: reopened.browserUrl,
-                    expires_at: reopened.expiresAt,
-                    fork_id: reopened.forkId,
-                    sandbox_id: reopened.sandboxId,
-                    state_expires_at: reopened.stateExpiresAt,
-                    reused: reopened.reused,
-                });
-            }
-            if (name === 'verify_cleanup') {
-                if (typeof input.cell !== 'string')
-                    return fail('cell required');
-                if (input.side !== undefined
-                    && input.side !== 'base'
-                    && input.side !== 'head') {
-                    return fail('side must be base or head');
-                }
-                const loaded = await loadRunAuto({ server, repoRoot, selector });
-                const match = findCellByStableSelector(loaded.run, input.cell);
-                const side = input.side === 'base' ? 'base' : 'head';
-                const universe = side === 'base' ? match.cell.base : match.cell.head;
-                if (!universe.forkId) {
-                    return fail(`Test ${match.cell.ordinal}'s ${side} universe has no durable fork ID.`);
-                }
-                const { requestUniverseCleanupStatus } = await import('./verify-ops.js');
-                return ok({
-                    run_id: loaded.run.runId,
-                    ordinal: match.cell.ordinal,
-                    side,
-                    ...await requestUniverseCleanupStatus(server, universe.forkId),
-                });
-            }
-            if (name === 'verify_reopen' || name === 'verify_refork') {
-                if (input.side !== undefined
-                    && input.side !== 'base'
-                    && input.side !== 'head') {
-                    return fail('side must be base or head');
-                }
-                const forkId = typeof input.fork_id === 'string'
-                    ? input.fork_id
-                    : undefined;
-                const cell = typeof input.cell === 'string' ? input.cell : undefined;
-                if (forkId && cell) {
-                    return fail('provide fork_id or run/cell, not both');
-                }
-                if (!forkId && !cell)
-                    return fail('fork_id or cell required');
-                if (name === 'verify_refork') {
-                    if (typeof input.child_key !== 'string') {
-                        return fail('child_key required');
-                    }
-                    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(input.child_key)) {
-                        return fail('child_key must start with a letter or number and contain at '
-                            + 'most 128 letters, numbers, dots, underscores, colons, or hyphens');
-                    }
-                }
-                const { reforkRetainedUniverse, requestUniverseReopen, resolveRetainedUniverseTarget, } = await import('./verify-ops.js');
-                const target = await resolveRetainedUniverseTarget({
-                    server,
-                    repoRoot,
-                    source: forkId ?? selector,
-                    cellSelector: cell,
-                    side: typeof input.side === 'string' ? input.side : undefined,
-                });
-                if (name === 'verify_reopen') {
-                    const reopened = await requestUniverseReopen(server, target.forkId);
-                    return ok({
-                        schema_version: '1.0.0',
-                        run_id: target.runId,
-                        ordinal: target.ordinal,
-                        side: target.side,
-                        ...reopened,
-                    });
-                }
-                const operation = await reforkRetainedUniverse(server, target, input.child_key);
-                return ok({
-                    schema_version: '1.0.0',
-                    run_id: target.runId,
-                    ordinal: target.ordinal,
-                    side: target.side,
-                    child_key: input.child_key,
-                    attachment_sandbox_id: operation.reopened.sandboxId,
-                    reused_attachment: operation.reopened.reused,
-                    ...operation.reforked,
-                });
-            }
-            if (name === 'verify_artifact') {
-                if (typeof input.path !== 'string')
-                    return fail('path required');
-                const loaded = await loadRunAuto({ server, repoRoot, selector });
-                const run = loaded.run;
-                const requested = input.path.replace(/^\/+/, '');
-                const fileName = path.posix.basename(requested);
-                // Resolve to "<chapter>/artifacts/<file>" — accept that form or a bare
-                // file name (searched across chapters on disk / in evidence URLs).
-                let rel = requested.includes('/') ? requested : null;
-                let bytes = null;
-                const localRunDir = repoRoot ? runDir(repoRoot, run.runId) : null;
-                if (localRunDir && fs.existsSync(path.join(localRunDir, 'chapters'))) {
-                    const candidates = rel
-                        ? [path.join(localRunDir, 'chapters', rel)]
-                        : run.chapters.map(chapter => path.join(localRunDir, 'chapters', chapter.chapterId, 'artifacts', fileName));
-                    for (const candidate of candidates) {
-                        const resolved = path.resolve(candidate);
-                        if (!resolved.startsWith(path.resolve(localRunDir, 'chapters') + path.sep))
-                            continue;
-                        if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
-                            bytes = fs.readFileSync(resolved);
-                            rel = path.relative(path.join(localRunDir, 'chapters'), resolved);
-                            break;
-                        }
-                    }
-                }
-                if (!bytes) {
-                    // A bare file name carries no chapter, and artifacts live under
-                    // <chapter>/artifacts/<file> — try each chapter of the run.
-                    const candidates = rel ? [rel] : run.chapters.map(chapter => `${chapter.chapterId}/artifacts/${fileName}`);
-                    for (const candidate of candidates) {
-                        const url = `${server}/api/cloud-verifier/runs/${run.runId}/artifacts/${candidate.split('/').map(encodeURIComponent).join('/')}`;
-                        const response = await fetch(url, { headers: verifyAuthHeaders() });
-                        if (!response.ok)
-                            continue;
-                        bytes = Buffer.from(await response.arrayBuffer());
-                        rel = candidate;
-                        break;
-                    }
-                    if (!bytes)
-                        return fail(`Artifact "${input.path}" not found for ${run.runId} on disk or the control plane. Use verify_cell to list artifact paths.`);
-                }
-                const outPath = typeof input.out_path === 'string' && input.out_path
-                    ? path.resolve(input.out_path)
-                    : path.join(os.tmpdir(), 'haystack-verify-artifacts', run.runId, rel ?? fileName);
-                fs.mkdirSync(path.dirname(outPath), { recursive: true });
-                fs.writeFileSync(outPath, bytes);
-                const textual = ['.json', '.txt', '.log', '.ndjson'].includes(path.extname(outPath));
-                return ok({
-                    run_id: run.runId,
-                    artifact: rel ?? fileName,
-                    saved_to: outPath,
-                    bytes: bytes.length,
-                    ...(textual && bytes.length <= 65536 ? { content: bytes.toString('utf8') } : {}),
-                });
-            }
-            if (name === 'sandbox_list') {
-                const { inventory, via } = await resolveInventory({ server, repoRoot });
-                return ok({ ...inventory, via });
-            }
-            if (name === 'sandbox_kill') {
-                if (typeof input.sandbox_id !== 'string')
-                    return fail('sandbox_id required');
-                const { inventory, kill } = await resolveInventory({ server, repoRoot });
-                const target = inventory.sandboxes.find(row => row.sandbox_id === input.sandbox_id);
-                if (!target)
-                    return fail(`Sandbox ${input.sandbox_id} is not in the running list (already gone?).`);
-                const result = await kill(target.sandbox_id, input.force === true);
-                if (!result.ok) {
-                    return fail(`Refusing/failed to kill ${target.sandbox_id}: ${result.error}`);
-                }
-                return ok({
-                    killed: target.sandbox_id,
-                    was: target.run_id
-                        ? { run_id: target.run_id, role: target.role, cell: target.cell }
-                        : { template: target.template, forced: !target.verifier },
-                });
-            }
-            return fail(`unknown tool: ${name}`);
-        }
-        catch (error) {
-            return fail(error instanceof Error ? error.message : String(error));
-        }
-    });
-    await mcp.connect(new StdioServerTransport());
-}

package/dist/commands/verify-ops.d.ts

@@ -1,158 +0,0 @@
-import { type CellDetail } from './verify-core.js';
-export interface VerifyOpsOptions {
-    server?: string;
-    repoRoot?: string;
-    token?: string;
-    json?: boolean;
-}
-export declare function verifyStatusCommand(runSelector: string | undefined, options: VerifyOpsOptions): Promise<void>;
-export interface VerifyWatchOptions extends VerifyOpsOptions {
-    interval?: string;
-    timeout?: string;
-}
-export declare function verifyWatchCommand(runSelector: string | undefined, options: VerifyWatchOptions): Promise<void>;
-export declare function verifyListCommand(options: VerifyOpsOptions & {
-    limit?: string;
-}): Promise<void>;
-export declare function verifyShowCommand(runSelector: string, cellSelector: string, options: VerifyOpsOptions & {
-    timeline?: boolean;
-}): Promise<void>;
-export interface VerifyArtifactsOptions extends VerifyOpsOptions {
-    out?: string;
-    cell?: string;
-}
-export declare function verifyArtifactsCommand(runSelector: string, options: VerifyArtifactsOptions): Promise<void>;
-export declare function verifyFindingsCommand(runSelector: string | undefined, options: VerifyOpsOptions & {
-    full?: boolean;
-}): Promise<void>;
-export interface VerifyOpenOptions extends VerifyOpsOptions {
-    side?: string;
-    step?: string;
-    kind?: string;
-    live?: boolean;
-}
-/**
- * Open one piece of a run: a live environment (`--live`), a specific artifact
- * by file name, or a cell's video/screenshot/DOM snapshot picked by
- * --side/--step/--kind.
- */
-export declare function verifyOpenCommand(runSelector: string, target: string, options: VerifyOpenOptions): Promise<void>;
-export interface DiffResult {
-    html: string;
-    steps: Array<{
-        ordinal: number;
-        name: string;
-        identical: boolean | null;
-    }>;
-    differing: number;
-    identical: number;
-    detail: CellDetail;
-}
-/**
- * Build the screenshot-diff page for one test and report which steps differ
- * byte-for-byte. Shared by `haystack verify diff` and the MCP verify_diff tool.
- */
-export declare function buildScreenshotDiff(options: {
-    server: string;
-    repoRoot: string | null;
-    runSelector: string;
-    cellSelector: string;
-    step?: number;
-    outDir?: string;
-}): Promise<DiffResult>;
-export interface VerifyDiffOptions extends VerifyOpsOptions {
-    step?: string;
-    out?: string;
-    open?: boolean;
-}
-/**
- * Build and open the base-vs-head screenshot differ for one test — the same
- * viewer as the results page: 1 what changed / 2 before / 3 after, swapped in
- * place, with arrow keys stepping.
- */
-export declare function verifyDiffCommand(runSelector: string, cellSelector: string, options: VerifyDiffOptions): Promise<void>;
-export interface VerifyShellOptions extends VerifyOpsOptions {
-    side?: string;
-}
-export interface ReopenResponse {
-    forkId: string;
-    sandboxId: string;
-    browserUrl: string | null;
-    expiresAt: string;
-    stateExpiresAt: string;
-    reused: boolean;
-}
-export interface ReforkResponse {
-    forkId: string;
-    parentForkId: string;
-    checkpointName: string;
-    stateExpiresAt: string;
-}
-export interface RetainedUniverseTarget {
-    forkId: string;
-    runId: string | null;
-    ordinal: number | null;
-    side: 'base' | 'head' | null;
-}
-export interface UniverseCleanupStatus {
-    forkId: string;
-    catalogStatus: 'available' | 'expired' | 'deleted';
-    status: 'not_started' | 'pending' | 'complete' | 'missed';
-    checkedAt: string;
-    resources: Array<{
-        resourceIdentity: string;
-        resource: {
-            kind: 'archil-disk';
-            id: string;
-            region: string;
-        } | {
-            kind: 'e2b-snapshot';
-            id: string;
-        };
-        status: 'unregistered' | 'active' | 'deleting' | 'deleted';
-        referenceCount: number;
-        deleteAttempts: number;
-        updatedAt?: string;
-        deletion?: {
-            status: 'pending' | 'met' | 'missed';
-            requestedAt: string;
-            deadlineAt: string;
-            sloSeconds: number;
-            deletedAt?: string;
-            durationMs?: number;
-        };
-    }>;
-}
-export declare function requestUniverseCleanupStatus(server: string, forkId: string): Promise<UniverseCleanupStatus>;
-export interface VerifyCleanupOptions extends VerifyOpsOptions {
-    side?: string;
-}
-export declare function verifyCleanupCommand(runSelector: string, cellSelector: string, options: VerifyCleanupOptions): Promise<void>;
-export declare function requestUniverseReopen(server: string, forkId: string): Promise<ReopenResponse>;
-export declare function requestUniverseRefork(server: string, forkId: string, sandboxId: string, childKey: string): Promise<ReforkResponse>;
-export declare function resolveRetainedUniverseTarget(options: {
-    server: string;
-    repoRoot: string | null;
-    source: string;
-    cellSelector?: string;
-    side?: string;
-}): Promise<RetainedUniverseTarget>;
-export declare function reforkRetainedUniverse(server: string, target: RetainedUniverseTarget, childKey: string): Promise<{
-    reopened: ReopenResponse;
-    reforked: ReforkResponse;
-}>;
-export interface VerifyReopenOptions extends VerifyOpsOptions {
-    side?: string;
-    openBrowser?: boolean;
-}
-export declare function verifyReopenCommand(source: string, cellSelector: string | undefined, options: VerifyReopenOptions): Promise<void>;
-export interface VerifyReforkOptions extends VerifyOpsOptions {
-    side?: string;
-}
-export declare function verifyReforkCommand(source: string, cellOrChildKey: string, requestedChildKey: string | undefined, options: VerifyReforkOptions): Promise<void>;
-/**
- * Drop a terminal into a test's live universe via the E2B CLI. Only failing
- * tests keep a universe alive. An expired Archil-backed compute attachment is
- * transparently replaced while its durable state is still retained.
- */
-export declare function verifyShellCommand(runSelector: string, cellSelector: string, options: VerifyShellOptions): Promise<void>;