@haystackeditor/cli 0.15.16 → 0.15.18

package/dist/commands/pr.js

@@ -1,103 +1,121 @@
-/**
- * PR-reference helpers shared by the MCP server's `pr_state` tool.
- *
- * No top-level `haystack pr` CLI command — the original `pr <ref>` /
- * `pr <ref> merge|snooze|dismiss` surface was scope creep on the
- * CLI-as-platform spec. Use the pre-existing `haystack pr-status <pr>`
- * for the same read.
- *
- * Output shape is stamped with `schema_version` per `schemas/pr.v1.json`.
- */
 import chalk from 'chalk';
 import { loadToken } from '../utils/auth.js';
-import { fetchRatingSynthesis } from '../utils/analysis-api.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 { withSchema } from '../schema.js';
-const GITHUB_PROXY = process.env.HAYSTACK_API_BASE ?? 'https://haystackeditor.com';
 export function parsePrRef(ref) {
     const urlMatch = ref.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/);
     if (urlMatch)
-        return { owner: urlMatch[1], repo: urlMatch[2], prNumber: parseInt(urlMatch[3], 10) };
+        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: parseInt(qualifiedMatch[3], 10) };
+        return { owner: qualifiedMatch[1], repo: qualifiedMatch[2], prNumber: Number.parseInt(qualifiedMatch[3], 10) };
     const bare = ref.match(/^#?(\d+)$/);
     if (bare) {
-        const r = parseRemoteUrl('origin');
-        return { owner: r.owner, repo: r.repo, prNumber: parseInt(bare[1], 10) };
+        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.`);
 }
-async function ghPr(token, owner, repo, num) {
-    const url = `${GITHUB_PROXY}/api/github/repos/${owner}/${repo}/pulls/${num}`;
-    const res = await fetch(url, {
-        headers: {
-            Accept: 'application/vnd.github+json',
-            Authorization: `Bearer ${token}`,
-            'User-Agent': 'Haystack-CLI',
-        },
-    });
-    if (!res.ok) {
-        throw new Error(`GitHub API ${res.status}: ${(await res.text()).slice(0, 200)}`);
+export function mergePublicState(meta, entry, queueAvailable = true) {
+    if (meta.merged) {
+        return { status: 'merged', reason: 'The PR has merged.', blocking_checks: [], action: null };
+    }
+    if (meta.state === 'closed') {
+        return { status: 'closed', reason: 'The PR was closed without merging.', blocking_checks: [], action: null };
+    }
+    if (!queueAvailable) {
+        return {
+            status: 'unavailable',
+            reason: 'Haystack merge status is temporarily unavailable.',
+            blocking_checks: [],
+            action: 'Retry this request before making a merge decision.',
+        };
+    }
+    if (!entry) {
+        return {
+            status: 'not_applicable',
+            reason: 'The PR is not currently in Haystack merge processing.',
+            blocking_checks: [],
+            action: null,
+        };
     }
-    return res.json();
+    const failed = entry.failedChecks ?? [];
+    const blocked = failed.length > 0
+        || entry.status === 'failed'
+        || entry.status === 'needs_shepherding'
+        || entry.status === 'awaiting_human_approval';
+    return {
+        status: blocked ? 'blocked' : 'processing',
+        reason: blocked ? 'The PR has merge blockers.' : 'Haystack is processing the PR.',
+        blocking_checks: failed,
+        action: blocked ? 'Resolve the merge blockers.' : null,
+    };
 }
-export async function prReadCommand(ref, opts) {
-    const pr = parsePrRef(ref);
-    const token = await loadToken();
-    if (!token) {
-        console.error(chalk.red('Not authenticated. Run `haystack login` first.'));
-        process.exit(1);
+export async function fetchMergePublicState(meta, prNumber, owner, repo, token) {
+    try {
+        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)]);
     }
-    const [meta, synthesis] = await Promise.all([
-        ghPr(token, pr.owner, pr.repo, pr.prNumber),
-        // 404 → null is the "not analyzed yet" signal; we still log unexpected
-        // failures so they don't look the same as "not analyzed".
-        fetchRatingSynthesis(pr.owner, pr.repo, pr.prNumber, token).catch((err) => {
-            console.error(chalk.dim(`[pr] rating fetch failed: ${err instanceof Error ? err.message : String(err)}`));
-            return null;
-        }),
-    ]);
-    let bucket = 'analyzing';
-    if (meta.merged)
-        bucket = 'merged';
-    else if (meta.state === 'closed')
-        bucket = 'merged';
-    else if (synthesis?.haystackRating != null) {
-        bucket = synthesis.haystackRating <= 2
-            ? 'issues'
-            : synthesis.haystackRating === 5
-                ? 'good-to-merge'
-                : 'needs-attention';
+    catch {
+        return mergePublicState(meta, undefined, false);
     }
+}
+export async function fetchPrStatePayload(ref) {
+    const pr = parsePrRef(ref);
+    const token = await loadToken({ owner: pr.owner, repo: pr.repo });
+    if (!token)
+        throw new Error('Not authenticated. Run `haystack login` first.');
+    const meta = await fetchGitHubJson(`/repos/${pr.owner}/${pr.repo}/pulls/${pr.prNumber}`, token);
+    const [synthesis, manifest, traces, merge] = await Promise.all([
+        fetchRatingSynthesis(pr.owner, pr.repo, pr.prNumber, token),
+        fetchAutoFixManifest(pr.owner, pr.repo, pr.prNumber, token),
+        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 = {
-        owner: pr.owner,
-        repo: pr.repo,
-        prNumber: pr.prNumber,
-        bucket,
-        state: meta.merged ? 'merged' : meta.state,
+        ref: `${pr.owner}/${pr.repo}#${pr.prNumber}`,
         title: meta.title,
-        headSha: meta.head.sha,
-        haystackUrl: `https://haystackeditor.com/review/${pr.owner}/${pr.repo}/${pr.prNumber}`,
-        mergeQueue: null,
-        lastTriage: synthesis?.haystackRating != null
+        head_sha: meta.head.sha,
+        triage: synthesis
             ? {
-                rating: synthesis.haystackRating,
-                completedAt: new Date().toISOString(),
-                headSha: meta.head.sha,
+                status: 'complete',
+                verdict: verdict === 'clean' ? 'good_to_merge' : verdict === 'needs-review' ? 'needs_review' : 'needs_input',
+                findings_count: synthesis.synthesisDisplay?.length ?? 0,
             }
-            : null,
+            : { status: 'pending', verdict: null, findings_count: 0 },
+        merge,
+        traces: {
+            available: traces?.hasTraces === true,
+            count: traces?.traces?.length ?? 0,
+        },
     };
-    if (opts.json) {
-        console.log(JSON.stringify(withSchema('pr', payload), null, 2));
-        return;
+    if (manifest) {
+        const fixed = manifest.fixedItems.length;
+        const remaining = manifest.leftForReview.length;
+        payload.fixer = {
+            status: 'completed',
+            result_sha: manifest.resultSha ?? meta.head.sha,
+            summary: `Fixed ${fixed} finding${fixed === 1 ? '' : 's'}; ${remaining} remain${remaining === 1 ? 's' : ''} for review.`,
+        };
     }
-    console.log(`\n  ${chalk.bold(`${pr.owner}/${pr.repo}#${pr.prNumber}`)}  ${chalk.dim(meta.title)}`);
-    console.log(`  ${chalk.dim('bucket:')}    ${bucket}`);
-    console.log(`  ${chalk.dim('state:')}     ${payload.state}`);
-    console.log(`  ${chalk.dim('head:')}      ${meta.head.sha.slice(0, 7)} (${meta.head.ref})`);
-    if (payload.lastTriage) {
-        console.log(`  ${chalk.dim('rating:')}    ★${payload.lastTriage.rating}`);
+    return withSchema('pr', payload);
+}
+export async function prReadCommand(ref, options) {
+    const payload = await fetchPrStatePayload(ref);
+    if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
     }
-    console.log(`  ${chalk.dim(payload.haystackUrl)}\n`);
+    const triage = payload.triage;
+    const merge = payload.merge;
+    console.log(`\n  ${chalk.bold(String(payload.ref))}  ${chalk.dim(String(payload.title))}`);
+    console.log(`  ${chalk.dim('triage:')}  ${triage.status}${triage.verdict ? ` · ${triage.verdict}` : ''} · ${triage.findings_count} findings`);
+    console.log(`  ${chalk.dim('merge:')}   ${merge.status} · ${merge.reason}`);
+    if (merge.action)
+        console.log(`  ${chalk.dim('next:')}    ${merge.action}`);
+    console.log('');
 }

package/dist/commands/schema-cmd.js

@@ -37,5 +37,5 @@ export function listSchemas() {
         console.log(`  ${chalk.cyan(name.padEnd(10))} v${SCHEMA_VERSIONS[name]}`);
     }
     console.log(`\nPrint one with: ${chalk.dim('haystack schema <name>')}\n` +
-        `External URL:   ${chalk.dim('https://docs.haystackeditor.com/cli/schemas/<name>.v1.json')}`);
+        `External URL:   ${chalk.dim('https://docs.haystackeditor.com/cli/schemas/<name>.v<major>.json')}`);
 }

