@haystackeditor/cli 0.15.16 → 0.15.18

package/README.md

@@ -69,7 +69,6 @@ Create a PR from current changes. Runs pre-PR triage (code review, rules validat
 
 ```bash
 haystack submit                      # Triage -> create PR -> wait for analysis
-haystack submit --auto-fix           # Discouraged alpha auto-fix for straightforward mechanical issues
 haystack submit --title "Fix auth"   # Custom PR title
 haystack submit --draft              # Create as draft PR
 haystack submit --force              # Skip triage checks
@@ -85,8 +84,6 @@ haystack submit --review octocat     # Request review from a specific teammate
 
 When `--review` is used without a username, the PR is labeled `haystack:needs-review` and appears in your team's assignment queue. When a username is provided, that person is also requested as a reviewer on GitHub.
 
-The `--auto-fix` flag is an alpha feature and is discouraged by default. It opts into a sandbox agent that attempts straightforward mechanical fixes before surfacing issues in the Feed. For most PRs, prefer plain `haystack submit`.
-
 ### `haystack triage`
 
 View Haystack analysis results for any PR. Shows the same data as the Haystack web feed: rating, verdict, structured findings with details, verified bugs, human review reasons, and agent fix prompts.
@@ -102,9 +99,51 @@ haystack triage --hook                      # Minimal one-liner (for session hoo
 haystack triage --clear                     # Clear pending submit state
 ```
 
-When called without a PR identifier, checks the last PR submitted via `haystack submit`. The `--hook` flag produces a single-line summary with the Haystack rating and auto-fixer status, designed for session-start hooks.
+When called without a PR identifier, checks the last PR submitted via `haystack submit`. The `--hook` flag produces a single-line summary with the Haystack rating, designed for session-start hooks.
+
+The `--json` output includes every finding and its customer-facing `suggested_fix` when available.
+
+### `haystack inbox list`
+
+List PRs in your Haystack inbox with the reason each PR is present and the next action:
+
+```bash
+haystack inbox list
+haystack inbox list --json
+```
+
+### `haystack pr get`
+
+Get the useful state of one PR: triage, minimal merge blockers, and customer-trace availability:
+
+```bash
+haystack pr get 42
+haystack pr get owner/repo#42 --json
+```
+
+### `haystack ask`
+
+Ask Haystack Chat about a PR. Machine output contains the answer and every customer-facing source Chat consulted:
+
+```bash
+haystack ask 42 "Why is this finding legitimate?"
+haystack ask owner/repo#42 "Show the implementation" --json
+haystack ask owner/repo#42 "What about its callers?" --session <session-id> --json
+```
+
+Chat may search the complete authorized repository when the changed files are insufficient. Search results and fetched source are included in `evidence`.
+
+### `haystack traces`
+
+Inspect retained customer-owned Entire checkpoints and transcript chunks:
+
+```bash
+haystack traces list owner/repo#42 --json
+haystack traces get owner/repo#42 <checkpoint-id> --json
+haystack traces get owner/repo#42 <checkpoint-id> --cursor 20 --limit 20 --json
+```
 
-The `--json` output includes `agentFixPrompt` fields -- ready-to-paste instructions for coding agents to fix each finding.
+These commands expose customer coding-session data, not Haystack's internal analysis-agent execution.
 
 ### `haystack dismiss`
 
@@ -135,7 +174,7 @@ haystack mark-reviewed acme/widgets#99     # Mark for specific repo
 
 ### `haystack pr-status`
 
-Show what bucket a PR is in within the Haystack pipeline (analyzing, auto-fixing, good-to-merge, issues, needs-assignment, etc.):
+Show what bucket a PR is in within the Haystack pipeline (analyzing, good-to-merge, issues, needs-assignment, etc.):
 
 ```bash
 haystack pr-status 42                          # Current repo, PR #42

package/dist/commands/ask.d.ts

@@ -0,0 +1,14 @@
+export interface AskOptions {
+    json?: boolean;
+    session?: string;
+}
+export interface AskResponse {
+    schema_version: string;
+    ref: string;
+    head_sha: string;
+    answer: string;
+    evidence: Array<Record<string, unknown>>;
+    session_id: string;
+}
+export declare function fetchAskPayload(ref: string, question: string, options: Pick<AskOptions, 'session'>): Promise<AskResponse>;
+export declare function askHaystackCommand(ref: string, question: string, options: AskOptions): Promise<void>;

package/dist/commands/ask.js

@@ -0,0 +1,20 @@
+import chalk from 'chalk';
+import { loadToken } from '../utils/auth.js';
+import { postAskHaystack } from '../utils/haystack-api.js';
+import { parsePrRef } from './pr.js';
+export async function fetchAskPayload(ref, question, options) {
+    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.');
+    return postAskHaystack(pr.owner, pr.repo, pr.prNumber, question, options.session, token);
+}
+export async function askHaystackCommand(ref, question, options) {
+    const response = await fetchAskPayload(ref, question, options);
+    if (options.json) {
+        console.log(JSON.stringify(response, null, 2));
+        return;
+    }
+    console.log(`\n${response.answer}\n`);
+    console.log(chalk.dim(`${response.evidence.length} source${response.evidence.length === 1 ? '' : 's'} consulted · session ${response.session_id}\n`));
+}

package/dist/commands/inbox.d.ts

@@ -0,0 +1,65 @@
+interface GitHubPull {
+    number: number;
+    title: string;
+    html_url: string;
+    draft?: boolean;
+    user: {
+        id: number;
+        login: string;
+    };
+    assignees?: Array<{
+        id: number;
+        login: string;
+    }>;
+    requested_reviewers?: Array<{
+        id: number;
+        login: string;
+    }>;
+    head: {
+        sha: string;
+        ref: string;
+    };
+    base: {
+        ref: string;
+    };
+}
+interface InboxCandidate extends GitHubPull {
+    owner: string;
+    repo: string;
+}
+interface AnalysisSummary {
+    analysisStatus?: 'pending' | 'in_queue' | 'ready' | 'error';
+    analysisVerdict?: 'clean' | 'has-issues' | 'needs-review';
+    haystackRating?: number;
+    needsHumanReview?: boolean;
+    findingsCount?: number;
+    merge?: {
+        status: string;
+        reason: string;
+        blocking_checks: string[];
+        action: string | null;
+    };
+}
+export interface InboxListOptions {
+    json?: boolean;
+}
+export declare function isRelevantToUser(pr: GitHubPull, userId: number): boolean;
+export declare function classify(candidate: InboxCandidate, analysis: AnalysisSummary | undefined): {
+    bucket: string;
+    reason: string;
+    action: string;
+};
+export declare function fetchInboxPayload(token: string): Promise<{
+    pull_requests: {
+        bucket: string;
+        reason: string;
+        action: string;
+        ref: string;
+        title: string;
+        head_sha: string;
+    }[];
+} & {
+    schema_version: string;
+}>;
+export declare function inboxListCommand(options: InboxListOptions): Promise<void>;
+export {};

package/dist/commands/inbox.js

@@ -0,0 +1,137 @@
+import chalk from 'chalk';
+import { loadToken } from '../utils/auth.js';
+import { fetchCliIdentity, fetchGitHubJson, fetchHaystackInstallations, haystackJson, } from '../utils/haystack-api.js';
+import { withSchema } from '../schema.js';
+async function fetchOpenPulls(owner, repo, token) {
+    const pulls = [];
+    for (let page = 1;; page++) {
+        const batch = await fetchGitHubJson(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls?state=open&per_page=100&page=${page}`, token);
+        pulls.push(...batch);
+        if (batch.length < 100)
+            return pulls;
+    }
+}
+export function isRelevantToUser(pr, userId) {
+    return pr.user.id === userId
+        || (pr.assignees ?? []).some((user) => user.id === userId)
+        || (pr.requested_reviewers ?? []).some((user) => user.id === userId);
+}
+async function mapConcurrent(values, concurrency, fn) {
+    const results = new Array(values.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, async () => {
+        while (next < values.length) {
+            const index = next++;
+            results[index] = await fn(values[index]);
+        }
+    }));
+    return results;
+}
+export function classify(candidate, analysis) {
+    const findingCount = analysis?.findingsCount ?? 0;
+    const failedChecks = analysis?.merge?.blocking_checks ?? [];
+    if (analysis?.analysisStatus === 'error') {
+        return {
+            bucket: 'needs_shepherding',
+            reason: 'Haystack analysis failed.',
+            action: 'Retry the analysis or inspect the failure.',
+        };
+    }
+    if (!analysis || analysis.analysisStatus === 'pending' || analysis.analysisStatus === 'in_queue') {
+        return {
+            bucket: 'analyzing',
+            reason: 'Haystack is still analyzing this PR.',
+            action: 'Wait for analysis to complete.',
+        };
+    }
+    if (analysis.analysisVerdict === 'has-issues' || (analysis.haystackRating ?? 5) < 4) {
+        return {
+            bucket: 'needs_shepherding',
+            reason: findingCount > 0
+                ? `Haystack found ${findingCount} author-actionable finding${findingCount === 1 ? '' : 's'}.`
+                : 'Haystack found author-actionable issues.',
+            action: 'Read the triage findings and resolve the issues.',
+        };
+    }
+    if (failedChecks.length > 0 || analysis.merge?.status === 'blocked') {
+        return {
+            bucket: 'needs_shepherding',
+            reason: failedChecks.length > 0
+                ? `${failedChecks.length} required check${failedChecks.length === 1 ? ' is' : 's are'} failing: ${failedChecks.join(', ')}.`
+                : (analysis.merge?.reason ?? 'The PR is blocked from merging.'),
+            action: analysis.merge?.action ?? 'Resolve the merge blockers.',
+        };
+    }
+    if (analysis.analysisVerdict === 'needs-review' || analysis.needsHumanReview) {
+        return {
+            bucket: 'needs_review',
+            reason: 'Analysis is clean, but review policy requires a human reviewer.',
+            action: 'Complete or request the required review.',
+        };
+    }
+    return {
+        bucket: 'good_to_merge',
+        reason: 'Haystack found no blocking issues.',
+        action: 'No user action is required.',
+    };
+}
+export async function fetchInboxPayload(token) {
+    const [identity, installations] = await Promise.all([
+        fetchCliIdentity(token),
+        fetchHaystackInstallations(token),
+    ]);
+    const repos = [...new Set(installations.flatMap((i) => i.repositories ?? []).map((r) => r.full_name))];
+    const batches = await mapConcurrent(repos, 8, async (fullName) => {
+        const [owner, repo] = fullName.split('/');
+        if (!owner || !repo)
+            throw new Error(`Invalid repository returned by Haystack: ${fullName}`);
+        const pulls = await fetchOpenPulls(owner, repo, token);
+        return pulls
+            .filter((pr) => isRelevantToUser(pr, identity.id))
+            .map((pr) => ({ ...pr, owner, repo }));
+    });
+    const candidates = batches.flat();
+    const refs = candidates.map((pr) => `${pr.owner}/${pr.repo}#${pr.number}`);
+    const analysis = refs.length === 0
+        ? {}
+        : await haystackJson('/api/bulk-analysis-summaries', token, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                prIdentifiers: refs,
+                prBaseBranches: Object.fromEntries(candidates.map((pr) => [`${pr.owner}/${pr.repo}#${pr.number}`, pr.base.ref])),
+                prHeadShas: Object.fromEntries(candidates.map((pr) => [`${pr.owner}/${pr.repo}#${pr.number}`, pr.head.sha])),
+            }),
+        });
+    return withSchema('inbox', {
+        pull_requests: candidates.map((pr) => {
+            const ref = `${pr.owner}/${pr.repo}#${pr.number}`;
+            return {
+                ref,
+                title: pr.title,
+                head_sha: pr.head.sha,
+                ...classify(pr, analysis[ref]),
+            };
+        }),
+    });
+}
+export async function inboxListCommand(options) {
+    const token = await loadToken();
+    if (!token)
+        throw new Error('Not authenticated. Run `haystack login` first.');
+    const payload = await fetchInboxPayload(token);
+    if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    if (payload.pull_requests.length === 0) {
+        console.log(chalk.dim('\nNo PRs need your attention.\n'));
+        return;
+    }
+    console.log(chalk.bold('\nHaystack inbox\n'));
+    for (const pr of payload.pull_requests) {
+        console.log(`${chalk.cyan(pr.ref)}  ${chalk.bold(pr.title)}`);
+        console.log(`  ${pr.reason}`);
+        console.log(`  ${chalk.dim('Next:')} ${pr.action}\n`);
+    }
+}

