@haystackeditor/cli 0.15.29 → 0.15.31

package/dist/commands/verify-hosted.js

@@ -3,7 +3,7 @@ import { readFileSync } from 'node:fs';
 import chalk from 'chalk';
 import { withSchema } from '../schema.js';
 import { resolveAuthContext } from '../utils/auth.js';
-import { HaystackApiError, haystackJson } from '../utils/haystack-api.js';
+import { classifyHttpError, HaystackApiError, haystackApiUrl, 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}$/;
@@ -17,6 +17,7 @@ const INTENT_FIELDS = [
     'goal',
     'intended_outcomes',
 ];
+const FLEET_PROJECTION_VERSION = 'dv-cloud-verifier-fleet-runner-projection-v1';
 function requireRecord(value, context) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         throw new Error(`${context} returned an invalid response object.`);
@@ -80,12 +81,70 @@ export function parseHostedRunState(value, expectedRunId) {
         ? undefined
         : requireRecord(outputValue, 'Hosted verifier output');
     const resultValue = response.result;
-    const result = resultValue === undefined
+    const fleet = response.provider === 'haystack';
+    if (response.provider !== undefined && !fleet) {
+        throw new Error('Hosted verifier returned an unsupported provider.');
+    }
+    if (fleet && response.version !== FLEET_PROJECTION_VERSION) {
+        throw new Error('Hosted verifier returned an unsupported fleet projection version.');
+    }
+    const result = fleet || resultValue === undefined
         ? undefined
         : parseHostedRunnerResult(resultValue);
     const createdAt = optionalTimestamp(response, 'createdAt');
     const completedAt = optionalTimestamp(response, 'completedAt');
-    if (status === 'complete') {
+    let progress;
+    let fleetResult;
+    if (fleet) {
+        if (response.publicRunId !== runId || !repository || !baseCommit || !headCommit || !createdAt || output) {
+            throw new Error('Hosted fleet projection is missing its immutable run identity.');
+        }
+        if (response.progress !== undefined && response.progress !== null) {
+            progress = requireRecord(response.progress, 'Hosted fleet progress');
+            if (progress.version !== 'dv-verify-progress-v1' || progress.publicRunId !== runId) {
+                throw new Error('Hosted fleet progress does not match the requested run.');
+            }
+            requireString(progress, 'stage');
+            requireString(progress, 'status');
+        }
+        if (resultValue !== undefined && resultValue !== null) {
+            fleetResult = requireRecord(resultValue, 'Hosted fleet result');
+            const mapping = requireRecord(fleetResult.mapping, 'Hosted fleet result mapping');
+            const provenance = requireRecord(fleetResult.provenance, 'Hosted fleet provenance');
+            if (fleetResult.version !== 'dv-verify-result-v1' || fleetResult.provider !== 'haystack'
+                || mapping.publicRunId !== runId || provenance.baseSha !== baseCommit || provenance.headSha !== headCommit) {
+                throw new Error('Hosted fleet result does not match the requested run and commits.');
+            }
+            // CONTRACT-GAP: P0 currently couples its canonical parsers to runner-only
+            // modules outside this published CLI. The server validates the complete
+            // P0 result; the CLI only checks the fields it presents, retaining the
+            // original document instead of defining a second P0 wire contract.
+            requireString(fleetResult, 'lifecycle', /^(complete|failed|cancelled|budget-stopped|account-action)$/);
+            requireString(fleetResult, 'runHealth', /^(healthy|degraded|infrastructure-error|not-executed)$/);
+            const cleanup = requireRecord(fleetResult.cleanup, 'Hosted fleet cleanup');
+            requireString(cleanup, 'status', /^(complete|pending)$/);
+            if (!Array.isArray(cleanup.pending) || !Array.isArray(fleetResult.findings)) {
+                throw new Error('Hosted fleet result has invalid findings or cleanup.');
+            }
+            for (const value of fleetResult.findings) {
+                const finding = requireRecord(value, 'Hosted fleet finding');
+                requireString(finding, 'findingId');
+                requireString(finding, 'caseId');
+                requireString(finding, 'judgment');
+            }
+            if (fleetResult.savedChecks !== undefined) {
+                parseHostedSavedChecks(fleetResult.savedChecks, runId, headCommit);
+            }
+            requireString(provenance, 'intent', /^(user|inferred)$/);
+            if (status === 'complete' && fleetResult.lifecycle !== 'complete') {
+                throw new Error('Hosted fleet lifecycle disagrees with its completed job.');
+            }
+        }
+        if (status === 'complete' && !fleetResult) {
+            throw new Error('Hosted fleet run completed without a result receipt.');
+        }
+    }
+    else if (status === 'complete') {
         // Two terminal shapes exist: the Workflow receipt envelope (`output`)
         // and the runner-queue result envelope (`result`). Exactly one must
         // validate.
@@ -119,6 +178,7 @@ export function parseHostedRunState(value, expectedRunId) {
         completedAt,
         output,
         result,
+        ...(fleet ? { provider: 'haystack', version: FLEET_PROJECTION_VERSION, progress, fleetResult } : {}),
         error: optionalString(response, 'error'),
     };
 }
@@ -159,12 +219,104 @@ export function parseHostedRepository(value) {
         fullName: value,
     };
 }
+/** The service validates the shared full contract. Check every additional
+ * field used by this published CLI before displaying or accepting a clean run. */
+function parseHostedSavedChecks(value, runId, headSha) {
+    const saved = requireRecord(value, 'Hosted saved checks');
+    if (saved.version !== 'dv-fleet-saved-check-result-v1'
+        || !Array.isArray(saved.descriptors) || !Array.isArray(saved.outcomes)
+        || !Array.isArray(saved.unresolvedFindings) || !Array.isArray(saved.conflicts)) {
+        throw new Error('Hosted saved checks have an invalid version or records.');
+    }
+    const completeness = requireRecord(saved.completeness, 'Hosted saved check completeness');
+    requireString(completeness, 'status', /^(complete|incomplete)$/);
+    if (completeness.status === 'incomplete' && (!Array.isArray(completeness.reasons) || completeness.reasons.length === 0)) {
+        throw new Error('Hosted saved check history has no explanation for missing evidence.');
+    }
+    const ref = (record) => {
+        requireString(record, 'checkId', /^[0-9a-f]{64}$/);
+        requireString(record, 'planRevisionId', /^[0-9a-f]{64}$/);
+        return `${record.checkId}:${record.planRevisionId}`;
+    };
+    const descriptors = new Map();
+    for (const value of saved.descriptors) {
+        const descriptor = requireRecord(value, 'Hosted saved check descriptor');
+        const key = ref(descriptor);
+        if (descriptor.version !== 'dv-fleet-saved-check-v1' || descriptors.has(key)) {
+            throw new Error('Hosted saved check descriptor identity is invalid or duplicated.');
+        }
+        requireString(descriptor, 'captureStatus', /^(captured|unavailable)$/);
+        descriptors.set(key, descriptor);
+    }
+    const outcomes = new Map();
+    for (const value of saved.outcomes) {
+        const outcome = requireRecord(value, 'Hosted saved check outcome');
+        const key = ref(outcome);
+        requireString(outcome, 'status', /^(passed|reproduced|blocked|inconclusive)$/);
+        if (outcome.version !== 'dv-fleet-saved-check-outcome-v1'
+            || (!descriptors.has(key) && completeness.status !== 'incomplete') || outcomes.has(key)
+            || outcome.publicRunId !== runId || outcome.headSha !== headSha
+            || (outcome.currentCaseId !== null && typeof outcome.currentCaseId !== 'string')
+            || (outcome.blockedCode !== null && typeof outcome.blockedCode !== 'string')) {
+            throw new Error('Hosted saved check outcome does not match its current run or original check.');
+        }
+        if ((outcome.status === 'blocked') !== (outcome.blockedCode !== null)
+            || (outcome.status === 'passed' && (descriptors.get(key)?.captureStatus !== 'captured'
+                || outcome.currentCaseId === null || !outcome.receipt || completeness.status !== 'complete'))) {
+            throw new Error('Hosted saved check outcome claims a pass without original execution evidence.');
+        }
+        outcomes.set(key, outcome);
+    }
+    const findings = new Set();
+    for (const value of saved.unresolvedFindings) {
+        const finding = requireRecord(value, 'Hosted unresolved finding');
+        const key = ref(finding);
+        requireString(finding, 'findingId');
+        const source = requireRecord(finding.firstObserved, 'Hosted original finding evidence');
+        requireString(source, 'publicRunId', RUN_ID);
+        requireString(source, 'caseId');
+        requireString(source, 'headSha', COMMIT_SHA);
+        if (finding.version !== 'dv-fleet-unresolved-finding-v1'
+            || (!descriptors.has(key) && completeness.status !== 'incomplete')
+            || findings.has(finding.findingId) || !Array.isArray(source.evidence) || source.evidence.length === 0
+            || outcomes.get(key)?.status === 'passed') {
+            throw new Error('Hosted unresolved finding has invalid original evidence or check identity.');
+        }
+        findings.add(finding.findingId);
+        if (finding.lastOutcome !== null) {
+            const last = requireRecord(finding.lastOutcome, 'Hosted unresolved finding outcome');
+            if (ref(last) !== key || last.status === 'passed')
+                throw new Error('Hosted unresolved finding lost its exact original check.');
+            requireString(last, 'status', /^(reproduced|blocked|inconclusive)$/);
+            if (last.blockedCode !== null)
+                requireString(last, 'blockedCode');
+        }
+    }
+    for (const value of saved.conflicts) {
+        const conflict = requireRecord(value, 'Hosted saved check conflict');
+        requireString(conflict, 'checkId', /^[0-9a-f]{64}$/);
+        if (!Array.isArray(conflict.planRevisionIds) || conflict.planRevisionIds.length < 2
+            || conflict.planRevisionIds.some(id => typeof id !== 'string' || !/^[0-9a-f]{64}$/.test(id))) {
+            throw new Error('Hosted saved check conflict is invalid.');
+        }
+    }
+    return saved;
+}
+function savedCheckDisplay(value) {
+    return String(value).replace(/[\u0000-\u001f\u007f-\u009f]/g, '');
+}
 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;
 }
