@haystackeditor/cli 0.15.19 → 0.15.21

package/dist/commands/mcp.js

@@ -6,11 +6,17 @@ import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { fetchInboxPayload } from './inbox.js';
 import { fetchPrStatePayload } from './pr.js';
-import { fetchTriagePayload } from './triage.js';
+import { fetchPrStatusPayload } from './pr-status.js';
+import { fetchTriagePayload, fetchTriageHeadSha } from './triage.js';
 import { fetchAskPayload } from './ask.js';
 import { fetchTracesGetPayload, fetchTracesListPayload } from './traces.js';
+import { performOverride, performUndismiss } from './dismiss.js';
+import { performRequestReview } from './request-review.js';
 import { loadToken } from '../utils/auth.js';
+import { triggerAnalysis } from '../utils/analysis-api.js';
+import { parsePrRef } from '../utils/pr-ref.js';
 import { SCHEMA_VERSIONS } from '../schema.js';
+import { withSchema } from '../schema.js';
 const refInput = {
     type: 'string',
     description: 'PR reference: bare number, owner/repo#number, or GitHub URL.',
@@ -63,6 +69,43 @@ const TOOLS = [
             required: ['ref', 'checkpoint_id'],
         },
     },
+    {
+        name: 'pr_status',
+        description: 'Get which Haystack feed bucket a PR is in (analyzing, good_to_merge, issues, needs_assignment, ...) and why.',
+        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
+    },
+    {
+        name: 'dismiss',
+        description: 'Dismiss analysis findings for a PR (moves it toward "Good to Merge"). Tied to the current head commit; a new commit invalidates it.',
+        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
+    },
+    {
+        name: 'mark_reviewed',
+        description: 'Mark human review as not needed for a PR (moves it toward "Good to Merge"). Tied to the current head commit.',
+        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
+    },
+    {
+        name: 'undismiss',
+        description: 'Undo dismiss/mark-reviewed overrides for a PR, returning it to its original feed bucket.',
+        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
+    },
+    {
+        name: 'request_review',
+        description: 'Tag a PR as needing HUMAN review (adds haystack:needs-review), optionally requesting a specific GitHub user.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: refInput,
+                reviewer: { type: 'string', description: 'Optional GitHub username to request review from.' },
+            },
+            required: ['ref'],
+        },
+    },
+    {
+        name: 'trigger_review',
+        description: 'Trigger a fresh Haystack MACHINE analysis of a PR\'s current head (equivalent to `haystack review`). Returns immediately; poll triage_get for results.',
+        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
+    },
     {
         name: 'schema',
         description: 'Return the committed JSON Schema for a Haystack machine response.',
@@ -123,6 +166,58 @@ export async function runMcpServer() {
                     limit: typeof input.limit === 'number' ? String(input.limit) : undefined,
                 }));
             }