package/dist/commands/traces.d.ts

@@ -0,0 +1,48 @@
+export interface TraceGetOptions {
+    json?: boolean;
+    cursor?: string;
+    limit?: string;
+}
+export declare function fetchTracesListPayload(ref: string): Promise<{
+    operation: string;
+    ref: string;
+    head_sha: string;
+    checkpoints: {
+        checkpoint_id: string;
+        commit_sha: string;
+        commit_message: string;
+        timestamp: string | null;
+        summary: string;
+        user_prompt: string | null;
+        files_touched: string[];
+        branch: string | null;
+    }[];
+} & {
+    schema_version: string;
+}>;
+export declare function tracesListCommand(ref: string, options: {
+    json?: boolean;
+}): Promise<void>;
+export declare function fetchTracesGetPayload(ref: string, checkpointId: string, options: Pick<TraceGetOptions, 'cursor' | 'limit'>): Promise<{
+    operation: string;
+    ref: string;
+    head_sha: string;
+    checkpoint_id: string;
+    checkpoint: {
+        checkpoint_id: string;
+        commit_sha: string;
+        commit_message: string;
+        timestamp: string | null;
+        summary: string;
+        user_prompt: string | null;
+        files_touched: string[];
+        branch: string | null;
+    } | null;
+    chunks: string[];
+    total_chunks: number;
+    total_chars: number;
+    next_cursor: string | null;
+} & {
+    schema_version: string;
+}>;
+export declare function tracesGetCommand(ref: string, checkpointId: string, options: TraceGetOptions): Promise<void>;