+function requireRevision(value, flag) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 1_024 || /[\u0000-\u0020\u007f]/.test(value)) {
+        throw new Error(`${flag} must be a non-empty Git revision of at most 1024 characters without whitespace or control characters.`);
+    }
+    return value;
+}
 export function readHostedIntentFile(intentFile) {
     if (typeof intentFile !== 'string' || intentFile.length === 0) {
         throw new Error('--intent-file is required and must name a JSON file containing exactly problem, goal, and intended_outcomes.');
@@ -213,11 +365,13 @@ export function readHostedIntentFile(intentFile) {
         intended_outcomes: record.intended_outcomes,
     };
 }
-export function defaultHostedIdempotencyKey(repository, baseCommit, headCommit, replayPlanFrom) {
+export function defaultHostedIdempotencyKey(repository, baseCommit, headCommit, replayPlanFrom, fleetRequest) {
     const digest = createHash('sha256')
-        .update(JSON.stringify(replayPlanFrom
-        ? [repository, baseCommit, headCommit, replayPlanFrom]
-        : [repository, baseCommit, headCommit]))
+        .update(JSON.stringify(fleetRequest
+        ? [fleetRequest.provider, repository, baseCommit, headCommit, fleetRequest.intent ?? null]
+        : replayPlanFrom
+            ? [repository, baseCommit, headCommit, replayPlanFrom]
+            : [repository, baseCommit, headCommit]))
         .digest('hex');
     return `cli:${digest}`;
 }
@@ -244,42 +398,77 @@ export function hostedPollingOptions(interval, timeout, onStatus) {
     };
 }
 export async function startHostedVerification(repositoryArg, options, token) {
+    const { repository, launchBody, idempotencyKey } = prepareHostedLaunch(repositoryArg, options);
+    const path = '/api/agent/cloud-verifier/runs';
+    const response = await fetch(haystackApiUrl(path), {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: 'application/json',
+            'User-Agent': 'Haystack-CLI',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(launchBody),
+    });
+    if (!response.ok) {
+        // Keep the shared HTTP classification and raw-body fallback while exposing
+        // the launch service's additional explanation for a retryable failure.
+        const body = response.status === 503
+            ? await response.clone().json().catch(() => null)
+            : null;
+        const error = await classifyHttpError(response, `Haystack API ${path}`);
+        if (body && typeof body === 'object' && 'detail' in body
+            && typeof body.detail === 'string' && body.detail.trim()) {
+            error.message += ` Details: ${body.detail}`;
+        }
+        throw error;
+    }
+    const state = parseHostedRunState(await response.json());
+    if (options.provider === 'haystack' && state.provider !== 'haystack') {
+        throw new Error('Hosted verifier did not acknowledge the fleet-pinned request.');
+    }
+    return {
+        state: {
+            ...state,
+            repository: state.repository ?? repository.fullName,
+            baseCommit: state.baseCommit ?? launchBody.baseCommit,
+            headCommit: state.headCommit ?? launchBody.headCommit,
+        },
+        idempotencyKey,
+    };
+}
+function prepareHostedLaunch(repositoryArg, options) {
     const repository = parseHostedRepository(repositoryArg);
-    const baseCommit = requireCommit(options.base, '--base');
-    const headCommit = requireCommit(options.head, '--head');
-    const intent = readHostedIntentFile(options.intentFile);
+    const fleet = options.provider === 'haystack';
+    const validateRevision = fleet ? requireRevision : requireCommit;
+    const baseCommit = validateRevision(options.base, '--base');
+    const headCommit = validateRevision(options.head, '--head');
+    const intent = fleet && options.intentFile === undefined ? undefined : readHostedIntentFile(options.intentFile);
+    if (fleet && intent && [intent.problem, intent.goal, ...intent.intended_outcomes].some(value => /[\u0000-\u001f\u007f]/.test(value))) {
+        throw new Error('Fleet --intent-file fields must be single-line text without control characters.');
+    }
     const replayPlanFrom = options.replayPlanFrom;
+    if (fleet && replayPlanFrom !== undefined) {
+        throw new Error('--replay-plan-from is available through the explicit hosted start alias.');
+    }
     if (replayPlanFrom !== undefined && !RUN_ID.test(replayPlanFrom)) {
         throw new Error('--replay-plan-from must match cv_ followed by 48 lowercase hex characters.');
     }
     const idempotencyKey = requireIdempotencyKey(options.idempotencyKey
-        ?? defaultHostedIdempotencyKey(repository.fullName, baseCommit, headCommit, replayPlanFrom));
+        ?? defaultHostedIdempotencyKey(repository.fullName, baseCommit, headCommit, replayPlanFrom, fleet ? { provider: 'haystack', intent } : undefined));
     const launchBody = {
+        ...(fleet ? { provider: 'haystack' } : {}),
         owner: repository.owner,
         repository: repository.repository,
         baseCommit,
         headCommit,
         idempotencyKey,
-        intent,
+        ...(intent ? { intent } : {}),
         ...(replayPlanFrom
             ? { replayPlanFromRunId: replayPlanFrom }
             : {}),
     };
-    const response = await haystackJson('/api/agent/cloud-verifier/runs', token, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(launchBody),
-    });
-    const state = parseHostedRunState(response);
-    return {
-        state: {
-            ...state,
-            repository: state.repository ?? repository.fullName,
-            baseCommit: state.baseCommit ?? baseCommit,
-            headCommit: state.headCommit ?? headCommit,
-        },
-        idempotencyKey,
-    };
+    return { repository, launchBody, idempotencyKey };
 }
 export async function getHostedVerification(runId, token) {
     if (!RUN_ID.test(runId)) {
@@ -303,12 +492,13 @@ function delay(milliseconds) {
 }
 export async function waitForHostedVerification(runId, token, options) {
     const startedAt = Date.now();
-    let lastStatus;
+    let lastProgress;
     for (;;) {
         const state = await getHostedVerification(runId, token);
-        if (state.status !== lastStatus) {
+        const progressKey = JSON.stringify([state.status, state.progress?.sequence, state.progress?.stage, state.progress?.status]);
+        if (progressKey !== lastProgress) {
             options.onStatus?.(state);
-            lastStatus = state.status;
+            lastProgress = progressKey;
         }
         if (TERMINAL_STATUSES.has(state.status)) {
             return { state, timedOut: false };
@@ -338,6 +528,9 @@ export function buildHostedJson(operation, state, extras = {}) {
         ...(extras.timedOut !== undefined ? { timed_out: extras.timedOut } : {}),
         ...(state.output ? { output: state.output } : {}),
         ...(state.result ? { result: state.result } : {}),
+        ...(state.provider ? { provider: state.provider, version: state.version } : {}),
+        ...(state.progress ? { progress: state.progress } : {}),
+        ...(state.fleetResult ? { result: state.fleetResult } : {}),
         ...(state.error ? { error: state.error } : {}),
     });
 }
@@ -357,11 +550,13 @@ function printHostedState(operation, state, options) {
         }), null, 2)}\n`);
         return;
     }
-    const icon = state.status === 'complete'
-        ? chalk.green('✓')
-        : TERMINAL_STATUSES.has(state.status)
-            ? chalk.red('✗')
-            : chalk.cyan('•');
+    const icon = state.provider === 'haystack' && state.status === 'complete'
+        ? chalk.cyan('•')
+        : 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}`);
@@ -378,6 +573,42 @@ function printHostedState(operation, state, options) {
         }
         console.log(`  ${chalk.dim('Artifacts:')} ${state.result.outputLocation}`);
     }
