@haystackeditor/cli 0.15.30 → 0.16.0

package/dist/commands/policy.js

@@ -10,7 +10,8 @@
 import chalk from 'chalk';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
-import inquirer from 'inquirer';
+import { confirm as confirmPrompt, input, select } from '@inquirer/prompts';
+import { runPrompt } from '../utils/prompter.js';
 const POLICY_PATH = '.haystack/review-policy.md';
 // ============================================================================
 // Markdown Parsing
@@ -18,7 +19,7 @@ const POLICY_PATH = '.haystack/review-policy.md';
 /**
  * Parse review-policy.md content into ReviewPolicy objects and instructions
  */
-function parsePolicyMarkdown(content) {
+export function parsePolicyMarkdown(content) {
     const policies = [];
     const instructions = [];
     // Split by H2 headings (## )
@@ -45,9 +46,11 @@ function parsePolicyMarkdown(content) {
         let paths = [];
         let severity = 'medium';
         let reason = '';
-        // Parse bullet points
+        // Parse fields. serializePolicies (and therefore policy init/add/remove and
+        // setup) writes them as bullets, `- **Paths**: ...`; hand-written files may
+        // omit the bullet, so accept both.
         for (const line of lines.slice(1)) {
-            const trimmed = line.trim();
+            const trimmed = line.trim().replace(/^[-*]\s+/, '');
             // Match **Paths**: `pattern1`, `pattern2`
             const pathsMatch = trimmed.match(/^\*\*Paths?\*\*:\s*(.+)$/i);
             if (pathsMatch) {
@@ -84,7 +87,7 @@ function parsePolicyMarkdown(content) {
 /**
  * Serialize ReviewPolicy objects and instructions back to markdown
  */
-function serializePolicies(policies, instructions = []) {
+export function serializePolicies(policies, instructions = []) {
     const lines = ['# Review Policies', ''];
     if (instructions.length > 0) {
         lines.push('## Instructions', '');
@@ -177,30 +180,24 @@ export async function addPolicy(nameArg) {
     }
     console.log(chalk.cyan('\n➕ Add Review Policy\n'));
     // Prompt for policy details
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'name',
+    const answers = {
+        name: await runPrompt(input({
             message: 'Policy name:',
             default: nameArg,
-            validate: (input) => {
-                if (!input.trim())
+            validate: (value) => {
+                if (!value.trim())
                     return 'Name is required';
-                if (policies.some(p => p.name.toLowerCase() === input.toLowerCase())) {
+                if (policies.some(p => p.name.toLowerCase() === value.toLowerCase())) {
                     return 'A policy with this name already exists';
                 }
                 return true;
             },
-        },
-        {
-            type: 'input',
-            name: 'paths',
+        })),
+        paths: await runPrompt(input({
             message: 'File patterns (comma-separated globs):',
-            validate: (input) => input.trim() ? true : 'At least one path pattern is required',
-        },
-        {
-            type: 'list',
-            name: 'severity',
+            validate: (value) => value.trim() ? true : 'At least one path pattern is required',
+        })),
+        severity: await runPrompt(select({
             message: 'Severity:',
             choices: [
                 { name: chalk.red('critical') + ' - Always requires human review', value: 'critical' },
@@ -209,14 +206,12 @@ export async function addPolicy(nameArg) {
                 { name: chalk.dim('low') + ' - Nice to review', value: 'low' },
             ],
             default: 'medium',
-        },
-        {
-            type: 'input',
-            name: 'reason',
+        })),
+        reason: await runPrompt(input({
             message: 'Reason for requiring review:',
-            validate: (input) => input.trim() ? true : 'Reason is required',
-        },
-    ]);
+            validate: (value) => value.trim() ? true : 'Reason is required',
+        })),
+    };
     // Parse paths from comma-separated input
     const paths = answers.paths.split(',').map((p) => p.trim()).filter(Boolean);
     const newPolicy = {
@@ -264,14 +259,10 @@ export async function removePolicy(name) {
     // Confirm removal. Without a TTY the prompt would hang — the command names
     // an exact policy, so treat the invocation itself as the confirmation.
     if (process.stdin.isTTY) {
-        const { confirm } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: `Remove policy "${removed.name}"?`,
-                default: false,
-            },
-        ]);
+        const confirm = await runPrompt(confirmPrompt({
+            message: `Remove policy "${removed.name}"?`,
+            default: false,
+        }));
         if (!confirm) {
             console.log(chalk.dim('\nCancelled.\n'));
             return;
@@ -307,15 +298,11 @@ export async function addInstruction(text) {
                 'Pass the text directly: haystack policy add-instruction "Never flag weak test coverage"\n'));
             process.exit(1);
         }
-        const answers = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'instruction',
-                message: 'Review instruction:',
-                validate: (input) => input.trim() ? true : 'Instruction text is required',
-            },
-        ]);
-        instruction = answers.instruction.trim();
+        const answer = await runPrompt(input({
+            message: 'Review instruction:',
+            validate: (value) => value.trim() ? true : 'Instruction text is required',
+        }));
+        instruction = answer.trim();
     }
     instructions.push(instruction);
     // Ensure directory exists

package/dist/commands/precompute-delivery.js

@@ -3,6 +3,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { closeSync, constants, fchmodSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { validateCapturedSearch } from './combination-search-hook.js';
 const requestFile = 'request.json';
 const receiptFile = 'receipt.json';
 const deliverySchema = 'precompute-delivery-v1';
@@ -126,7 +127,7 @@ function validateRequest(value) {
     const request = value.request;
     const component = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.-';
     if (!onlyKeys(request, ['owner', 'repository', 'baseCommit', 'workCommit', 'observedAt',
-        'cacheKey', 'patchGzBase64', 'patchSha256'])
+        'cacheKey', 'patchGzBase64', 'patchSha256', ...(request.combinationSearch === undefined ? [] : ['combinationSearch'])])
         || !characters(request.owner, component) || request.owner.length > 100
         || !characters(request.repository, component) || request.repository.length > 100
         || !characters(request.baseCommit, '0123456789abcdef', 40)
@@ -141,6 +142,10 @@ function validateRequest(value) {
         || createHash('sha256').update(patch).digest('hex') !== request.patchSha256) {
         throw new Error('Captured patch identity does not match.');
     }
+    if (request.combinationSearch !== undefined)
+        validateCapturedSearch(request.combinationSearch, {
+            owner: request.owner, repository: request.repository, baseCommit: request.baseCommit, workCommit: request.workCommit,
+        });
 }
 export class PrecomputeDeliveryAccessError extends Error {
     delivery;

package/dist/commands/scaffold-provisional-universe.js

@@ -49,11 +49,11 @@ const UNSAFE_VALUE_PATTERNS = [
 function sanitizedStringSchema(schema, label) {
     return schema.superRefine((value, context) => {
         if (value.includes('\0')) {
-            context.addIssue({ code: z.ZodIssueCode.custom, message: `${label} must not contain NUL` });
+            context.addIssue({ code: 'custom', message: `${label} must not contain NUL` });
         }
         for (const [pattern, message] of UNSAFE_VALUE_PATTERNS) {
             if (pattern.test(value)) {
-                context.addIssue({ code: z.ZodIssueCode.custom, message: `${label}: ${message}` });
+                context.addIssue({ code: 'custom', message: `${label}: ${message}` });
             }
         }
     });
@@ -84,13 +84,13 @@ const repositoryPathSchema = safeStringSchema('repository path').superRefine((va
         normalize(value) !== value ||
         value.split('/').some((component) => component === '..' || component === '')) {
         context.addIssue({
-            code: z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'must be a normalized repository-relative POSIX path',
         });
     }
     if (value.split('/').includes('.haystack')) {
         context.addIssue({
-            code: z.ZodIssueCode.custom,
+            code: 'custom',
             message: 'must not reference generated .haystack artifacts',
         });
     }
@@ -120,7 +120,7 @@ const evidenceSourceSchema = z
     if (source.locatorKind === 'line-span') {
         if (!source.lines || source.lines.end < source.lines.start) {
             context.addIssue({
-                code: z.ZodIssueCode.custom,
+                code: 'custom',
                 path: ['lines'],
                 message: 'must contain positive start/end positions with end >= start for locatorKind line-span',
             });
@@ -128,7 +128,7 @@ const evidenceSourceSchema = z
     }
     else if (source.lines !== undefined) {
         context.addIssue({
-            code: z.ZodIssueCode.custom,
+            code: 'custom',
             path: ['lines'],
             message: 'is only valid for locatorKind line-span',
         });
@@ -149,7 +149,7 @@ const evidenceRecordSchema = z
 const budgetUsageSchema = z
     .object({
     repositoryInspectionCallsUsed: z.number().int().nonnegative(),
-    elapsedSeconds: z.number().finite().nonnegative(),
+    elapsedSeconds: z.number().nonnegative(),
 })
     .strict();
 const provisionalUniverseScaffoldInputSchema = z
@@ -160,9 +160,7 @@ const provisionalUniverseScaffoldInputSchema = z
         id: stableIdSchema,
         requestedScope: stableIdSchema,
         evaluationMode: z.literal('real-production', {
-            errorMap: () => ({
-                message: 'must be "real-production" because this scaffold records missing real-production authority',
-            }),
+            error: 'must be "real-production" because this scaffold records missing real-production authority',
         }),
     })
         .strict(),

package/dist/commands/setup.js

@@ -15,7 +15,8 @@ import chalk from 'chalk';
 import { execFileSync, execSync } from 'child_process';
 import { basename } from 'path';
 import { resolveAuthContext } from '../utils/auth.js';
-import { hooksInstall } from './hooks.js';
+import { githubRestBaseFor } from '../utils/github-api.js';
+import { describeHookOverwrites, hooksInstall } from './hooks.js';
 import { installSessionHooks } from './install-session-hooks.js';
 import { findGitRoot } from '../utils/hooks.js';
 import { trackError } from '../utils/telemetry.js';
@@ -61,10 +62,9 @@ function buildAnswerMap(options) {
 // Constants
 // =============================================================================
 const HAYSTACK_API = 'https://haystackeditor.com';
-// User-level GitHub calls (repo listing, App-installation check, token
-// verification) go direct: they're scoped to the authenticated user, so OAuth
-// App Policy org restrictions don't apply to them.
-const GITHUB_API = 'https://api.github.com';
+// The token verification call below uses githubRestBaseFor: direct to GitHub
+// for an OAuth token (user-scoped, so OAuth App Policy does not apply), the
+// Haystack proxy for an hsk_live token, which must never reach GitHub.
 // Per-repo reads + writes go through the auth-worker proxy, which swaps in the
 // GitHub App installation token server-side. That's what lets the config write
 // and the bootstrap PR succeed on orgs that restrict the OAuth app — the same
@@ -1041,7 +1041,7 @@ async function runSetupFlow(options) {
     }
     const token = authContext.token;
     // Verify token
-    const userResponse = await fetch(`${GITHUB_API}/user`, {
+    const userResponse = await fetch(`${githubRestBaseFor(token)}/user`, {
         headers: {
             Authorization: `Bearer ${token}`,
             'User-Agent': 'Haystack-CLI',
@@ -1073,7 +1073,7 @@ async function runSetupFlow(options) {
         return;
     }
     // Step 7: Offer Haystack's local quality hooks when setup runs in a selected repo.
-    await stepInstallHooks(selectedRepos);
+    await stepInstallHooks(selectedRepos, options.json === true);
     // Close the loop with ONE prominent CTA: the Haystack feed. The Configure
     // Haystack PR (and every PR after it) is reviewed and merged from the feed,
     // NOT the GitHub PR page, so the feed is the only link we surface. In JSON
@@ -1110,7 +1110,7 @@ async function runSetupFlow(options) {
 // =============================================================================
 // Step 7: Install Haystack git hooks
 // =============================================================================
-async function stepInstallHooks(selectedRepos) {
+async function stepInstallHooks(selectedRepos, json) {
     // Offer to install local git hooks if cwd is inside one of the selected repos
     const gitRoot = findGitRoot();
     if (gitRoot) {
@@ -1123,12 +1123,34 @@ async function stepInstallHooks(selectedRepos) {
             try {
                 const installHooks = await ui.confirm({
                     id: 'install_hooks',
-                    message: `Install local hooks for ${repoName}? (agent checks, session status, verification precompute)`,
+                    message: `Install local hooks for ${repoName}? (git hooks in hooks/ via core.hooksPath; Claude Code session and verification-precompute hooks in your .claude/settings.local.json)`,
                     default: true,
                 });
                 if (installHooks) {
                     console.log('');
-                    await hooksInstall({ force: true });
+                    const overwrites = await describeHookOverwrites(gitRoot);
+                    let installGitHooks = true;
+                    if (overwrites.length > 0) {
+                        console.log(chalk.yellow('  Installing Haystack hooks would:'));
+                        for (const change of overwrites)
+                            console.log(chalk.yellow(`    - ${change}`));
+                        if (json || !process.stdin.isTTY) {
+                            console.log('  Existing git hooks were left alone; to replace them, run `haystack hooks install --force` yourself.');
+                            installGitHooks = false;
+                        }
+                        else {
+                            installGitHooks = await ui.confirm({
+                                id: 'overwrite_hooks',
+                                message: 'Overwrite these existing hooks?',
+                                default: false,
+                            });
+                            if (!installGitHooks) {
+                                console.log(chalk.dim('  Existing git hooks were left alone. To replace them later: haystack hooks install --force'));
+                            }
+                        }
+                    }
+                    if (installGitHooks)
+                        await hooksInstall({ force: overwrites.length > 0 });
                     await installSessionHooks({ cli: 'claude' });
                 }
             }

package/dist/commands/submit.js

@@ -11,14 +11,14 @@
  */
 import chalk from 'chalk';
 import fs from 'fs';
-import { findGitRoot, getCurrentBranch, getDefaultBranch, hasUncommittedChanges, parseRemoteUrl, pushBranch, getLastCommitMessage, getCommitMessagesSinceBase, } from '../utils/git.js';
+import { findGitRoot, getCurrentBranch, getDefaultBranch, hasUncommittedChanges, parseRemoteUrl, pushBranch, getLastCommitMessage, getCommitMessagesSinceBase, HEADLESS_PUSH_ERROR, } from '../utils/git.js';
 import { createPullRequest, findExistingPR, getRepositoryAccess, requestReviewers, } from '../utils/github-api.js';
 import { runTriage } from '../triage/runner.js';
 import { loadConfig } from '../utils/config.js';
 import { checkAnalysisReady, fetchAnalysisResults } from '../utils/analysis-api.js';
 import { savePendingSubmit, updatePendingSubmit } from '../utils/pending-state.js';
 import { ensureHaystackLabels, addLabelsToIssue, } from '../utils/github-api.js';
-import { listStoredAccounts, resolveAuthContext, setRepoDefaultAccount, } from '../utils/auth.js';
+import { isHeadlessToken, listStoredAccounts, resolveAuthContext, setRepoDefaultAccount, } from '../utils/auth.js';
 import { HaystackApiError } from '../utils/haystack-api.js';
 import { withSchema } from '../schema.js';
 // ============================================================================
@@ -316,6 +316,11 @@ export async function submitCommand(options) {
     catch (err) {
         fail(err.message);
     }
+    // A headless (hsk_live_) token cannot authenticate a git push, and must not
+    // be sent to github.com as a password. Stop before triage and the push.
+    if (githubToken && isHeadlessToken(githubToken)) {
+        fail(HEADLESS_PUSH_ERROR);
+    }
     // Check for uncommitted changes
     if (hasUncommittedChanges()) {
         console.log(chalk.yellow('⚠ You have uncommitted changes. They will not be included in the PR.'));

package/dist/commands/telemetry.js

@@ -7,8 +7,20 @@ import chalk from 'chalk';
 import fg from 'fast-glob';
 // @babel/core intentionally has no bundled declarations. Keep this small
 // build-transform boundary dynamic instead of leaking `any` into CLI contracts.
+// It is loaded on first use, not at module top: loading it costs tens of
+// milliseconds, and only the instrument transforms below need it.
 const require = createRequire(import.meta.url);
-const babel = require('@babel/core');
+let babelModule;
+function loadBabel() {
+    babelModule ??= require('@babel/core');
+    return babelModule;
+}
+// @babel/core 8 is ESM-only. require() of ESM works from Node 22.12, but 22.12
+// prints an ExperimentalWarning for it, so the command path loads Babel with
+// import() first and loadBabel() then reuses that module.
+async function preloadBabel() {
+    babelModule ??= await import('@babel/core');
+}
 const INSTRUMENTED_MARKER = '__haystack_telemetry_instrumented_v1__';
 const INSTRUMENTED_MARKER_COMMENT = `/* ${INSTRUMENTED_MARKER} */`;
 const BOOTSTRAP_MARKER = '__haystack_telemetry_bootstrap_v1__';
@@ -486,6 +498,7 @@ function instrumentSource(code, sourcePath, runtimeSpecifier, moduleType, contro
             },
         };
     };
+    const babel = loadBabel();
     const transformed = babel.transformSync(code, {
         parserOpts: {
             sourceType: 'unambiguous',
@@ -541,7 +554,7 @@ function findNearestPackageType(start, stop) {
         current = dirname(current);
     }
 }
-function moduleTypeForOutput(output, dist) {
+function moduleTypeForOutput(output, _dist) {
     const extension = extname(output);
     if (extension === '.mjs')
         return 'module';
@@ -570,6 +583,7 @@ function bootstrapFor(entry, dist, buildId, runtimeHash, runtimeGuardChannel, ru
     return `/* ${BOOTSTRAP_MARKER} */ (() => { const processHost = require('node:process'); const define = (name, descriptor) => ({}).constructor.defineProperty(processHost, name, descriptor); const block = () => { try { if (!(${JSON.stringify(runtimeBlockedChannel)} in processHost)) define(${JSON.stringify(runtimeBlockedChannel)}, { configurable: false, enumerable: false, writable: false, value: true }); } catch (_ignored) {} }; try { if (${JSON.stringify(runtimeGuardChannel)} in processHost || ${JSON.stringify(runtimeBlockedChannel)} in processHost) { block(); return; } const runtimePath = require.resolve(${JSON.stringify(specifier)}); const source = require('node:fs').readFileSync(runtimePath, 'utf8'); if (require('node:crypto').createHash('sha256').update(source).digest('hex') !== ${JSON.stringify(runtimeHash)}) { block(); return; } const Module = require('node:module'); const loaded = new Module(runtimePath); loaded.filename = runtimePath; loaded.paths = Module._nodeModulePaths(require('node:path').dirname(runtimePath)); loaded._compile(source, runtimePath); loaded.loaded = true; const runtime = loaded.exports; if (!runtime || typeof runtime.install !== 'function' || typeof runtime.safeSelectProbe !== 'function') { block(); return; } define(${JSON.stringify(runtimeGuardChannel)}, { configurable: false, enumerable: false, writable: false, value: runtime }); require.cache[runtimePath] = loaded; runtime.install({ buildId: ${JSON.stringify(buildId)} }); } catch (_error) { block(); } })();\n`;
 }
 function insertEntryBootstrap(code, bootstrap) {
+    const babel = loadBabel();
     const bootstrapAst = babel.parseSync(bootstrap, {
         sourceType: 'unambiguous',
     });
@@ -814,6 +828,7 @@ export async function telemetryInstrumentCommand(distDirectory, options) {
         }
         includeSymbols = rows;
     }
+    await preloadBabel();
     const result = instrumentNodeTelemetryBuild(distDirectory, { ...options, includeSymbols });
     if (options.json) {
         console.log(JSON.stringify(result, null, 2));

package/dist/commands/triage.js

@@ -28,6 +28,7 @@ import { parsePrRef } from '../utils/pr-ref.js';
 import { toPublicVerdict } from '../states.js';
 import { withSchema } from '../schema.js';
 import { fetchGitHubJson } from '../utils/haystack-api.js';
+import { githubRestBaseFor } from '../utils/github-api.js';
 // ============================================================================
 // Output formatting
 // ============================================================================
@@ -562,7 +563,7 @@ function updatePendingSubmitIfExists(pr, status) {
  */
 async function recordFindingsSeen(pr, token, findingKeys) {
     // Get PR head SHA
-    const ghResp = await fetch(`https://api.github.com/repos/${pr.owner}/${pr.repo}/pulls/${pr.prNumber}`, {
+    const ghResp = await fetch(`${githubRestBaseFor(token)}/repos/${pr.owner}/${pr.repo}/pulls/${pr.prNumber}`, {
         headers: {
             Authorization: `Bearer ${token}`,
             Accept: 'application/vnd.github.v3+json',

package/dist/commands/verify-explore.js

@@ -12,6 +12,7 @@ function timestamp(value) {
     return typeof value === 'string' && Number.isFinite(Date.parse(value));
 }
 function terminalSafe(value) {
+    // eslint-disable-next-line no-control-regex -- rejecting/stripping control characters is the point
     return value.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, '');
 }
 async function context(runId, repository) {

package/dist/commands/verify-history.js

@@ -0,0 +1,152 @@
+import { resolveAuthContext } from '../utils/auth.js';
+import { haystackJson, HaystackApiError } from '../utils/haystack-api.js';
+const HEALTH = ['healthy', 'degraded', 'infrastructure-error', 'not-executed', 'unknown'];
+const LIFECYCLES = ['complete', 'failed', 'cancelled', 'budget-stopped', 'account-action'];
+const RUN_ID = /^cv_[0-9a-f]{48}$/;
+const COMMIT = /^[0-9a-f]{40}$/;
+const REPO_COMPONENT = /^(?!\.{1,2}$)[A-Za-z0-9_.-]{1,100}$/;
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function count(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function timestamp(value) {
+    return typeof value === 'string' && Number.isFinite(Date.parse(value));
+}
+/** Reject contradictory or mismatched data before printing health or findings. */
+export function parseVerifyHistoryReport(value, expected) {
+    const invalid = () => {
+        throw new Error('The hosted verifier returned invalid or mismatched history. No reliability summary was accepted.');
+    };
+    if (!record(value) || value.version !== 'dv-verify-history-v1'
+        || value.provider !== 'haystack' || value.scope !== 'user'
+        || !record(value.repository)
+        || typeof value.repository.owner !== 'string' || typeof value.repository.name !== 'string'
+        || value.repository.owner !== expected.owner
+        || value.repository.name !== expected.name
+        || typeof value.repository.repositoryId !== 'string'
+        || !/^github\.com:[1-9]\d*$/.test(value.repository.repositoryId)
+        || value.limit !== expected.limit || typeof value.hasMore !== 'boolean'
+        || !Array.isArray(value.runs) || value.runs.length > expected.limit
+        || (value.hasMore && value.runs.length !== expected.limit)
+        || !record(value.summary) || !record(value.summary.counts))
+        return invalid();
+    const counts = {
+        healthy: 0, degraded: 0, 'infrastructure-error': 0, 'not-executed': 0, unknown: 0,
+    };
+    const seen = new Set();
+    let usable = 0;
+    let previousCompletedAt = Infinity;
+    for (const run of value.runs) {
+        if (!record(run) || typeof run.runId !== 'string' || !RUN_ID.test(run.runId)
+            || seen.has(run.runId)
+            || typeof run.baseCommit !== 'string' || !COMMIT.test(run.baseCommit)
+            || typeof run.headCommit !== 'string' || !COMMIT.test(run.headCommit)
+            || !timestamp(run.createdAt) || !timestamp(run.completedAt)
+            || Date.parse(run.completedAt) < Date.parse(run.createdAt)
+            || Date.parse(run.completedAt) > previousCompletedAt
+            || (run.status !== 'complete' && run.status !== 'errored')
+            || (run.lifecycle !== null && !LIFECYCLES.includes(run.lifecycle))
+            || !HEALTH.includes(run.health)
+            || (run.regressionCount !== null && !count(run.regressionCount))
+            || (run.executedCaseCount !== null && !count(run.executedCaseCount))
+            || !Array.isArray(run.degradationCodes)
+            || run.degradationCodes.some(code => typeof code !== 'string' || code.length === 0)
+            || new Set(run.degradationCodes).size !== run.degradationCodes.length
+            || (run.supersededBy !== null && (typeof run.supersededBy !== 'string'
+                || !RUN_ID.test(run.supersededBy) || run.supersededBy === run.runId)))
+            return invalid();
+        if (run.health === 'unknown') {
+            if (run.status !== 'errored' || run.lifecycle !== null || run.regressionCount !== null
+                || run.executedCaseCount !== null || run.degradationCodes.length !== 0)
+                return invalid();
+        }
+        else if (run.lifecycle === null || run.regressionCount === null || run.executedCaseCount === null) {
+            return invalid();
+        }
+        else if ((run.lifecycle === 'complete') !== (run.status === 'complete')) {
+            return invalid();
+        }
+        if (run.health === 'healthy' && (run.lifecycle !== 'complete'
+            || run.executedCaseCount === 0 || run.degradationCodes.length !== 0))
+            return invalid();
+        if (run.health === 'not-executed' && (run.executedCaseCount !== 0 || run.regressionCount !== 0))
+            return invalid();
+        if (run.executedCaseCount === 0 && run.regressionCount !== null && run.regressionCount !== 0)
+            return invalid();
+        seen.add(run.runId);
+        previousCompletedAt = Date.parse(run.completedAt);
+        counts[run.health]++;
+        if ((run.health === 'healthy' || run.health === 'degraded')
+            && typeof run.executedCaseCount === 'number' && run.executedCaseCount > 0)
+            usable++;
+    }
+    const usableRate = value.runs.length === 0 ? null : usable / value.runs.length;
+    const summaryCounts = value.summary.counts;
+    if (value.summary.total !== value.runs.length || value.summary.usableRate !== usableRate
+        || HEALTH.some(health => summaryCounts[health] !== counts[health]))
+        return invalid();
+    return value;
+}
+function terminalSafe(value) {
+    return Array.from(value).filter(character => {
+        const point = character.codePointAt(0);
+        return point >= 32 && !(point >= 127 && point <= 159);
+    }).join('');
+}
+export function formatVerifyHistory(report) {
+    const { summary } = report;
+    const lines = [
+        `Your verification history for ${report.repository.owner}/${report.repository.name}`,
+        `Latest ${summary.total} finished runs for the selected account (limit ${report.limit}).`,
+    ];
+    if (summary.total === 0) {
+        lines.push('No finished hosted fleet runs found for this account and repository.');
+        return lines.join('\n');
+    }
+    const usable = report.runs.filter(run => (run.health === 'healthy' || run.health === 'degraded')
+        && run.executedCaseCount !== null && run.executedCaseCount > 0).length;
+    lines.push(`Usable evidence: ${Math.round(summary.usableRate * 100)}% of these runs (${usable}/${summary.total}).`, `Healthy: ${summary.counts.healthy}; partially degraded: ${summary.counts.degraded}; infrastructure error: ${summary.counts['infrastructure-error']}; not executed: ${summary.counts['not-executed']}; unknown: ${summary.counts.unknown}.`, 'Usable means healthy or partially degraded with at least one executed check.', 'This measures execution reliability. Bugs found are listed separately; they do not lower this rate.', '');
+    for (const run of report.runs) {
+        const health = run.health === 'degraded' ? 'partially degraded' : run.health;
+        const checks = run.executedCaseCount === null ? 'unknown checks executed' : `${run.executedCaseCount} checks executed`;
+        const regressions = run.regressionCount === null ? 'bugs found unknown'
+            : `${run.regressionCount} ${run.regressionCount === 1 ? 'bug' : 'bugs'} found`;
+        lines.push(`${terminalSafe(run.completedAt)}  ${health}  ${checks}  ${regressions}`, `  ${run.runId}  ${run.baseCommit.slice(0, 12)} -> ${run.headCommit.slice(0, 12)}`);
+        if (run.lifecycle && run.lifecycle !== 'complete')
+            lines.push(`  Run outcome: ${run.lifecycle}`);
+        if (run.degradationCodes.length)
+            lines.push(`  Limitations: ${run.degradationCodes.map(terminalSafe).join(', ')}`);
+        if (run.supersededBy)
+            lines.push(`  Replaced by: ${run.supersededBy}`);
+    }
+    if (report.hasMore)
+        lines.push('', 'Older finished runs exist. Increase --limit to show up to 100.');
+    return lines.join('\n');
+}
+export async function verifyHistoryCommand(repository, options) {
+    const parts = repository.split('/');
+    if (parts.length !== 2 || !parts.every(part => REPO_COMPONENT.test(part))) {
+        throw new Error('Use an exact GitHub owner/repository name for verification history.');
+    }
+    const limitText = options.limit ?? '20';
+    if (!/^[1-9]\d*$/.test(limitText) || Number(limitText) > 100) {
+        throw new Error('--limit must be a whole number from 1 to 100.');
+    }
+    const [owner, name] = parts;
+    const limit = Number(limitText);
+    const auth = await resolveAuthContext({ preferredLogin: options.account, owner, repo: name });
+    let response;
+    try {
+        response = await haystackJson(`/api/agent/cloud-verifier/history/${encodeURIComponent(owner)}/${encodeURIComponent(name)}?limit=${limit}`, auth.token, { method: 'GET' });
+    }
+    catch (error) {
+        if (error instanceof HaystackApiError && error.status === 404) {
+            throw new Error('Verification history was not found for this repository and account. Check repository access and use --account <login> if needed.');
+        }
+        throw error;
+    }
+    const report = parseVerifyHistoryReport(response, { owner, name, limit });
+    process.stdout.write((options.json ? JSON.stringify(report, null, 2) : formatVerifyHistory(report)) + '\n');
+}

package/dist/commands/verify-hosted-mcp.js

@@ -1,8 +1,5 @@
 // Production Cloud Verifier MCP server: `haystack verify hosted mcp`.
 //
-// This intentionally exposes only the durable hosted run lifecycle. The local
-// specimen MCP server has artifact and retained-sandbox tools whose data model
-// does not exist in the source-free production result contract.
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
@@ -58,13 +55,9 @@ export const HOSTED_VERIFY_TOOLS = [
                     pattern: '^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$',
                     description: 'Optional stable retry key. Omit to derive it from the exact repository and commits.',
                 },
-                replay_plan_from_run_id: {
-                    ...runIdInput,
-                    description: 'Optional completed owned run whose exact validated risk plan must be replayed.',
-                },
                 account: accountInput,
             },
-            required: ['repository', 'base_commit', 'head_commit', 'intent_file'],
+            required: ['repository', 'base_commit', 'head_commit'],
         },
     },
     {
@@ -130,7 +123,6 @@ function assertToolInputFields(name, input) {
             'head_commit',
             'idempotency_key',
             'intent_file',
-            'replay_plan_from_run_id',
             'repository',
         ]);
         return;
@@ -157,9 +149,8 @@ export async function executeHostedVerifyTool(name, input, context) {
         const started = await startHostedVerification(repository, {
             base: requireInputString(input, 'base_commit'),
             head: requireInputString(input, 'head_commit'),
-            intentFile: requireInputString(input, 'intent_file'),
+            intentFile: optionalInputString(input, 'intent_file'),
             idempotencyKey: optionalInputString(input, 'idempotency_key'),
-            replayPlanFrom: optionalInputString(input, 'replay_plan_from_run_id'),
             wait: false,
         }, context.token);
         return buildHostedJson('start', started.state, {
@@ -224,7 +215,7 @@ export async function runHostedVerifyMcpServer(options) {
             // Reject undeclared fields before account resolution so callers cannot
             // use an invalid request to trigger credential or repository lookup.
             assertToolInputFields(name, input);
-            if (name === 'verify_start') {
+            if (name === 'verify_start' && input.intent_file !== undefined) {
                 readHostedIntentFile(requireInputString(input, 'intent_file'));
             }
             const context = await resolveToolContext(name, input, options);