package/dist/commands/traces.js

@@ -0,0 +1,92 @@
+import chalk from 'chalk';
+import { loadToken } from '../utils/auth.js';
+import { fetchAnalysisArtifact, fetchGitHubJson } from '../utils/haystack-api.js';
+import { withSchema } from '../schema.js';
+import { parsePrRef } from './pr.js';
+function publicCheckpoint(trace) {
+    return {
+        checkpoint_id: trace.checkpointId,
+        commit_sha: trace.commitSha,
+        commit_message: trace.commitMessage,
+        timestamp: trace.timestamp ?? null,
+        summary: trace.overviewSummary,
+        user_prompt: trace.userPrompt ?? null,
+        files_touched: trace.filesTouched ?? [],
+        branch: trace.branch ?? null,
+    };
+}
+async function tokenAndHead(ref) {
+    const pr = parsePrRef(ref);
+    const token = await loadToken({ owner: pr.owner, repo: pr.repo });
+    if (!token)
+        throw new Error('Not authenticated. Run `haystack login` first.');
+    const meta = await fetchGitHubJson(`/repos/${pr.owner}/${pr.repo}/pulls/${pr.prNumber}`, token);
+    return { pr, token, headSha: meta.head.sha, ref: `${pr.owner}/${pr.repo}#${pr.prNumber}` };
+}
+export async function fetchTracesListPayload(ref) {
+    const { pr, token, headSha, ref: normalizedRef } = await tokenAndHead(ref);
+    const overview = await fetchAnalysisArtifact(pr.owner, pr.repo, pr.prNumber, 'entire_traces.json', token);
+    return withSchema('traces', {
+        operation: 'list',
+        ref: normalizedRef,
+        head_sha: headSha,
+        checkpoints: (overview?.traces ?? []).map(publicCheckpoint),
+    });
+}
+export async function tracesListCommand(ref, options) {
+    const payload = await fetchTracesListPayload(ref);
+    if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    if (payload.checkpoints.length === 0) {
+        console.log(chalk.dim('\nNo retained customer traces for this PR.\n'));
+        return;
+    }
+    console.log(chalk.bold('\nCustomer traces\n'));
+    for (const trace of payload.checkpoints) {
+        console.log(`${chalk.cyan(trace.checkpoint_id)}  ${trace.commit_message}`);
+        console.log(`  ${trace.summary}\n`);
+    }
+}
+export async function fetchTracesGetPayload(ref, checkpointId, options) {
+    const { pr, token, headSha, ref: normalizedRef } = await tokenAndHead(ref);
+    const [trace, overview] = await Promise.all([
+        fetchAnalysisArtifact(pr.owner, pr.repo, pr.prNumber, `entire_trace_chunks/${encodeURIComponent(checkpointId)}.json`, token),
+        fetchAnalysisArtifact(pr.owner, pr.repo, pr.prNumber, 'entire_traces.json', token),
+    ]);
+    if (!trace)
+        throw new Error(`Trace checkpoint not found: ${checkpointId}`);
+    if (trace.checkpointId !== checkpointId)
+        throw new Error('Trace checkpoint provenance mismatch');
+    const cursor = Math.max(0, Number.parseInt(options.cursor ?? '0', 10) || 0);
+    const limit = Math.min(100, Math.max(1, Number.parseInt(options.limit ?? '20', 10) || 20));
+    const chunks = trace.chunks.slice(cursor, cursor + limit);
+    const next = cursor + chunks.length < trace.chunks.length ? String(cursor + chunks.length) : null;
+    return withSchema('traces', {
+        operation: 'get',
+        ref: normalizedRef,
+        head_sha: headSha,
+        checkpoint_id: trace.checkpointId,
+        checkpoint: (() => {
+            const item = overview?.traces?.find((candidate) => candidate.checkpointId === trace.checkpointId);
+            return item ? publicCheckpoint(item) : null;
+        })(),
+        chunks,
+        total_chunks: trace.chunks.length,
+        total_chars: trace.totalChars,
+        next_cursor: next,
+    });
+}
+export async function tracesGetCommand(ref, checkpointId, options) {
+    const payload = await fetchTracesGetPayload(ref, checkpointId, options);
+    const chunks = payload.chunks;
+    const next = payload.next_cursor;
+    if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(chunks.join('\n\n---\n\n'));
+    if (next)
+        console.log(chalk.dim(`\nMore available: --cursor ${next}\n`));
+}