+            if (name === 'pr_status') {
+                if (typeof input.ref !== 'string')
+                    return fail('ref required');
+                return ok(await fetchPrStatusPayload(input.ref));
+            }
+            if (name === 'dismiss' || name === 'mark_reviewed') {
+                if (typeof input.ref !== 'string')
+                    return fail('ref required');
+                return ok(withSchema('action', await performOverride(input.ref, name === 'dismiss' ? 'findings-dismissed' : 'review-not-needed', name === 'dismiss' ? 'dismiss' : 'mark-reviewed')));
+            }
+            if (name === 'undismiss') {
+                if (typeof input.ref !== 'string')
+                    return fail('ref required');
+                return ok(withSchema('action', await performUndismiss(input.ref)));
+            }
+            if (name === 'request_review') {
+                if (typeof input.ref !== 'string')
+                    return fail('ref required');
+                return ok(withSchema('action', await performRequestReview(input.ref, typeof input.reviewer === 'string' ? input.reviewer : undefined)));
+            }
+            if (name === 'trigger_review') {
+                if (typeof input.ref !== 'string')
+                    return fail('ref required');
+                const pr = parsePrRef(input.ref, 'review');
+                const token = await loadToken({ owner: pr.owner, repo: pr.repo });
+                if (!token)
+                    return fail('Not authenticated. Run `haystack login` first.');
+                const ref = `${pr.owner}/${pr.repo}#${pr.prNumber}`;
+                // Resolve the current head so ingestion's dedup compares commits — an
+                // in-flight run for an OLDER head must be superseded, not reused
+                // (same degradation as `haystack review`: continue head-less on failure).
+                let headSha;
+                try {
+                    headSha = await fetchTriageHeadSha(pr, token) ?? undefined;
+                }
+                catch {
+                    headSha = undefined;
+                }
+                const trigger = await triggerAnalysis(pr.owner, pr.repo, pr.prNumber, token, headSha);
+                if (trigger.status !== 'started' && trigger.status !== 'already_processing') {
+                    return fail(trigger.message);
+                }
+                return ok(withSchema('action', {
+                    action: 'trigger_review',
+                    status: 'ok',
+                    ref,
+                    detail: 'Analysis triggered; poll triage_get for results.',
+                    request_id: trigger.requestId,
+                    run_status: trigger.status,
+                    next: null,
+                }));
+            }
             if (name === 'schema') {
                 const schema = input.name;
                 if (!(schema in SCHEMA_VERSIONS))

package/dist/commands/policy.js

@@ -167,6 +167,14 @@ export async function addPolicy(nameArg) {
         policies = parsed.policies;
         instructions = parsed.instructions;
     }
+    // Interactive-only command: without a TTY the inquirer prompt would hang a
+    // non-interactive caller (e.g. a coding agent) forever.
+    if (!process.stdin.isTTY) {
+        console.error(chalk.red('\n`haystack policy add` is interactive and requires a terminal.\n' +
+            `Non-interactive alternative: edit ${POLICY_PATH} directly ` +
+            '(run `haystack policy list` to see the current policies and format).\n'));
+        process.exit(1);
+    }
     console.log(chalk.cyan('\n➕ Add Review Policy\n'));
     // Prompt for policy details
     const answers = await inquirer.prompt([
@@ -253,18 +261,24 @@ export async function removePolicy(name) {
         return;
     }
     const removed = policies[index];
-    // Confirm removal
-    const { confirm } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'confirm',
-            message: `Remove policy "${removed.name}"?`,
-            default: false,
-        },
-    ]);
-    if (!confirm) {
-        console.log(chalk.dim('\nCancelled.\n'));
-        return;
+    // 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,
+            },
+        ]);
+        if (!confirm) {
+            console.log(chalk.dim('\nCancelled.\n'));
+            return;
+        }
+    }
+    else {
+        console.error(chalk.dim(`No TTY — removing "${removed.name}" without interactive confirmation.`));
     }
     // Remove and write
     policies = policies.filter((_, i) => i !== index);
