@haystackeditor/cli 0.15.17 → 0.15.19

package/dist/commands/review.js

@@ -0,0 +1,193 @@
+/**
+ * review command — Trigger a fresh Haystack analysis for a PR.
+ *
+ * haystack review [pr] [--no-wait]
+ *
+ * Haystack runs a full analysis when a PR is opened (or marked ready);
+ * later pushes only get a resolution check against the existing findings.
+ * This command is the explicit escape hatch: it re-runs full detection on
+ * the PR's current head — use it after substantial new commits, or any
+ * time you want a fresh second opinion.
+ *
+ * When called without a PR identifier, reads the last submitted PR from
+ * `.haystack/pending-submit.json` (written by `haystack submit`).
+ *
+ * Accepts a PR identifier in several formats:
+ *   haystack review                      # Last submitted PR
+ *   haystack review 123                  # Uses current repo's owner/repo
+ *   haystack review owner/repo#123       # Fully qualified
+ *   haystack review https://github.com/owner/repo/pull/123
+ */
+import chalk from 'chalk';
+import { triggerAnalysis, fetchTriggerStatus } from '../utils/analysis-api.js';
+import { fetchTriageHeadSha } from './triage.js';
+import { parseRemoteUrl } from '../utils/git.js';
+import { loadToken } from '../utils/auth.js';
+import { loadPendingSubmit } from '../utils/pending-state.js';
+import { triageCommand } from './triage.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const STATUS_POLL_INTERVAL_MS = 10_000;
+// Full analyses regularly take 10+ minutes on large PRs; this bounds the
+// CLI's wait, not the analysis itself (results land on the feed regardless).
+const STATUS_POLL_TIMEOUT_MS = 25 * 60 * 1000;
+// ============================================================================
+// PR identifier parsing (shared pattern with request-review.ts / triage.ts)
+// ============================================================================
+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 review owner/repo#${prNumber}`);
+        }
+    }
+    throw new Error(`Invalid PR identifier: "${identifier}"\n\n` +
+        `Accepted formats:\n` +
+        `  haystack review 123\n` +
+        `  haystack review owner/repo#123\n` +
+        `  haystack review https://github.com/owner/repo/pull/123`);
+}
+function resolvePR(identifier) {
+    if (identifier) {
+        try {
+            return parsePRIdentifier(identifier);
+        }
+        catch (err) {
+            console.error(chalk.red(`\n${err.message}\n`));
+            process.exit(1);
+        }
+    }
+    const pending = loadPendingSubmit();
+    if (!pending) {
+        console.log(chalk.dim('No pending submits. Pass a PR number to review a specific PR.\n'));
+        return null;
+    }
+    return { owner: pending.owner, repo: pending.repo, prNumber: pending.prNumber };
+}
+// ============================================================================
+// Waiting
+// ============================================================================
+async function waitForRun(requestId, token) {
+    const deadline = Date.now() + STATUS_POLL_TIMEOUT_MS;
+    let consecutiveErrors = 0;
+    while (Date.now() < deadline) {
+        const result = await fetchTriggerStatus(requestId, token);
+        if (result.status === 'COMPLETED')
+            return 'completed';
+        if (result.status === 'FAILED')
+            return 'failed';
+        if (result.status === 'SUPERSEDED')
+            return 'superseded';
+        if (result.status === 'error') {
+            consecutiveErrors++;
+            if (consecutiveErrors >= 5)
+                return 'failed';
+        }
+        else {
+            consecutiveErrors = 0;
+        }
+        process.stderr.write(`\r  ${chalk.dim('Analysis in progress...')}${'  '.repeat(5)}`);
+        // Deliberately NOT unref'd: during the wait this timer can be the only
+        // live handle, and an unref'd timer lets Node exit mid-wait.
+        await new Promise((resolve) => {
+            setTimeout(resolve, STATUS_POLL_INTERVAL_MS);
+        });
+    }
+    return 'timeout';
+}
+// ============================================================================
+// Main command
+// ============================================================================
+export async function reviewCommand(identifier, options) {
+    const pr = resolvePR(identifier);
+    if (!pr)
+        return;
+    const prLabel = `${pr.owner}/${pr.repo}#${pr.prNumber}`;
+    let token = null;
+    try {
+        token = await loadToken({ owner: pr.owner, repo: pr.repo });
+    }
+    catch (err) {
+        console.error(chalk.red(`\nCould not load Haystack credentials: ${err.message}\n`));
+        process.exit(1);
+    }
+    if (!token) {
+        console.error(chalk.red('\nTriggering an analysis requires authentication.'));
+        console.log(chalk.dim('  Run ') + chalk.cyan('haystack login') + chalk.dim(' first.\n'));
+        process.exit(1);
+    }
+    console.log(chalk.dim(`\nRequesting a fresh analysis for ${prLabel}...`));
+    // Resolve the current head so ingestion's dedup compares commits — an
+    // in-flight run for an OLDER head must be superseded, not reused. A
+    // failed metadata fetch degrades to a head-less trigger (the dedup is a
+    // freshness aid, not a correctness requirement) instead of crashing.
+    let headSha;
+    try {
+        headSha = await fetchTriageHeadSha(pr, token) ?? undefined;
+    }
+    catch (err) {
+        console.log(chalk.dim(`  Could not resolve the PR head (${err.message}) — continuing without it.`));
+    }
+    const trigger = await triggerAnalysis(pr.owner, pr.repo, pr.prNumber, token, headSha);
+    if (trigger.status === 'rate_limited') {
+        console.error(chalk.red(`\n  ${trigger.message}`));
+        if (trigger.retryAfterSeconds) {
+            console.log(chalk.dim(`  Try again in ~${Math.ceil(trigger.retryAfterSeconds / 60)} minute(s).\n`));
+        }
+        process.exit(1);
+    }
+    if (trigger.status === 'denied') {
+        console.error(chalk.red(`\n  ${trigger.message}\n`));
+        process.exit(1);
+    }
+    if (trigger.status === 'error') {
+        console.error(chalk.red(`\n  Failed to trigger analysis: ${trigger.message}\n`));
+        process.exit(1);
+    }
+    if (trigger.status === 'already_processing') {
+        console.log(chalk.yellow('  An analysis for this PR is already running — waiting on it instead.'));
+    }
+    else {
+        console.log(chalk.green('  Analysis started.'));
+    }
+    if (options.wait === false) {
+        console.log(chalk.dim('  Check results later with: ') + chalk.cyan(`haystack triage ${prLabel}`));
+        console.log(chalk.dim('  Or view the review: ') + chalk.cyan(`https://haystackeditor.com/review/${pr.owner}/${pr.repo}/${pr.prNumber}\n`));
+        return;
+    }
+    const outcome = await waitForRun(trigger.requestId, token);
+    process.stderr.write('\r' + ' '.repeat(60) + '\r');
+    if (outcome === 'failed') {
+        console.error(chalk.red('\n  Analysis run failed.'));
+        console.log(chalk.dim('  Check the review page: ') + chalk.cyan(`https://haystackeditor.com/review/${pr.owner}/${pr.repo}/${pr.prNumber}\n`));
+        process.exit(1);
+    }
+    if (outcome === 'superseded') {
+        console.log(chalk.yellow('\n  This run was superseded by a newer analysis (a push likely landed meanwhile).'));
+        console.log(chalk.dim('  Showing the latest results instead.'));
+        await triageCommand(prLabel, { wait: false });
+        return;
+    }
+    if (outcome === 'timeout') {
+        console.log(chalk.yellow('\n  Still running after 25 minutes — giving up on waiting.'));
+        console.log(chalk.dim('  Check results later with: ') + chalk.cyan(`haystack triage ${prLabel}\n`));
+        return;
+    }
+    // Completed — render results through the triage view (no extra wait).
+    await triageCommand(prLabel, { wait: false });
+}

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/skills.js