+    if (state.progress) {
+        console.log(`  ${chalk.dim('Progress:')} ${state.progress.stage} (${state.progress.status})`);
+    }
+    if (state.fleetResult) {
+        const result = state.fleetResult;
+        const cleanup = requireRecord(result.cleanup, 'Hosted fleet cleanup');
+        const provenance = requireRecord(result.provenance, 'Hosted fleet provenance');
+        console.log(`  ${chalk.dim('Lifecycle:')} ${result.lifecycle}`);
+        console.log(`  ${chalk.dim('Run health:')} ${result.runHealth}`);
+        console.log(`  ${chalk.dim('Intent:')} ${provenance.intent}`);
+        console.log(`  ${chalk.dim('Cleanup:')} ${cleanup.status} (${cleanup.pending.length} pending)`);
+        for (const value of result.findings) {
+            const finding = requireRecord(value, 'Hosted fleet finding');
+            console.log(`  ${chalk.dim('Finding:')} ${finding.findingId} / ${finding.caseId}: ${finding.judgment}`);
+        }
+        if (result.savedChecks !== undefined) {
+            const saved = requireRecord(result.savedChecks, 'Hosted saved checks');
+            const completeness = requireRecord(saved.completeness, 'Hosted saved check completeness');
+            const unresolved = saved.unresolvedFindings;
+            console.log(`  ${chalk.dim('Saved checks:')} ${completeness.status}; ${saved.conflicts.length} conflicts; ${unresolved.length} unresolved bugs`);
+            for (const value of unresolved) {
+                const finding = requireRecord(value, 'Hosted unresolved finding');
+                const source = requireRecord(finding.firstObserved, 'Hosted original finding evidence');
+                const last = finding.lastOutcome === null ? null : requireRecord(finding.lastOutcome, 'Hosted unresolved finding outcome');
+                console.log(`  ${chalk.yellow('Unresolved:')} ${savedCheckDisplay(finding.findingId)} / ${savedCheckDisplay(source.caseId)}`);
+                console.log(`    First reproduced at ${String(source.headSha).slice(0, 12)}; latest check: ${savedCheckDisplay(last?.status ?? 'not executed')}${last?.blockedCode ? ` (${savedCheckDisplay(last.blockedCode)})` : ''}`);
+            }
+            if (unresolved.length)
+                console.log('  Earlier bug evidence remains open until the exact saved check passes.');
+            if (completeness.status === 'incomplete')
+                console.log('  Saved check history is incomplete; this run cannot confirm earlier bugs are fixed.');
+        }
+        else {
+            console.log(`  ${chalk.dim('Saved checks:')} unavailable for this run`);
+        }
+    }
     if (state.error)
         console.log(`  ${chalk.dim('Error:')} ${state.error}`);
     if (options.timedOut) {
@@ -387,23 +618,48 @@ function printHostedState(operation, state, options) {
         console.log(`  ${chalk.dim('Resume:')} ${nextCommand}`);
 }
 function markNonSuccess(state, timedOut = false) {
+    if (state.fleetResult) {
+        const result = state.fleetResult;
+        const cleanup = requireRecord(result.cleanup, 'Hosted fleet cleanup');
+        if (result.lifecycle !== 'complete' || result.runHealth !== 'healthy' || cleanup.status !== 'complete') {
+            process.exitCode = 2;
+            return;
+        }
+        if (result.savedChecks !== undefined) {
+            const saved = requireRecord(result.savedChecks, 'Hosted saved checks');
+            const completeness = requireRecord(saved.completeness, 'Hosted saved check completeness');
+            if (completeness.status !== 'complete' || saved.conflicts.length > 0) {
+                process.exitCode = 2;
+                return;
+            }
+            if (saved.unresolvedFindings.length > 0)
+                process.exitCode = 1;
+        }
+        if (result.findings.some(value => requireRecord(value, 'Hosted fleet finding').judgment === 'regression')) {
+            process.exitCode = 1;
+        }
+    }
     if (timedOut
         || (state.status !== 'complete' && TERMINAL_STATUSES.has(state.status))) {
         process.exitCode = 2;
     }
 }
 export async function verifyHostedStartCommand(repositoryArg, options) {
-    const repository = parseHostedRepository(repositoryArg);
-    // Fail before account resolution so an invalid local intent never advances
-    // toward a hosted launch.
-    readHostedIntentFile(options.intentFile);
+    // Validate all local input before resolving accounts or submitting a job.
+    const { repository } = prepareHostedLaunch(repositoryArg, options);
+    const polling = hostedPollingOptions(options.interval, options.timeout, current => {
+        if (!options.json)
+            console.error(chalk.dim(hostedProgressMessage(current)));
+    });
     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…'));
+        console.error(chalk.dim(options.provider === 'haystack'
+            ? 'Submitting repository revisions to the hosted fleet verifier…'
+            : 'Submitting the exact commit pair to the hosted verifier…'));
     }
     const started = await startHostedVerification(repositoryArg, options, auth.token);
     const selectedAccount = auth.token.startsWith('hsk_live_')
@@ -412,11 +668,7 @@ export async function verifyHostedStartCommand(repositoryArg, options) {
     let state = started.state;
     let timedOut;
     if (options.wait !== false && !TERMINAL_STATUSES.has(state.status)) {
-        const waited = await waitForHostedVerification(state.runId, auth.token, hostedPollingOptions(options.interval, options.timeout, current => {
-            if (!options.json) {
-                console.error(chalk.dim(`Hosted verifier: ${current.status}…`));
-            }
-        }));
+        const waited = await waitForHostedVerification(state.runId, auth.token, polling);
         state = waited.state;
         timedOut = waited.timedOut;
     }
@@ -431,7 +683,14 @@ export async function verifyHostedStartCommand(repositoryArg, options) {
     });
     markNonSuccess(state, timedOut);
 }