package/dist/commands/triage.d.ts

@@ -19,10 +19,22 @@
  *   --json    Machine-readable JSON
  *   (default) Rich terminal output
  */
+import type { RatingSynthesis, AutoFixManifest } from '../utils/analysis-api.js';
 export interface TriageOptions {
     json?: boolean;
     wait?: boolean;
     hook?: boolean;
     clear?: boolean;
 }
+interface ParsedPR {
+    owner: string;
+    repo: string;
+    prNumber: number;
+}
+export declare function buildJsonOutput(pr: ParsedPR, headSha: string | null, synthesis: RatingSynthesis, manifest?: AutoFixManifest | null): Record<string, unknown>;
+export declare function buildJsonState(pr: ParsedPR, status: 'pending' | 'failed' | 'unavailable', message?: string): Record<string, unknown>;
+export declare function fetchTriageHeadSha(pr: ParsedPR, token?: string): Promise<string | null>;
 export declare function triageCommand(identifier: string | undefined, options: TriageOptions): Promise<void>;
+/** Pure read path for MCP: returns a public payload without writing stdout or exiting. */
+export declare function fetchTriagePayload(identifier: string): Promise<Record<string, unknown>>;
+export {};

package/dist/commands/triage.js

@@ -26,6 +26,7 @@ import { parseRemoteUrl } from '../utils/git.js';
 import { loadToken } from '../utils/auth.js';
 import { loadPendingSubmit, updatePendingSubmit, clearPendingSubmit } from '../utils/pending-state.js';
 import { withSchema } from '../schema.js';
+import { fetchGitHubJson } from '../utils/haystack-api.js';
 // ============================================================================
 // PR identifier parsing
 // ============================================================================