@@ -15,6 +15,7 @@ function getSkillsSourceDir() {
 const SKILL_FILES = [
     'setup-haystack.md',
     'submit.md',
+    'map-your-system.md',
 ];
 function installSkillFiles(targetDir) {
     const sourceDir = getSkillsSourceDir();
@@ -55,6 +56,7 @@ export async function installSkills(options) {
     }
     const claudeCommandPath = join(claudeCommandsDir, 'setup-haystack.md');
     writeFileSync(claudeCommandPath, '# Set Up Haystack\n\nFollow .agents/skills/setup-haystack.md to set up Haystack for this repo.\n');
+    writeFileSync(join(claudeCommandsDir, 'map-your-system.md'), '# Map Your System for Haystack QA\n\nFollow .agents/skills/map-your-system.md to create .haystack/system.yml — verified facts about how this system builds, boots, seeds data, and logs in, so Haystack QA can run it.\n');
     showSuccessMessage();
 }
 function showSuccessMessage() {
@@ -62,6 +64,7 @@ function showSuccessMessage() {
     console.log(chalk.white('Available skills:'));
     console.log(chalk.cyan('  /setup-haystack         ') + chalk.gray('- Create .haystack.json with AI assistance'));
     console.log(chalk.cyan('  /submit                 ') + chalk.gray('- Submit a PR via Haystack'));
+    console.log(chalk.cyan('  /map-your-system        ') + chalk.gray('- Write .haystack/system.yml so Haystack QA can run this system'));
     console.log();
     console.log(chalk.white('Run in your coding CLI:'));
     console.log(chalk.cyan('  /setup-haystack'));
@@ -71,5 +74,6 @@ export async function listSkills() {
     console.log(chalk.white('\nAvailable Haystack skills:\n'));
     console.log(chalk.cyan('  /setup-haystack         ') + chalk.gray('- Master setup - creates .haystack.json'));
     console.log(chalk.cyan('  /submit                 ') + chalk.gray('- Submit a PR via Haystack'));
+    console.log(chalk.cyan('  /map-your-system        ') + chalk.gray('- Write .haystack/system.yml so Haystack QA can run this system'));
     console.log();
 }

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(', ')}`);