+function hostedProgressMessage(state) {
+    return `Hosted verifier: ${state.status}${state.progress ? ` · ${state.progress.stage} (${state.progress.status})` : ''}…`;
+}
 export async function verifyHostedStatusCommand(runId, options) {
+    const polling = hostedPollingOptions(options.interval, options.timeout, current => {
+        if (!options.json)
+            console.error(chalk.dim(hostedProgressMessage(current)));
+    });
     const auth = await resolveAuthContext({ preferredLogin: options.account });
     const selectedAccount = auth.token.startsWith('hsk_live_')
         ? undefined
@@ -439,11 +698,7 @@ export async function verifyHostedStatusCommand(runId, options) {
     let state = await getHostedVerification(runId, auth.token);
     let timedOut;
     if (options.wait && !TERMINAL_STATUSES.has(state.status)) {
-        const waited = await waitForHostedVerification(runId, auth.token, hostedPollingOptions(options.interval, options.timeout, current => {
-            if (!options.json) {
-                console.error(chalk.dim(`Hosted verifier: ${current.status}…`));
-            }
-        }));
+        const waited = await waitForHostedVerification(runId, auth.token, polling);
         state = waited.state;
         timedOut = waited.timedOut;
     }

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

@@ -1,4 +1,12 @@
-export type PrecomputeOutcome = 'enqueued' | 'cached' | 'existing' | 'skipped_no_auth' | 'error';
+import type { DeliverPrecomputeRequest } from './precompute-delivery-contract.js';
+export type RepoWalkHookStatus = {
+    status: 'queued' | 'existing';
+    runId: string;
+} | {
+    status: 'unavailable';
+    reason: 'runner-unavailable' | 'enqueue-failed';
+};
+export type PrecomputeOutcome = 'pending' | 'enqueued' | 'cached' | 'existing' | 'skipped_no_auth' | 'error';
 export interface VerifyPrecomputeOptions {
     hook?: boolean;
 }
@@ -7,6 +15,7 @@ export interface FrontHalfEnqueueRequest {
     repository: string;
     baseCommit: string;
     workCommit: string;
+    observedAt: number;
     cacheKey: string;
     patchGzBase64: string;
     patchSha256: string;
@@ -16,4 +25,6 @@ export interface PrecomputeDerivation {
     request: FrontHalfEnqueueRequest;
 }
 export declare function derivePrecomputeRequest(gitRoot: string, owner: string, repository: string, deadline?: number): Promise<PrecomputeDerivation>;
+/** One authenticated submission of the already captured request. No source reads or retries. */
+export declare const deliverPrecomputeRequest: DeliverPrecomputeRequest;
 export declare function verifyPrecomputeCommand(options: VerifyPrecomputeOptions): Promise<void>;