@@ -85,29 +86,14 @@ function isAutoFixing(finding, manifest) {
 function printRichOutput(pr, synthesis, manifest) {
     const reviewUrl = `https://haystackeditor.com/review/${pr.owner}/${pr.repo}/${pr.prNumber}`;
     console.log(`\n  ${chalk.bold(`Haystack Triage: ${pr.owner}/${pr.repo}#${pr.prNumber}`)}\n`);
-    // Auto-fixer status — what's being fixed vs what it skipped
+    // Alpha output stays intentionally small. Findings remain fully visible below.
     if (manifest && (manifest.fixedItems.length > 0 || manifest.leftForReview.length > 0)) {
-        if (manifest.fixedItems.length > 0) {
-            console.log(chalk.bold('  Auto-fixer is handling these (leave them alone):\n'));
-            for (const item of manifest.fixedItems) {
-                console.log(`    - [${item.category}] ${item.summary}`);
-            }
-            console.log(`  ${chalk.dim("Don't fix these. The auto-fixer is already on them and will push its own commit.")}\n`);
-        }
-        if (manifest.leftForReview.length > 0) {
-            console.log(chalk.bold('  Auto-fixer skipped these (they need you):\n'));
-            for (const item of manifest.leftForReview) {
-                console.log(`    - [${item.category}] ${item.summary}`);
-                console.log(`      ${chalk.dim(item.reason)}`);
-            }
-            console.log('');
-        }
+        const fixed = manifest.fixedItems.length;
+        const remaining = manifest.leftForReview.length;
+        console.log(chalk.dim(`  Fixer: completed · fixed ${fixed}; ${remaining} remain for review.\n`));
     }
-    // Findings — the actionable output for agents. Exclude anything the auto-fixer
-    // is already handling so the agent doesn't duplicate (and fight) its work.
-    const allFindings = synthesis.synthesisDisplay || [];
-    const findings = allFindings.filter((f) => !isAutoFixing(f, manifest));
-    const fixingCount = manifest?.fixedItems?.length ?? 0;
+    // Every customer-facing finding stays visible regardless of fixer state.
+    const findings = synthesis.synthesisDisplay || [];
     if (findings.length > 0) {
         console.log(chalk.bold('  Findings to address:\n'));
         for (let i = 0; i < findings.length; i++) {
@@ -129,35 +115,74 @@ function printRichOutput(pr, synthesis, manifest) {
             console.log('');
         }
     }
-    else if (fixingCount > 0 && allFindings.length > 0) {
-        // Every finding is being auto-fixed — nothing left for the agent.
-        console.log(chalk.dim('  Nothing to address. Every finding is being auto-fixed (see above).\n'));
-    }
     else {
         console.log(chalk.dim('  No findings.\n'));
     }
     console.log(`  ${chalk.dim(reviewUrl)}\n`);
 }
-function printJsonOutput(pr, synthesis, manifest) {
-    const output = withSchema('triage', {
-        owner: pr.owner,
-        repo: pr.repo,
-        prNumber: pr.prNumber,
+export function buildJsonOutput(pr, headSha, synthesis, manifest) {
+    const verdict = synthesis.analysisVerdict
+        ?? (synthesis.haystackRating >= 5 ? 'clean' : 'has-issues');
+    const payload = {
+        ref: `${pr.owner}/${pr.repo}#${pr.prNumber}`,
+        head_sha: headSha,
+        status: 'complete',
+        verdict: verdict === 'clean' ? 'good_to_merge' : verdict === 'needs-review' ? 'needs_review' : 'needs_input',
         rating: synthesis.haystackRating,
-        // Issues the auto-fixer is already on — leave these alone, do not re-fix.
-        autoFixerHandling: manifest?.fixedItems ?? [],
-        autoFixerSkipped: manifest?.leftForReview ?? [],
+        human_review_reasons: synthesis.humanReviewReasons ?? [],
         findings: (synthesis.synthesisDisplay || []).map((f) => ({
+            id: f.id ?? null,
             category: f.category,
             summary: f.summary,
             detail: f.detail,
-            agentFixPrompt: f.agentFixPrompt || null,
-            source: f.source || null,
-            // True when the auto-fixer is handling this finding — don't fix it yourself.
-            autoFixing: isAutoFixing(f, manifest),
+            suggested_fix: f.agentFixPrompt ?? null,
+            source: f.source ?? null,
+            location: f.filePath || f.startLine != null || f.endLine != null
+                ? {
+                    path: f.filePath ?? null,
+                    start_line: f.startLine ?? null,
+                    end_line: f.endLine ?? null,
+                }
+                : null,
+            severity: f.severity ?? null,
         })),
-    });
-    console.log(JSON.stringify(output, null, 2));
+    };
+    if (manifest) {
+        const fixed = manifest.fixedItems.length;
+        const remaining = manifest.leftForReview.length;
+        payload.fixer = {
+            status: 'completed',
+            result_sha: manifest.resultSha ?? headSha,
+            summary: `Fixed ${fixed} finding${fixed === 1 ? '' : 's'}; ${remaining} remain${remaining === 1 ? 's' : ''} for review.`,
+        };
+    }
+    return withSchema('triage', payload);
+}
+export function buildJsonState(pr, status, message) {
+    const payload = {
+        ref: `${pr.owner}/${pr.repo}#${pr.prNumber}`,
+        head_sha: null,
+        status,
+        verdict: null,
+        rating: null,
+        human_review_reasons: [],
+        findings: [],
+    };
+    if (message)
+        payload.message = message;
+    return withSchema('triage', payload);
+}
+export async function fetchTriageHeadSha(pr, token) {
+    if (!token)
+        return null;
+    const meta = await fetchGitHubJson(`/repos/${pr.owner}/${pr.repo}/pulls/${pr.prNumber}`, token);
+    const headSha = meta.head?.sha;
+    if (!headSha)
+        throw new Error('GitHub PR metadata response is missing head.sha');
+    return headSha;
+}
+function printJsonState(pr, status, message) {
+    console.log(JSON.stringify(buildJsonState(pr, status, message), null, 2));
 }
 function ratingStars(rating) {
     const filled = '\u2605'; // ★
@@ -391,9 +416,7 @@ export async function triageCommand(identifier, options) {
         }
         else if (options.wait === false) {
             if (options.json) {
-                console.log(JSON.stringify({
-                    owner: pr.owner, repo: pr.repo, prNumber: pr.prNumber, status: 'pending',
-                }, null, 2));
+                printJsonState(pr, 'pending');
             }
             else {
                 console.log(chalk.yellow('\n  Analysis is still in progress.'));
@@ -415,9 +438,7 @@ export async function triageCommand(identifier, options) {
             }
             else if (waitResult === 'pending') {
                 if (options.json) {
-                    console.log(JSON.stringify({
-                        owner: pr.owner, repo: pr.repo, prNumber: pr.prNumber, status: 'pending',
-                    }, null, 2));
+                    printJsonState(pr, 'pending', 'Timed out waiting for analysis');
                 }
                 else {
                     console.log(chalk.yellow('\n  Timed out waiting for analysis.'));
@@ -428,9 +449,7 @@ export async function triageCommand(identifier, options) {
             else {
                 // waitResult === 'error'
                 if (options.json) {
-                    console.log(JSON.stringify({
-                        owner: pr.owner, repo: pr.repo, prNumber: pr.prNumber, status: 'error',
-                    }, null, 2));
+                    printJsonState(pr, 'failed', 'Analysis check failed');
                 }
                 else {
                     console.error(chalk.red('\n  Analysis check failed.\n'));
@@ -446,10 +465,7 @@ export async function triageCommand(identifier, options) {
             return;
         }
         if (options.json) {
-            console.log(JSON.stringify({
-                owner: pr.owner, repo: pr.repo, prNumber: pr.prNumber,
-                status: 'error', message: readyResult.message,
-            }, null, 2));
+            printJsonState(pr, 'failed', readyResult.message);
         }
         else {
             console.error(chalk.red(`\n  Analysis check failed: ${readyResult.message}\n`));
@@ -459,9 +475,10 @@ export async function triageCommand(identifier, options) {
     if (!analysisReady)
         return;
     // Fetch the full rating synthesis and auto-fix manifest in parallel
-    const [synthesis, autoFixManifest] = await Promise.all([
+    const [synthesis, autoFixManifest, headSha] = await Promise.all([
         fetchRatingSynthesis(pr.owner, pr.repo, pr.prNumber, token),
         fetchAutoFixManifest(pr.owner, pr.repo, pr.prNumber, token),
+        fetchTriageHeadSha(pr, token),
     ]);
     // Update pending state if this PR matches the pending submit
     updatePendingSubmitIfExists(pr, synthesis ? 'completed' : undefined);
@@ -471,10 +488,7 @@ export async function triageCommand(identifier, options) {
             return;
         }
         if (options.json) {
-            console.log(JSON.stringify({
-                owner: pr.owner, repo: pr.repo, prNumber: pr.prNumber,
-                status: 'error', message: 'Rating synthesis not available',
-            }, null, 2));
+            printJsonState(pr, 'unavailable', 'Rating synthesis not available');
         }
         else {
             console.error(chalk.yellow('\n  Analysis completed but rating synthesis is not available yet.'));
@@ -488,7 +502,7 @@ export async function triageCommand(identifier, options) {
         printHookOutput(pr, synthesis, autoFixManifest);
     }
     else if (options.json) {
-        printJsonOutput(pr, synthesis, autoFixManifest);
+        console.log(JSON.stringify(buildJsonOutput(pr, headSha, synthesis, autoFixManifest), null, 2));
     }
     else {
         printRichOutput(pr, synthesis, autoFixManifest);
@@ -504,6 +518,24 @@ export async function triageCommand(identifier, options) {
         });
     }
 }
+/** Pure read path for MCP: returns a public payload without writing stdout or exiting. */
+export async function fetchTriagePayload(identifier) {
+    const pr = parsePRIdentifier(identifier);
+    const token = await loadToken({ owner: pr.owner, repo: pr.repo }) || undefined;
+    const ready = await checkAnalysisReady(pr.owner, pr.repo, pr.prNumber, token);
+    if (ready.status === 'pending')
+        return buildJsonState(pr, 'pending');
+    if (ready.status === 'error')
+        return buildJsonState(pr, 'failed', ready.message);
+    const [synthesis, manifest, headSha] = await Promise.all([
+        fetchRatingSynthesis(pr.owner, pr.repo, pr.prNumber, token),
+        fetchAutoFixManifest(pr.owner, pr.repo, pr.prNumber, token),
+        fetchTriageHeadSha(pr, token),
+    ]);
+    if (!synthesis)
+        return buildJsonState(pr, 'unavailable', 'Rating synthesis not available');
+    return buildJsonOutput(pr, headSha, synthesis, manifest);
+}
 /**
  * Update the pending-submit state if the given PR matches the pending one.
  * Best-effort — failure is silently ignored.

package/dist/commands/webhooks.js

@@ -30,14 +30,11 @@ import { parseRemoteUrl, UnsupportedRemoteUrlError } from '../utils/git.js';
 import { loadToken } from '../utils/auth.js';
 const DEFAULT_WORKER_URL = process.env.HAYSTACK_WEBHOOKS_URL ??
     'https://haystack-webhooks.akshaysg.workers.dev';
-// Keep in lockstep with infra/webhooks-worker/src/types.ts ALLOWED_EVENTS
-// and agent/cloudflare/src/webhook-emitter.ts WebhookEvent. The three
-// lists must agree: a CLI-accepted event with no worker/emitter support
-// either 400s at registration or silently never fires.
+// Public events accepted by the CLI. The backend may support additional
+// gated events, but alpha-only features should not appear in normal CLI help.
 const ALLOWED_EVENTS = [
     'triage.completed',
     'triage.failed',
-    'fixer.completed',
     'merge_queue.state_changed',
     // 'review_chat.response_ready' deferred — chat CLI was cut, no producer.
     'pr.classified',
@@ -124,7 +121,7 @@ async function readJsonOrFail(res) {
 // ─── register ────────────────────────────────────────────────────────────────
 export async function registerWebhook(opts) {
     const repo = opts.repo ?? currentRepo();
-    const events = opts.events ?? ['triage.completed', 'triage.failed', 'fixer.completed'];
+    const events = opts.events ?? ['triage.completed', 'triage.failed'];
     for (const e of events) {
         if (!ALLOWED_EVENTS.includes(e)) {
             throw new Error(`Unknown event "${e}". Allowed: ${ALLOWED_EVENTS.join(', ')}`);