@@ -288,6 +302,11 @@ export async function addInstruction(text) {
     }
     let instruction = text?.trim();
     if (!instruction) {
+        if (!process.stdin.isTTY) {
+            console.error(chalk.red('\nNo instruction text given and no terminal to prompt in.\n' +
+                'Pass the text directly: haystack policy add-instruction "Never flag weak test coverage"\n'));
+            process.exit(1);
+        }
         const answers = await inquirer.prompt([
             {
                 type: 'input',

package/dist/commands/pr-status.d.ts

@@ -2,20 +2,143 @@
  * pr-status command — Show the current Haystack status of a PR.
  *
  * Calls the classify-debug endpoint to determine which inbox bucket the PR
- * is in (analyzing, auto-fixing, good-to-merge, issues, needs-assignment, etc.)
- * and displays a human-readable summary.
+ * is in (analyzing, auto_fixing, good_to_merge, issues, needs_assignment,
+ * etc.) and displays a human-readable summary.
+ *
+ * `--json` emits the versioned `pr-status` schema (see `haystack schema
+ * pr-status`), with all state tokens normalized to the canonical snake_case
+ * vocabulary shared by every CLI JSON surface. The server's raw kebab-case
+ * classify-debug response is an internal shape and is not exposed.
  *
  * Accepts a PR identifier in several formats:
  *   123                                    # Uses current repo's owner/repo
+ *   #123                                   # PR number with hash
  *   owner/repo#123                         # Fully qualified
  *   https://github.com/owner/repo/pull/123 # GitHub URL
  */
+import { type ParsedPR } from '../utils/pr-ref.js';
+import { type TriageVerdict } from '../states.js';
 export interface PRStatusOptions {
     json?: boolean;
 }
+interface ClassifyResponse {
+    prId: string;
+    bucket: string | null;
+    feedPriority: number | null;
+    isInFeed: boolean;
+    reason: string;
+    inputs: {
+        isOpen: boolean;
+        isAuthor: boolean;
+        author: string;
+        currentUsername: string;
+        category: string;
+        analysisStatus: string;
+        analysisVerdict?: string;
+        haystackRating?: number;
+        needsHumanReview?: boolean;
+        hasReviewer: boolean;
+        reviewDecision?: string;
+        snoozed: boolean;
+        dismissed: boolean;
+        dismissedAgentAlerts: boolean;
+        dismissedNeedsAssignment: boolean;
+        manuallyGoodToMerge: boolean;
+        hasNeedsReviewLabel: boolean;
+        hasFixingLabel: boolean;
+        hasNeedsShepherdingLabel: boolean;
+        labels: string[];
+    };
+    stateSyncedAt?: string;
+    staleWarning?: string;
+}
+export interface PrStatusPayload extends Record<string, unknown> {
+    ref: string;
+    bucket: string | null;
+    in_feed: boolean | null;
+    feed_priority: number | null;
+    reason: string;
+    analysis: {
+        status: string;
+        verdict: TriageVerdict | null;
+        rating: number | null;
+    };
+    needs_human_review: boolean | null;
+    labels: string[];
+    overrides: {
+        snoozed: boolean;
+        dismissed: boolean;
+        dismissed_agent_alerts: boolean;
+        dismissed_needs_assignment: boolean;
+        manually_good_to_merge: boolean;
+    };
+    author: string | null;
+    is_author: boolean | null;
+    is_open: boolean | null;
+    state_synced_at: string | null;
+    stale_warning: string | null;
+}
+export declare function buildPrStatusPayload(pr: ParsedPR, data: ClassifyResponse): {
+    ref: string;
+    bucket: string | null;
+    in_feed: boolean;
+    feed_priority: number | null;
+    reason: string;
+    analysis: {
+        status: string;
+        verdict: "good_to_merge" | "needs_review" | "needs_input" | null;
+        rating: number | null;
+    };
+    needs_human_review: boolean | null;
+    labels: string[];
+    overrides: {
+        snoozed: boolean;
+        dismissed: boolean;
+        dismissed_agent_alerts: boolean;
+        dismissed_needs_assignment: boolean;
+        manually_good_to_merge: boolean;
+    };
+    author: string;
+    is_author: boolean;
+    is_open: boolean;
+    state_synced_at: string | null;
+    stale_warning: string | null;
+} & {
+    schema_version: string;
+};
 export declare const BUCKET_DISPLAY: Record<string, {
     label: string;
     color: (s: string) => string;
     icon: string;
 }>;
+/** Pure read path (also used by MCP): returns the versioned payload without writing stdout. */
+export declare function fetchPrStatusPayload(identifier: string): Promise<{
+    ref: string;
+    bucket: string | null;
+    in_feed: boolean;
+    feed_priority: number | null;
+    reason: string;
+    analysis: {
+        status: string;
+        verdict: "good_to_merge" | "needs_review" | "needs_input" | null;
+        rating: number | null;
+    };
+    needs_human_review: boolean | null;
+    labels: string[];
+    overrides: {
+        snoozed: boolean;
+        dismissed: boolean;
+        dismissed_agent_alerts: boolean;
+        dismissed_needs_assignment: boolean;
+        manually_good_to_merge: boolean;
+    };
+    author: string;
+    is_author: boolean;
+    is_open: boolean;
+    state_synced_at: string | null;
+    stale_warning: string | null;
+} & {
+    schema_version: string;
+}>;
 export declare function prStatusCommand(identifier: string, options: PRStatusOptions): Promise<void>;
+export {};

package/dist/commands/pr-status.js

@@ -2,61 +2,75 @@
  * pr-status command — Show the current Haystack status of a PR.
  *
  * Calls the classify-debug endpoint to determine which inbox bucket the PR
- * is in (analyzing, auto-fixing, good-to-merge, issues, needs-assignment, etc.)
- * and displays a human-readable summary.
+ * is in (analyzing, auto_fixing, good_to_merge, issues, needs_assignment,
+ * etc.) and displays a human-readable summary.
+ *
+ * `--json` emits the versioned `pr-status` schema (see `haystack schema
+ * pr-status`), with all state tokens normalized to the canonical snake_case
+ * vocabulary shared by every CLI JSON surface. The server's raw kebab-case
+ * classify-debug response is an internal shape and is not exposed.
  *
  * Accepts a PR identifier in several formats:
  *   123                                    # Uses current repo's owner/repo
+ *   #123                                   # PR number with hash
  *   owner/repo#123                         # Fully qualified
  *   https://github.com/owner/repo/pull/123 # GitHub URL
  */
 import chalk from 'chalk';
 import { resolveAuthContext } from '../utils/auth.js';
-import { parseRemoteUrl } from '../utils/git.js';
-// ============================================================================
-// PR identifier parsing
-// ============================================================================
-function parsePRIdentifier(identifier) {
-    const urlMatch = identifier.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/);
-    if (urlMatch) {
-        return { owner: urlMatch[1], repo: urlMatch[2], prNumber: parseInt(urlMatch[3], 10) };
-    }
-    const qualifiedMatch = identifier.match(/^([^/]+)\/([^#]+)#(\d+)$/);
-    if (qualifiedMatch) {
-        return { owner: qualifiedMatch[1], repo: qualifiedMatch[2], prNumber: parseInt(qualifiedMatch[3], 10) };
-    }
-    const numberMatch = identifier.match(/^#?(\d+)$/);
-    if (numberMatch) {
-        const prNumber = parseInt(numberMatch[1], 10);
-        try {
-            const remote = parseRemoteUrl('origin');
-            return { owner: remote.owner, repo: remote.repo, prNumber };
-        }
-        catch {
-            throw new Error(`Cannot determine repository for PR #${prNumber}.\n` +
-                `Use the full format: haystack pr-status owner/repo#${prNumber}`);
-        }
-    }
-    throw new Error(`Invalid PR identifier: "${identifier}"\n\n` +
-        `Accepted formats:\n` +
-        `  haystack pr-status 123\n` +
-        `  haystack pr-status owner/repo#123\n` +
-        `  haystack pr-status https://github.com/owner/repo/pull/123`);
+import { classifyHttpError } from '../utils/haystack-api.js';
+import { parsePrRef } from '../utils/pr-ref.js';
+import { normalizeFeedBucket, toPublicVerdict } from '../states.js';
+import { withSchema } from '../schema.js';
+export function buildPrStatusPayload(pr, data) {
+    const inputs = data.inputs ?? {};
+    return withSchema('pr-status', {
+        ref: `${pr.owner}/${pr.repo}#${pr.prNumber}`,
+        bucket: normalizeFeedBucket(data.bucket),
+        in_feed: data.isInFeed ?? null,
+        feed_priority: data.feedPriority ?? null,
+        reason: data.reason,
+        analysis: {
+            status: inputs.analysisStatus ?? 'pending',
+            // Verdict only exists once analysis is ready; no rating-based guessing here.
+            verdict: inputs.analysisVerdict
+                ? toPublicVerdict(inputs.analysisVerdict, inputs.haystackRating)
+                : null,
+            rating: inputs.haystackRating ?? null,
+        },
+        needs_human_review: inputs.needsHumanReview ?? null,
+        labels: inputs.labels ?? [],
+        overrides: {
+            snoozed: inputs.snoozed ?? false,
+            dismissed: inputs.dismissed ?? false,
+            dismissed_agent_alerts: inputs.dismissedAgentAlerts ?? false,
+            dismissed_needs_assignment: inputs.dismissedNeedsAssignment ?? false,
+            manually_good_to_merge: inputs.manuallyGoodToMerge ?? false,
+        },
+        // The classify endpoint can return 200 with missing PR metadata (its own
+        // GitHub fetch failed) — coalesce to null so required fields never vanish
+        // from the serialized payload (undefined keys are dropped by JSON.stringify).
+        author: inputs.author ?? null,
+        is_author: inputs.isAuthor ?? null,
+        is_open: inputs.isOpen ?? null,
+        state_synced_at: data.stateSyncedAt ?? null,
+        stale_warning: data.staleWarning ?? null,
+    });
 }
 // ============================================================================
 // Display helpers
 // ============================================================================
 export const BUCKET_DISPLAY = {
     'analyzing': { label: 'Analyzing', color: chalk.blue, icon: '...' },
-    'auto-fixing': { label: 'Auto-fixing (alpha)', color: chalk.blue, icon: '>>>' },
-    'good-to-merge': { label: 'Good to Merge', color: chalk.green, icon: '[+]' },
-    'failed-when-merging': { label: 'Failed When Merging', color: chalk.red, icon: '[!]' },
+    'auto_fixing': { label: 'Auto-fixing (alpha)', color: chalk.blue, icon: '>>>' },
+    'good_to_merge': { label: 'Good to Merge', color: chalk.green, icon: '[+]' },
+    'failed_when_merging': { label: 'Failed When Merging', color: chalk.red, icon: '[!]' },
     'issues': { label: 'Issues Found', color: chalk.yellow, icon: '[?]' },
-    'needs-assignment': { label: 'Needs Reviewer Assignment', color: chalk.yellow, icon: '[?]' },
-    'needs-shepherding': { label: 'Needs Manual Merge', color: chalk.yellow, icon: '[!]' },
-    'needs-fixing': { label: 'Agent Fixing CI', color: chalk.blue, icon: '>>>' },
-    'awaiting-review': { label: 'Awaiting Review', color: chalk.cyan, icon: '[-]' },
-    'review-requested': { label: 'Review Requested', color: chalk.cyan, icon: '[-]' },
+    'needs_assignment': { label: 'Needs Reviewer Assignment', color: chalk.yellow, icon: '[?]' },
+    'needs_shepherding': { label: 'Needs Manual Merge', color: chalk.yellow, icon: '[!]' },
+    'needs_fixing': { label: 'Agent Fixing CI', color: chalk.blue, icon: '>>>' },
+    'awaiting_review': { label: 'Awaiting Review', color: chalk.cyan, icon: '[-]' },
+    'review_requested': { label: 'Review Requested', color: chalk.cyan, icon: '[-]' },
     'snoozed': { label: 'Snoozed', color: chalk.dim, icon: '[-]' },
 };
 function formatBucket(bucket) {
@@ -78,10 +92,10 @@ function formatAnalysisStatus(status) {
 }
 function formatVerdict(verdict) {
     switch (verdict) {
-        case 'clean': return chalk.green('Clean');
-        case 'has-issues': return chalk.yellow('Has issues');
-        case 'needs-review': return chalk.cyan('Needs review');
-        default: return chalk.dim(verdict ?? 'n/a');
+        case 'good_to_merge': return chalk.green('Good to merge');
+        case 'needs_input': return chalk.yellow('Needs input');
+        case 'needs_review': return chalk.cyan('Needs review');
+        default: return chalk.dim('n/a');
     }
 }
 // ============================================================================
@@ -97,24 +111,24 @@ async function fetchClassification(owner, repo, prNumber, token) {
         },
     });
     if (!response.ok) {
-        if (response.status === 401) {
-            throw new Error('Authentication failed. Run `haystack login` to re-authenticate.');
-        }
-        if (response.status === 403) {
-            throw new Error('Access denied — you may not have permission to this repository.');
-        }
-        const body = await response.text().catch(() => '');
-        throw new Error(`API error (${response.status}): ${body}`);
+        throw await classifyHttpError(response, `PR status for ${prId}`);
     }
     return response.json();
 }
+/** Pure read path (also used by MCP): returns the versioned payload without writing stdout. */
+export async function fetchPrStatusPayload(identifier) {
+    const pr = parsePrRef(identifier, 'pr-status');
+    const authContext = await resolveAuthContext({ owner: pr.owner, repo: pr.repo });
+    const data = await fetchClassification(pr.owner, pr.repo, pr.prNumber, authContext.token);
+    return buildPrStatusPayload(pr, data);
+}
 // ============================================================================
 // Command
 // ============================================================================
 export async function prStatusCommand(identifier, options) {
     let pr;
     try {
-        pr = parsePRIdentifier(identifier);
+        pr = parsePrRef(identifier, 'pr-status');
     }
     catch (err) {
         console.error(chalk.red(`\n${err.message}\n`));
@@ -141,52 +155,53 @@ export async function prStatusCommand(identifier, options) {
         console.error(chalk.red(`\n${err.message}\n`));
         process.exit(1);
     }
+    const payload = buildPrStatusPayload(pr, data);
     // JSON mode — pure JSON to stdout, nothing else
     if (options.json) {
-        console.log(JSON.stringify(data, null, 2));
+        console.log(JSON.stringify(payload, null, 2));
         return;
     }
     // Human-readable output
-    console.log(`  ${chalk.bold('PR')}:        ${data.prId}`);
-    console.log(`  ${chalk.bold('Status')}:    ${formatBucket(data.bucket)}`);
-    console.log(`  ${chalk.bold('Analysis')}:  ${formatAnalysisStatus(data.inputs.analysisStatus)}`);
-    if (data.inputs.analysisVerdict) {
-        console.log(`  ${chalk.bold('Verdict')}:   ${formatVerdict(data.inputs.analysisVerdict)}`);
+    console.log(`  ${chalk.bold('PR')}:        ${payload.ref}`);
+    console.log(`  ${chalk.bold('Status')}:    ${formatBucket(payload.bucket)}`);
+    console.log(`  ${chalk.bold('Analysis')}:  ${formatAnalysisStatus(payload.analysis.status)}`);
+    if (payload.analysis.verdict) {
+        console.log(`  ${chalk.bold('Verdict')}:   ${formatVerdict(payload.analysis.verdict)}`);
     }
-    if (data.inputs.haystackRating != null) {
-        console.log(`  ${chalk.bold('Rating')}:    ${data.inputs.haystackRating}/5`);
+    if (payload.analysis.rating != null) {
+        console.log(`  ${chalk.bold('Rating')}:    ${payload.analysis.rating}/5`);
     }
-    console.log(`  ${chalk.bold('Reason')}:    ${chalk.dim(data.reason)}`);
+    console.log(`  ${chalk.bold('Reason')}:    ${chalk.dim(payload.reason)}`);
     // Extra context
-    if (!data.inputs.isOpen) {
+    if (!payload.is_open) {
         console.log(chalk.dim(`\n  PR is closed or merged.`));
     }
-    if (!data.inputs.isAuthor) {
-        console.log(chalk.dim(`\n  You are not the author (author: ${data.inputs.author}).`));
+    if (!payload.is_author) {
+        console.log(chalk.dim(`\n  You are not the author (author: ${payload.author}).`));
     }
     // Labels of interest
-    const haystackLabels = (data.inputs.labels || []).filter(l => l.startsWith('haystack:'));
+    const haystackLabels = payload.labels.filter(l => l.startsWith('haystack:'));
     if (haystackLabels.length > 0) {
         console.log(`  ${chalk.bold('Labels')}:    ${haystackLabels.join(', ')}`);
     }
     // User overrides
     const overrides = [];
-    if (data.inputs.dismissed)
+    if (payload.overrides.dismissed)
         overrides.push('dismissed');
-    if (data.inputs.dismissedAgentAlerts)
+    if (payload.overrides.dismissed_agent_alerts)
         overrides.push('agent alerts dismissed');
-    if (data.inputs.dismissedNeedsAssignment)
+    if (payload.overrides.dismissed_needs_assignment)
         overrides.push('needs-assignment dismissed');
-    if (data.inputs.manuallyGoodToMerge)
+    if (payload.overrides.manually_good_to_merge)
         overrides.push('manually marked good-to-merge');
-    if (data.inputs.snoozed)
+    if (payload.overrides.snoozed)
         overrides.push('snoozed');
     if (overrides.length > 0) {
         console.log(`  ${chalk.bold('Overrides')}: ${overrides.join(', ')}`);
     }
     // Stale warning
-    if (data.staleWarning) {
-        console.log(chalk.yellow(`\n  Warning: ${data.staleWarning}`));
+    if (payload.stale_warning) {
+        console.log(chalk.yellow(`\n  Warning: ${payload.stale_warning}`));
     }
     console.log('');
 }

package/dist/commands/pr.d.ts

@@ -1,9 +1,4 @@
-export interface ParsedPR {
-    owner: string;
-    repo: string;
-    prNumber: number;
-}
-export declare function parsePrRef(ref: string): ParsedPR;
+export type { ParsedPR } from '../utils/pr-ref.js';
 interface GitHubPr {
     number: number;
     title: string;
@@ -43,4 +38,3 @@ export declare function fetchPrStatePayload(ref: string): Promise<Record<string,
     schema_version: string;
 }>;
 export declare function prReadCommand(ref: string, options: PrReadOptions): Promise<void>;
-export {};

package/dist/commands/pr.js

@@ -1,23 +1,10 @@
 import chalk from 'chalk';
 import { loadToken } from '../utils/auth.js';
 import { fetchAutoFixManifest, fetchRatingSynthesis } from '../utils/analysis-api.js';
-import { parseRemoteUrl } from '../utils/git.js';
-import { fetchAnalysisArtifact, fetchGitHubJson, haystackJson } from '../utils/haystack-api.js';
+import { fetchAnalysisArtifact, fetchGitHubJson, haystackJson, HaystackApiError } from '../utils/haystack-api.js';
+import { parsePrRef } from '../utils/pr-ref.js';
+import { toPublicVerdict } from '../states.js';
 import { withSchema } from '../schema.js';
-export function parsePrRef(ref) {
-    const urlMatch = ref.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/);
-    if (urlMatch)
-        return { owner: urlMatch[1], repo: urlMatch[2], prNumber: Number.parseInt(urlMatch[3], 10) };
-    const qualifiedMatch = ref.match(/^([^/]+)\/([^#]+)#(\d+)$/);
-    if (qualifiedMatch)
-        return { owner: qualifiedMatch[1], repo: qualifiedMatch[2], prNumber: Number.parseInt(qualifiedMatch[3], 10) };
-    const bare = ref.match(/^#?(\d+)$/);
-    if (bare) {
-        const remote = parseRemoteUrl('origin');
-        return { owner: remote.owner, repo: remote.repo, prNumber: Number.parseInt(bare[1], 10) };
-    }
-    throw new Error(`Invalid PR reference: "${ref}". Use 123, owner/repo#123, or a GitHub URL.`);
-}
 export function mergePublicState(meta, entry, queueAvailable = true) {
     if (meta.merged) {
         return { status: 'merged', reason: 'The PR has merged.', blocking_checks: [], action: null };
@@ -58,12 +45,16 @@ export async function fetchMergePublicState(meta, prNumber, owner, repo, token)
         const mergeQueue = await haystackJson(`/api/merge-queue/status?repo=${encodeURIComponent(`${owner}/${repo}`)}&branch=${encodeURIComponent(meta.base.ref)}`, token);
         return mergePublicState(meta, mergeQueue.prStatuses?.[String(prNumber)]);
     }
-    catch {
+    catch (err) {
+        // Auth failures are actionable, not transient — surface them instead of
+        // reporting "temporarily unavailable, retry".
+        if (err instanceof HaystackApiError && err.isAuthError)
+            throw err;
         return mergePublicState(meta, undefined, false);
     }
 }
 export async function fetchPrStatePayload(ref) {
-    const pr = parsePrRef(ref);
+    const pr = parsePrRef(ref, 'pr get');
     const token = await loadToken({ owner: pr.owner, repo: pr.repo });
     if (!token)
         throw new Error('Not authenticated. Run `haystack login` first.');
@@ -74,8 +65,6 @@ export async function fetchPrStatePayload(ref) {
         fetchAnalysisArtifact(pr.owner, pr.repo, pr.prNumber, 'entire_traces.json', token),
         fetchMergePublicState(meta, pr.prNumber, pr.owner, pr.repo, token),
     ]);
-    const verdict = synthesis?.analysisVerdict
-        ?? (synthesis ? (synthesis.haystackRating >= 5 ? 'clean' : 'has-issues') : null);
     const payload = {
         ref: `${pr.owner}/${pr.repo}#${pr.prNumber}`,
         title: meta.title,
@@ -83,7 +72,7 @@ export async function fetchPrStatePayload(ref) {
         triage: synthesis
             ? {
                 status: 'complete',
-                verdict: verdict === 'clean' ? 'good_to_merge' : verdict === 'needs-review' ? 'needs_review' : 'needs_input',
+                verdict: toPublicVerdict(synthesis.analysisVerdict, synthesis.haystackRating),
                 findings_count: synthesis.synthesisDisplay?.length ?? 0,
             }
             : { status: 'pending', verdict: null, findings_count: 0 },