@haystackeditor/cli 0.15.21 → 0.15.22

package/README.md

@@ -33,8 +33,8 @@ Most consumers of this CLI are coding agents. These invariants hold everywhere:
 - **Every JSON payload is versioned and schema'd.** Payloads carry
   `schema_version`; print the contract with `haystack schema <name>`
   (`haystack schema` lists all: `triage`, `pr`, `pr-status`, `inbox`, `ask`,
-  `traces`, `submit`, `action`, `error`, `setup`). Schemas are JSON-Schema
-  2020-12 and CI-guarded against drift.
+  `traces`, `submit`, `action`, `cloud-verifier`, `error`, `setup`). Schemas
+  are JSON-Schema 2020-12 and CI-guarded against drift.
 - **One state vocabulary.** All state tokens are snake_case across every
   command: verdicts are `good_to_merge` / `needs_review` / `needs_input`;
   feed buckets are `analyzing`, `good_to_merge`, `issues`, `needs_assignment`,
@@ -79,6 +79,32 @@ haystack verify refork latest 3 attempt:fix-2
 haystack verify reopen archil:<disk-id>:branch:<returned-child>
 ```
 
+**`haystack verify hosted`** is the authenticated production entry point for
+exact GitHub commit pairs. It uses the repository-default saved account,
+submits an idempotent run, and waits up to 35 minutes by default:
+
+```bash
+haystack verify hosted start owner/repo \
+  --base <40-character-commit-sha> \
+  --head <40-character-commit-sha> \
+  --json
+```
+
+Use `--no-wait` to return as soon as the workflow is queued. The result includes
+an account-bound `next_command`; use it verbatim on machines with multiple
+saved GitHub accounts. Repeating the same repository/base/head tuple reuses the
+same production run by default. Pass a new explicit `--idempotency-key` only
+when a fresh execution is intentional. A bounded wait that expires still emits
+the `cloud-verifier` schema with `timed_out: true`, the last observed status,
+and `next_command`, then exits 2. Read or resume a known run with:
+
+```bash
+haystack verify hosted status cv_<48-lowercase-hex-characters> \
+  --account <login> \
+  --wait \
+  --json
+```
+
 **`haystack setup --json`** speaks NDJSON: events (`question`, `permission`,
 `progress`, `result`) on stdout, replies on stdin keyed by
 `requestID`/`permissionID`. `haystack schema setup` documents the full

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

@@ -41,15 +41,31 @@ export interface UniverseRef {
 }
 export interface RiskCell {
     riskCellId: string;
+    riskSourceId?: string;
     ordinal: number;
     title: string;
     rationale?: string;
     observableConsequence?: string;
     activationConditions?: string[];
     causalPath?: string[];
+    capabilityId?: string;
     status: string;
     severity?: string;
     confidence?: number;
+    sourceEvidence?: Array<{
+        evidenceId: string;
+        file: string;
+        line?: number;
+        excerpt?: string;
+        relationship: string;
+    }>;
+    oracles?: Array<{
+        oracleId: string;
+        kind: string;
+        description?: string;
+        measurement: string;
+        threshold?: string;
+    }>;
     durationMs?: number;
     base: UniverseRef;
     head: UniverseRef;
@@ -114,6 +130,7 @@ export interface VerificationRun {
     command: string;
     createdAt: string;
     updatedAt: string;
+    planSourceRunId?: string;
     chapters: VerificationChapter[];
     events: VerificationRunEvent[];
     summary: {
@@ -139,9 +156,15 @@ export declare class VerifyUnauthorizedError extends Error {
 export declare function discoverVerifyRoot(explicit?: string): string | null;
 export declare function runsRoot(repoRoot: string): string;
 export declare function runDir(repoRoot: string, runId: string): string;
+/**
+ * Read when a run began from the record itself. updatedAt and mtime both move
+ * when cleanup or a migration rewrites old runs and therefore cannot define
+ * "latest".
+ */
+export declare function runStartedAtMs(runJsonPath: string): number | null;
 export declare function listRunDirs(repoRoot: string): Array<{
     runId: string;
-    changedAt: number;
+    startedAt: number;
 }>;
 /** Same alias rules as the control plane: run id verbatim, `latest`, or a chapter id. */
 export declare function resolveRunIdOnDisk(repoRoot: string, requested: string): string;
@@ -179,6 +202,7 @@ export interface RunListRow {
     chapters: string[];
     status: string;
     age: string | null;
+    created_at?: string;
     updated_at: string;
     tests: number;
     passed: number;
@@ -400,6 +424,7 @@ export interface WatchCallbacks {
 export interface WatchResult {
     loaded: LoadedRun;
     timedOut: boolean;
+    endReason: 'terminal' | 'stale' | 'timeout';
 }
 /**
  * Poll until the run reaches a terminal state. The terminal predicate is the

package/dist/commands/verify-core.js

@@ -72,6 +72,36 @@ export function runsRoot(repoRoot) {
 export function runDir(repoRoot, runId) {
     return path.join(runsRoot(repoRoot), runId);
 }
+function isMissingFileError(error) {
+    return typeof error === 'object'
+        && error !== null
+        && 'code' in error
+        && error.code === 'ENOENT';
+}
+function runRecordReadError(runJsonPath, error) {
+    return new Error(`Could not read verifier run record ${runJsonPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+}
+/**
+ * Read when a run began from the record itself. updatedAt and mtime both move
+ * when cleanup or a migration rewrites old runs and therefore cannot define
+ * "latest".
+ */
+export function runStartedAtMs(runJsonPath) {
+    try {
+        const run = JSON.parse(fs.readFileSync(runJsonPath, 'utf8'));
+        if (typeof run.createdAt === 'string') {
+            const recorded = Date.parse(run.createdAt);
+            if (Number.isFinite(recorded))
+                return recorded;
+        }
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return null;
+        throw runRecordReadError(runJsonPath, error);
+    }
+    return null;
+}
 export function listRunDirs(repoRoot) {
     let entries;
     try {
@@ -82,16 +112,12 @@ export function listRunDirs(repoRoot) {
     }
     return entries
         .filter(name => name.startsWith('run-'))
-        .map(name => {
-        try {
-            return { runId: name, changedAt: fs.statSync(path.join(runsRoot(repoRoot), name, 'run.json')).mtimeMs };
-        }
-        catch {
-            return { runId: name, changedAt: 0 };
-        }
-    })
-        .filter(entry => entry.changedAt > 0)
-        .sort((a, b) => b.changedAt - a.changedAt);
+        .map(name => ({
+        runId: name,
+        startedAt: runStartedAtMs(path.join(runsRoot(repoRoot), name, 'run.json')),
+    }))
+        .filter((entry) => (entry.startedAt !== null))
+        .sort((a, b) => b.startedAt - a.startedAt);
 }
 /** Same alias rules as the control plane: run id verbatim, `latest`, or a chapter id. */
 export function resolveRunIdOnDisk(repoRoot, requested) {
@@ -102,11 +128,14 @@ export function resolveRunIdOnDisk(repoRoot, requested) {
     return match?.runId ?? requested;
 }
 export function loadRunFromDisk(repoRoot, runId) {
+    const runJsonPath = path.join(runDir(repoRoot, runId), 'run.json');
     try {
-        return JSON.parse(fs.readFileSync(path.join(runDir(repoRoot, runId), 'run.json'), 'utf8'));
+        return JSON.parse(fs.readFileSync(runJsonPath, 'utf8'));
     }
-    catch {
-        return null;
+    catch (error) {
+        if (isMissingFileError(error))
+            return null;
+        throw runRecordReadError(runJsonPath, error);
     }
 }
 export async function fetchRunFromServer(server, idOrAlias) {
@@ -158,12 +187,13 @@ function rowOfRun(run) {
         run_id: run.runId,
         chapters: run.chapters.map(chapter => chapter.chapterId),
         status: run.status,
-        age: formatAge(run.updatedAt),
+        age: formatAge(run.createdAt),
+        created_at: run.createdAt,
         updated_at: run.updatedAt,
         tests: run.summary.total,
         passed: run.summary.passed,
         failed: run.summary.failed,
-        could_not_run: run.summary.infraErrors,
+        could_not_run: run.summary.infraErrors + (run.summary.inconclusive ?? 0),
         culprit_sha: bisect?.culpritSha ?? null,
     };
 }
@@ -184,7 +214,10 @@ export async function listRunRows(options) {
             const body = (await response.json());
             if (Array.isArray(body.runs)) {
                 // Recompute ages locally so they do not drift with server response caching.
-                const rows = body.runs.map(row => ({ ...row, age: formatAge(row.updated_at) ?? row.age }));
+                const rows = body.runs.map(row => ({
+                    ...row,
+                    age: formatAge(row.created_at || row.updated_at) ?? row.age,
+                }));
                 return { rows, source: 'server', total: body.total ?? rows.length };
             }
         }
@@ -504,7 +537,7 @@ export function summarizeRun(loaded, server) {
         source: loaded.source,
         created_at: run.createdAt,
         updated_at: run.updatedAt,
-        age: formatAge(run.updatedAt),
+        age: formatAge(run.createdAt),
         counts: {
             total: run.summary.total,
             completed: run.summary.completed,
@@ -729,8 +762,9 @@ export async function waitForTerminal(options) {
         }
         first = false;
         const staleMarked = loaded.stale || loaded.run.events.some(event => event.eventId.startsWith('evt-stale-'));
-        if (isTerminal(loaded.run) && !staleMarked)
-            return { loaded, timedOut: false };
+        if (isTerminal(loaded.run) && !staleMarked) {
+            return { loaded, timedOut: false, endReason: 'terminal' };
+        }
         const progressed = loaded.run.updatedAt !== lastUpdatedAt;
         lastUpdatedAt = loaded.run.updatedAt;
         if (staleMarked) {
@@ -739,15 +773,17 @@ export async function waitForTerminal(options) {
             }
             else {
                 noProgressSince = noProgressSince ?? Date.now();
-                if (Date.now() - noProgressSince > staleGraceMs)
-                    return { loaded, timedOut: false };
+                if (Date.now() - noProgressSince > staleGraceMs) {
+                    return { loaded, timedOut: false, endReason: 'stale' };
+                }
             }
         }
         else {
             noProgressSince = null;
         }
-        if (deadline && Date.now() > deadline)
-            return { loaded, timedOut: true };
+        if (deadline && Date.now() > deadline) {
+            return { loaded, timedOut: true, endReason: 'timeout' };
+        }
         await new Promise(resolve => setTimeout(resolve, intervalMs));
     }
 }

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

@@ -0,0 +1,60 @@
+export interface HostedStartOptions {
+    base: string;
+    head: string;
+    idempotencyKey?: string;
+    account?: string;
+    wait?: boolean;
+    interval?: string;
+    timeout?: string;
+    json?: boolean;
+}
+export interface HostedStatusOptions {
+    account?: string;
+    wait?: boolean;
+    interval?: string;
+    timeout?: string;
+    json?: boolean;
+}
+interface HostedRunState {
+    runId: string;
+    status: string;
+    repository?: string;
+    baseCommit?: string;
+    headCommit?: string;
+    createdAt?: string;
+    completedAt?: string;
+    output?: Record<string, unknown>;
+    error?: string;
+}
+interface HostedPollOptions {
+    intervalMs: number;
+    timeoutMs: number;
+    onStatus?: (state: HostedRunState) => void;
+}
+interface HostedWaitResult {
+    state: HostedRunState;
+    timedOut: boolean;
+}
+export declare function parseHostedRunState(value: unknown, expectedRunId?: string): HostedRunState;
+export declare function parseHostedRepository(value: string): {
+    owner: string;
+    repository: string;
+    fullName: string;
+};
+export declare function defaultHostedIdempotencyKey(repository: string, baseCommit: string, headCommit: string): string;
+export declare function startHostedVerification(repositoryArg: string, options: HostedStartOptions, token: string): Promise<{
+    state: HostedRunState;
+    idempotencyKey: string;
+}>;
+export declare function getHostedVerification(runId: string, token: string): Promise<HostedRunState>;
+export declare function waitForHostedVerification(runId: string, token: string, options: HostedPollOptions): Promise<HostedWaitResult>;
+export declare function buildHostedJson(operation: 'start' | 'status', state: HostedRunState, extras?: {
+    account?: string;
+    idempotencyKey?: string;
+    nextCommand?: string;
+    timedOut?: boolean;
+}): Record<string, unknown>;
+export declare function hostedResumeCommand(runId: string, account?: string): string;
+export declare function verifyHostedStartCommand(repositoryArg: string, options: HostedStartOptions): Promise<void>;
+export declare function verifyHostedStatusCommand(runId: string, options: HostedStatusOptions): Promise<void>;
+export {};

package/dist/commands/verify-hosted.js

@@ -0,0 +1,342 @@
+import { createHash } from 'node:crypto';
+import chalk from 'chalk';
+import { withSchema } from '../schema.js';
+import { resolveAuthContext } from '../utils/auth.js';
+import { HaystackApiError, haystackJson } from '../utils/haystack-api.js';
+const REPOSITORY_COMPONENT = /^[A-Za-z0-9_.-]{1,100}$/;
+const COMMIT_SHA = /^[0-9a-f]{40}$/;
+const IDEMPOTENCY_KEY = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
+const RUN_ID = /^cv_[0-9a-f]{48}$/;
+const STATUS = /^[a-z][a-z0-9_-]{1,31}$/;
+const TERMINAL_STATUSES = new Set(['complete', 'errored', 'expired', 'terminated']);
+const DEFAULT_INTERVAL_SECONDS = 5;
+const DEFAULT_TIMEOUT_MINUTES = 35;
+function requireRecord(value, context) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${context} returned an invalid response object.`);
+    }
+    return value;
+}
+function requireString(value, field, pattern) {
+    const candidate = value[field];
+    if (typeof candidate !== 'string'
+        || candidate.length === 0
+        || (pattern && !pattern.test(candidate))) {
+        throw new Error(`Hosted verifier response is missing a valid ${field}.`);
+    }
+    return candidate;
+}
+function optionalString(value, field) {
+    const candidate = value[field];
+    if (candidate === undefined)
+        return undefined;
+    if (typeof candidate !== 'string' || candidate.length === 0) {
+        throw new Error(`Hosted verifier response has an invalid ${field}.`);
+    }
+    return candidate;
+}
+function optionalTimestamp(value, field) {
+    const candidate = optionalString(value, field);
+    if (candidate === undefined)
+        return undefined;
+    const parsed = new Date(candidate);
+    if (!Number.isFinite(parsed.getTime())
+        || parsed.toISOString() !== candidate) {
+        throw new Error(`Hosted verifier response has an invalid ${field}.`);
+    }
+    return candidate;
+}
+export function parseHostedRunState(value, expectedRunId) {
+    const response = requireRecord(value, 'Hosted verifier');
+    const runId = requireString(response, 'runId', RUN_ID);
+    if (expectedRunId && runId !== expectedRunId) {
+        throw new Error(`Hosted verifier returned run ${runId} while status for ${expectedRunId} was requested.`);
+    }
+    const status = requireString(response, 'status', STATUS);
+    const repository = optionalString(response, 'repository');
+    if (repository) {
+        const parts = repository.split('/');
+        if (parts.length !== 2
+            || !parts.every(part => REPOSITORY_COMPONENT.test(part))) {
+            throw new Error('Hosted verifier response has an invalid repository.');
+        }
+    }
+    const baseCommit = optionalString(response, 'baseCommit');
+    const headCommit = optionalString(response, 'headCommit');
+    if (baseCommit && !COMMIT_SHA.test(baseCommit)) {
+        throw new Error('Hosted verifier response has an invalid baseCommit.');
+    }
+    if (headCommit && !COMMIT_SHA.test(headCommit)) {
+        throw new Error('Hosted verifier response has an invalid headCommit.');
+    }
+    const outputValue = response.output;
+    const output = outputValue === undefined
+        ? undefined
+        : requireRecord(outputValue, 'Hosted verifier output');
+    const createdAt = optionalTimestamp(response, 'createdAt');
+    const completedAt = optionalTimestamp(response, 'completedAt');
+    if (status === 'complete') {
+        if (!repository
+            || !baseCommit
+            || !headCommit
+            || !createdAt
+            || !completedAt
+            || !output
+            || output.runId !== runId
+            || output.repository !== repository
+            || output.baseCommit !== baseCommit
+            || output.headCommit !== headCommit
+            || output.sourceOfflineReady !== true
+            || output.sandboxDeleted !== true) {
+            throw new Error('Hosted verifier returned a complete run without a matching terminal receipt.');
+        }
+    }
+    return {
+        runId,
+        status,
+        repository,
+        baseCommit,
+        headCommit,
+        createdAt,
+        completedAt,
+        output,
+        error: optionalString(response, 'error'),
+    };
+}
+export function parseHostedRepository(value) {
+    const parts = value.split('/');
+    if (parts.length !== 2
+        || !parts.every(part => REPOSITORY_COMPONENT.test(part))) {
+        throw new Error(`Invalid repository "${value}". Use an exact GitHub owner/repository name.`);
+    }
+    return {
+        owner: parts[0],
+        repository: parts[1],
+        fullName: value,
+    };
+}
+function requireCommit(value, flag) {
+    if (typeof value !== 'string' || !COMMIT_SHA.test(value)) {
+        throw new Error(`${flag} must be an exact 40-character lowercase commit SHA.`);
+    }
+    return value;
+}
+export function defaultHostedIdempotencyKey(repository, baseCommit, headCommit) {
+    const digest = createHash('sha256')
+        .update(JSON.stringify([repository, baseCommit, headCommit]))
+        .digest('hex');
+    return `cli:${digest}`;
+}
+function requireIdempotencyKey(value) {
+    if (!IDEMPOTENCY_KEY.test(value)) {
+        throw new Error('--idempotency-key must be 8-128 characters and use only letters, numbers, ".", "_", ":", or "-".');
+    }
+    return value;
+}
+function parsePositiveNumber(value, fallback, flag, maximum) {
+    if (value === undefined)
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed > maximum) {
+        throw new Error(`${flag} must be a positive number no greater than ${maximum}.`);
+    }
+    return parsed;
+}
+function pollingOptions(interval, timeout, onStatus) {
+    return {
+        intervalMs: parsePositiveNumber(interval, DEFAULT_INTERVAL_SECONDS, '--interval', 300) * 1000,
+        timeoutMs: parsePositiveNumber(timeout, DEFAULT_TIMEOUT_MINUTES, '--timeout', 1_440) * 60_000,
+        onStatus,
+    };
+}
+export async function startHostedVerification(repositoryArg, options, token) {
+    const repository = parseHostedRepository(repositoryArg);
+    const baseCommit = requireCommit(options.base, '--base');
+    const headCommit = requireCommit(options.head, '--head');
+    const idempotencyKey = requireIdempotencyKey(options.idempotencyKey
+        ?? defaultHostedIdempotencyKey(repository.fullName, baseCommit, headCommit));
+    const response = await haystackJson('/api/agent/cloud-verifier/runs', token, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            owner: repository.owner,
+            repository: repository.repository,
+            baseCommit,
+            headCommit,
+            idempotencyKey,
+        }),
+    });
+    const state = parseHostedRunState(response);
+    return {
+        state: {
+            ...state,
+            repository: state.repository ?? repository.fullName,
+            baseCommit: state.baseCommit ?? baseCommit,
+            headCommit: state.headCommit ?? headCommit,
+        },
+        idempotencyKey,
+    };
+}
+export async function getHostedVerification(runId, token) {
+    if (!RUN_ID.test(runId)) {
+        throw new Error('Run id must match cv_ followed by 48 lowercase hex characters.');
+    }
+    let response;
+    try {
+        response = await haystackJson(`/api/agent/cloud-verifier/runs/${encodeURIComponent(runId)}`, token, {}, [410]);
+    }
+    catch (error) {
+        if (error instanceof HaystackApiError && error.status === 404) {
+            throw new Error(`Hosted verifier run ${runId} was not found for the selected account. `
+                + 'If the run was started with another saved account, retry with `--account <login>`.');
+        }
+        throw error;
+    }
+    return parseHostedRunState(response, runId);
+}
+function delay(milliseconds) {
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+export async function waitForHostedVerification(runId, token, options) {
+    const startedAt = Date.now();
+    let lastStatus;
+    while (true) {
+        const state = await getHostedVerification(runId, token);
+        if (state.status !== lastStatus) {
+            options.onStatus?.(state);
+            lastStatus = state.status;
+        }
+        if (TERMINAL_STATUSES.has(state.status)) {
+            return { state, timedOut: false };
+        }
+        const elapsed = Date.now() - startedAt;
+        if (elapsed >= options.timeoutMs) {
+            return { state, timedOut: true };
+        }
+        await delay(Math.min(options.intervalMs, options.timeoutMs - elapsed));
+    }
+}
+export function buildHostedJson(operation, state, extras = {}) {
+    return withSchema('cloud-verifier', {
+        operation,
+        run_id: state.runId,
+        status: state.status,
+        ...(state.repository ? { repository: state.repository } : {}),
+        ...(state.baseCommit ? { base_commit: state.baseCommit } : {}),
+        ...(state.headCommit ? { head_commit: state.headCommit } : {}),
+        ...(state.createdAt ? { created_at: state.createdAt } : {}),
+        ...(state.completedAt ? { completed_at: state.completedAt } : {}),
+        ...(extras.account ? { account: extras.account } : {}),
+        ...(extras.idempotencyKey
+            ? { idempotency_key: extras.idempotencyKey }
+            : {}),
+        ...(extras.nextCommand ? { next_command: extras.nextCommand } : {}),
+        ...(extras.timedOut !== undefined ? { timed_out: extras.timedOut } : {}),
+        ...(state.output ? { output: state.output } : {}),
+        ...(state.error ? { error: state.error } : {}),
+    });
+}
+export function hostedResumeCommand(runId, account) {
+    return `haystack verify hosted status ${runId}${account ? ` --account ${account}` : ''} --wait`;
+}
+function printHostedState(operation, state, options) {
+    const nextCommand = TERMINAL_STATUSES.has(state.status)
+        ? undefined
+        : hostedResumeCommand(state.runId, options.account);
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(buildHostedJson(operation, state, {
+            account: options.account,
+            idempotencyKey: options.idempotencyKey,
+            nextCommand,
+            timedOut: options.timedOut,
+        }), null, 2)}\n`);
+        return;
+    }
+    const icon = state.status === 'complete'
+        ? chalk.green('✓')
+        : TERMINAL_STATUSES.has(state.status)
+            ? chalk.red('✗')
+            : chalk.cyan('•');
+    console.log(`${icon} Hosted verification ${chalk.bold(state.runId)}: ${state.status}`);
+    if (state.repository) {
+        console.log(`  ${chalk.dim('Repository:')} ${state.repository}`);
+    }
+    if (state.baseCommit && state.headCommit) {
+        console.log(`  ${chalk.dim('Commits:')} ${state.baseCommit.slice(0, 12)} → ${state.headCommit.slice(0, 12)}`);
+    }
+    if (state.error)
+        console.log(`  ${chalk.dim('Error:')} ${state.error}`);
+    if (options.timedOut) {
+        console.log(chalk.yellow('  Wait timed out; the production run is still active.'));
+    }
+    if (nextCommand)
+        console.log(`  ${chalk.dim('Resume:')} ${nextCommand}`);
+}
+function markNonSuccess(state, timedOut = false) {
+    if (timedOut
+        || (state.status !== 'complete' && TERMINAL_STATUSES.has(state.status))) {
+        process.exitCode = 2;
+    }
+}
+export async function verifyHostedStartCommand(repositoryArg, options) {
+    const repository = parseHostedRepository(repositoryArg);
+    const auth = await resolveAuthContext({
+        preferredLogin: options.account,
+        owner: repository.owner,
+        repo: repository.repository,
+    });
+    if (!options.json) {
+        console.error(chalk.dim('Submitting the exact commit pair to the hosted verifier…'));
+    }
+    const started = await startHostedVerification(repositoryArg, options, auth.token);
+    const selectedAccount = auth.token.startsWith('hsk_live_')
+        ? undefined
+        : auth.login;
+    let state = started.state;
+    let timedOut;
+    if (options.wait !== false && !TERMINAL_STATUSES.has(state.status)) {
+        const waited = await waitForHostedVerification(state.runId, auth.token, pollingOptions(options.interval, options.timeout, current => {
+            if (!options.json) {
+                console.error(chalk.dim(`Hosted verifier: ${current.status}…`));
+            }
+        }));
+        state = waited.state;
+        timedOut = waited.timedOut;
+    }
+    else if (options.wait !== false) {
+        timedOut = false;
+    }
+    printHostedState('start', state, {
+        json: options.json,
+        account: selectedAccount,
+        idempotencyKey: started.idempotencyKey,
+        timedOut,
+    });
+    markNonSuccess(state, timedOut);
+}
+export async function verifyHostedStatusCommand(runId, options) {
+    const auth = await resolveAuthContext({ preferredLogin: options.account });
+    const selectedAccount = auth.token.startsWith('hsk_live_')
+        ? undefined
+        : auth.login;
+    let state = await getHostedVerification(runId, auth.token);
+    let timedOut;
+    if (options.wait && !TERMINAL_STATUSES.has(state.status)) {
+        const waited = await waitForHostedVerification(runId, auth.token, pollingOptions(options.interval, options.timeout, current => {
+            if (!options.json) {
+                console.error(chalk.dim(`Hosted verifier: ${current.status}…`));
+            }
+        }));
+        state = waited.state;
+        timedOut = waited.timedOut;
+    }
+    else if (options.wait) {
+        timedOut = false;
+    }
+    printHostedState('status', state, {
+        json: options.json,
+        account: selectedAccount,
+        timedOut,
+    });
+    markNonSuccess(state, timedOut);
+}