package/dist/commands/mcp.js

@@ -1,71 +1,74 @@
-/**
- * `haystack mcp` — Model Context Protocol server.
- *
- * Exposes Haystack's read surface to Claude Code, Cursor, Codex, etc. as
- * stdio MCP tools. Every tool wraps the same library function that powers
- * the corresponding `--json` CLI command, so an MCP client and a webhook
- * receiver see byte-identical payloads.
- *
- * Tools:
- *   triage_pr(ref)   same shape as `haystack triage <ref> --json`
- *   pr_state(ref)    PR state in the Haystack pipeline (schemas/pr.v1.json)
- *   schema(name)     prints the JSON Schema for a noun (debugging)
- *
- * Auth: inherited from the local CLI (loadToken). MCP clients run as the
- * operator's user, so they get whatever credentials are on disk — same model
- * as `git`, `gh`, etc.
- */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { parsePrRef, prReadCommand } from './pr.js';
-import { fetchRatingSynthesis, fetchAutoFixManifest } from '../utils/analysis-api.js';
+import { fetchInboxPayload } from './inbox.js';
+import { fetchPrStatePayload } from './pr.js';
+import { fetchTriagePayload } from './triage.js';
+import { fetchAskPayload } from './ask.js';
+import { fetchTracesGetPayload, fetchTracesListPayload } from './traces.js';
 import { loadToken } from '../utils/auth.js';
-import { SCHEMA_VERSIONS, withSchema } from '../schema.js';
+import { SCHEMA_VERSIONS } from '../schema.js';
+const refInput = {
+    type: 'string',
+    description: 'PR reference: bare number, owner/repo#number, or GitHub URL.',
+};
 const TOOLS = [
     {
-        name: 'triage_pr',
-        description: 'Fetch the latest triage results for a pull request. Returns rating, findings, ' +
-            'and which findings the auto-fixer is already handling. Identical shape to ' +
-            '`haystack triage <ref> --json`.',
+        name: 'inbox_list',
+        description: 'List PRs in the user\'s Haystack inbox with the reason and next action.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'pr_get',
+        description: 'Get useful state for one PR: triage, minimal merge blockers, trace availability, and conditional fixer outcome.',
+        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
+    },
+    {
+        name: 'triage_get',
+        description: 'Get the complete Haystack verdict and every customer-facing finding for one PR.',
+        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
+    },
+    {
+        name: 'ask_haystack',
+        description: 'Ask Haystack about a PR. Returns the answer and every customer-facing source consulted.',
         inputSchema: {
             type: 'object',
             properties: {
-                ref: {
-                    type: 'string',
-                    description: 'PR reference: bare number, owner/repo#number, or GitHub URL.',
-                },
+                ref: refInput,
+                question: { type: 'string', description: 'Question about the pull request.' },
+                session_id: { type: 'string', description: 'Optional prior Ask session to continue.' },
             },
-            required: ['ref'],
+            required: ['ref', 'question'],
         },
     },
     {
-        name: 'pr_state',
-        description: 'Show the Haystack state of a single PR: bucket, last triage rating, merge state.',
+        name: 'traces_list',
+        description: 'List retained customer-owned Entire checkpoints for one PR.',
+        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
+    },
+    {
+        name: 'traces_get',
+        description: 'Get a page of retained customer-owned transcript chunks for one checkpoint.',
         inputSchema: {
             type: 'object',
             properties: {
-                ref: { type: 'string', description: 'PR reference.' },
+                ref: refInput,
+                checkpoint_id: { type: 'string' },
+                cursor: { type: 'string' },
+                limit: { type: 'integer', minimum: 1, maximum: 100 },
             },
-            required: ['ref'],
+            required: ['ref', 'checkpoint_id'],
         },
     },
     {
         name: 'schema',
-        description: 'Return the JSON Schema for a Haystack --json command output. ' +
-            'Use this to discover the exact shape of triage / setup / pr envelopes.',
+        description: 'Return the committed JSON Schema for a Haystack machine response.',
         inputSchema: {
             type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    enum: Object.keys(SCHEMA_VERSIONS),
-                    description: 'Schema noun.',
-                },
-            },
+            properties: { name: { type: 'string', enum: Object.keys(SCHEMA_VERSIONS) } },
             required: ['name'],
         },
     },
@@ -73,113 +76,64 @@ const TOOLS = [
 async function readSchema(name) {
     const major = SCHEMA_VERSIONS[name].split('.')[0];
     const here = dirname(fileURLToPath(import.meta.url));
-    // dist/commands/mcp.js → ../../schemas/<name>.v<major>.json
-    const p = join(here, '..', '..', 'schemas', `${name}.v${major}.json`);
-    return JSON.parse(readFileSync(p, 'utf8'));
-}
-/** Capture process.stdout written by CLI commands and return it. MCP tool
- *  callbacks must return their result, not write it. The simplest way to
- *  reuse the existing --json printers without refactoring them is to
- *  redirect stdout for the duration of the call. */
-async function captureStdout(fn) {
-    const origWrite = process.stdout.write.bind(process.stdout);
-    let captured = '';
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    process.stdout.write = (chunk, encoding, cb) => {
-        captured += typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk);
-        if (typeof encoding === 'function')
-            encoding();
-        else if (cb)
-            cb();
-        return true;
-    };
-    try {
-        await fn();
-    }
-    finally {
-        process.stdout.write = origWrite;
-    }
-    return captured;
-}
-function jsonFromCapture(captured) {
-    try {
-        return JSON.parse(captured);
-    }
-    catch {
-        return { error: 'tool produced non-JSON output', raw: captured.slice(0, 1000) };
-    }
+    return JSON.parse(readFileSync(join(here, '..', '..', 'schemas', `${name}.v${major}.json`), 'utf8'));
 }
 export async function runMcpServer() {
-    const server = new Server({
-        name: 'haystack-cli',
-        version: '1.0.0',
-    }, {
-        capabilities: { tools: {} },
-    });
+    const server = new Server({ name: 'haystack-cli', version: '1.0.0' }, { capabilities: { tools: {} } });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
-        const ok = (data) => ({
-            content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
-        });
-        const fail = (msg) => ({
-            isError: true,
-            content: [{ type: 'text', text: msg }],
-        });
+        const input = (args ?? {});
+        const ok = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
+        const fail = (message) => ({ isError: true, content: [{ type: 'text', text: message }] });
         try {
-            if (name === 'triage_pr') {
-                const ref = args?.ref;
-                if (!ref)
+            if (name === 'inbox_list') {
+                const token = await loadToken();
+                if (!token)
+                    return fail('Not authenticated. Run `haystack login` first.');
+                return ok(await fetchInboxPayload(token));
+            }
+            if (name === 'pr_get') {
+                if (typeof input.ref !== 'string')
                     return fail('ref required');
-                const pr = parsePrRef(ref);
-                const token = (await loadToken()) ?? undefined;
-                const [synthesis, manifest] = await Promise.all([
-                    fetchRatingSynthesis(pr.owner, pr.repo, pr.prNumber, token),
-                    fetchAutoFixManifest(pr.owner, pr.repo, pr.prNumber, token),
-                ]);
-                if (!synthesis)
-                    return fail(`No triage data for ${pr.owner}/${pr.repo}#${pr.prNumber}`);
-                // Mirror triage --json envelope.
-                return ok(withSchema('triage', {
-                    owner: pr.owner,
-                    repo: pr.repo,
-                    prNumber: pr.prNumber,
-                    rating: synthesis.haystackRating,
-                    autoFixerHandling: manifest?.fixedItems ?? [],
-                    autoFixerSkipped: manifest?.leftForReview ?? [],
-                    findings: (synthesis.synthesisDisplay ?? []).map((f) => ({
-                        category: f.category,
-                        summary: f.summary,
-                        detail: f.detail,
-                        agentFixPrompt: f.agentFixPrompt ?? null,
-                        source: f.source ?? null,
-                    })),
+                return ok(await fetchPrStatePayload(input.ref));
+            }
+            if (name === 'triage_get') {
+                if (typeof input.ref !== 'string')
+                    return fail('ref required');
+                return ok(await fetchTriagePayload(input.ref));
+            }
+            if (name === 'ask_haystack') {
+                if (typeof input.ref !== 'string' || typeof input.question !== 'string')
+                    return fail('ref and question required');
+                return ok(await fetchAskPayload(input.ref, input.question, {
+                    session: typeof input.session_id === 'string' ? input.session_id : undefined,
                 }));
             }
-            if (name === 'pr_state') {
-                const ref = args?.ref;
-                if (!ref)
+            if (name === 'traces_list') {
+                if (typeof input.ref !== 'string')
                     return fail('ref required');
-                const captured = await captureStdout(async () => {
-                    await prReadCommand(ref, { json: true });
-                });
-                return ok(jsonFromCapture(captured));
+                return ok(await fetchTracesListPayload(input.ref));
+            }
+            if (name === 'traces_get') {
+                if (typeof input.ref !== 'string' || typeof input.checkpoint_id !== 'string')
+                    return fail('ref and checkpoint_id required');
+                return ok(await fetchTracesGetPayload(input.ref, input.checkpoint_id, {
+                    cursor: typeof input.cursor === 'string' ? input.cursor : undefined,
+                    limit: typeof input.limit === 'number' ? String(input.limit) : undefined,
+                }));
             }
             if (name === 'schema') {
-                const n = args?.name;
-                if (!n || !(n in SCHEMA_VERSIONS)) {
+                const schema = input.name;
+                if (!(schema in SCHEMA_VERSIONS))
                     return fail(`unknown schema; choose one of ${Object.keys(SCHEMA_VERSIONS).join(', ')}`);
-                }
-                return ok(await readSchema(n));
+                return ok(await readSchema(schema));
             }
             return fail(`unknown tool: ${name}`);
         }
-        catch (err) {
-            return fail(`tool error: ${err instanceof Error ? err.message : String(err)}`);
+        catch (error) {
+            return fail(error instanceof Error ? error.message : String(error));
         }
     });
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    // The server runs until stdin closes. Stdio MCP gives no exit signal beyond
-    // that; we don't return.
+    await server.connect(new StdioServerTransport());
 }

package/dist/commands/pr.d.ts

@@ -4,7 +4,43 @@ export interface ParsedPR {
     prNumber: number;
 }
 export declare function parsePrRef(ref: string): ParsedPR;
+interface GitHubPr {
+    number: number;
+    title: string;
+    state: 'open' | 'closed';
+    merged: boolean;
+    mergeable_state?: string;
+    head: {
+        sha: string;
+        ref: string;
+    };
+    base: {
+        ref: string;
+    };
+}
+interface MergeQueueEntry {
+    status?: string;
+    detail?: string;
+    failedChecks?: string[];
+    actionNeeded?: string;
+}
+export declare function mergePublicState(meta: GitHubPr, entry: MergeQueueEntry | undefined, queueAvailable?: boolean): {
+    status: string;
+    reason: string;
+    blocking_checks: string[];
+    action: string | null;
+};
+export declare function fetchMergePublicState(meta: GitHubPr, prNumber: number, owner: string, repo: string, token: string): Promise<{
+    status: string;
+    reason: string;
+    blocking_checks: string[];
+    action: string | null;
+}>;
 export interface PrReadOptions {
     json?: boolean;
 }
-export declare function prReadCommand(ref: string, opts: PrReadOptions): Promise<void>;
+export declare function fetchPrStatePayload(ref: string): Promise<Record<string, unknown> & {
+    schema_version: string;
+}>;
+export declare function prReadCommand(ref: string, options: PrReadOptions): Promise<void>;
+export {};