@haystackeditor/cli 0.15.10 → 0.15.11

package/dist/commands/mcp.d.ts

@@ -0,0 +1 @@
+export declare function runMcpServer(): Promise<void>;

package/dist/commands/mcp.js

@@ -0,0 +1,185 @@
+/**
+ * `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 { 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 { loadToken } from '../utils/auth.js';
+import { SCHEMA_VERSIONS, withSchema } from '../schema.js';
+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`.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: {
+                    type: 'string',
+                    description: 'PR reference: bare number, owner/repo#number, or GitHub URL.',
+                },
+            },
+            required: ['ref'],
+        },
+    },
+    {
+        name: 'pr_state',
+        description: 'Show the Haystack state of a single PR: bucket, last triage rating, merge state.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'PR reference.' },
+            },
+            required: ['ref'],
+        },
+    },
+    {
+        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.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    enum: Object.keys(SCHEMA_VERSIONS),
+                    description: 'Schema noun.',
+                },
+            },
+            required: ['name'],
+        },
+    },
+];
+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) };
+    }
+}
+export async function runMcpServer() {
+    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 }],
+        });
+        try {
+            if (name === 'triage_pr') {
+                const ref = args?.ref;
+                if (!ref)
+                    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,
+                    })),
+                }));
+            }
+            if (name === 'pr_state') {
+                const ref = args?.ref;
+                if (!ref)
+                    return fail('ref required');
+                const captured = await captureStdout(async () => {
+                    await prReadCommand(ref, { json: true });
+                });
+                return ok(jsonFromCapture(captured));
+            }
+            if (name === 'schema') {
+                const n = args?.name;
+                if (!n || !(n in SCHEMA_VERSIONS)) {
+                    return fail(`unknown schema; choose one of ${Object.keys(SCHEMA_VERSIONS).join(', ')}`);
+                }
+                return ok(await readSchema(n));
+            }
+            return fail(`unknown tool: ${name}`);
+        }
+        catch (err) {
+            return fail(`tool error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    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.
+}

package/dist/commands/pr.d.ts

@@ -0,0 +1,10 @@
+export interface ParsedPR {
+    owner: string;
+    repo: string;
+    prNumber: number;
+}
+export declare function parsePrRef(ref: string): ParsedPR;
+export interface PrReadOptions {
+    json?: boolean;
+}
+export declare function prReadCommand(ref: string, opts: PrReadOptions): Promise<void>;

package/dist/commands/pr.js

@@ -0,0 +1,103 @@
+/**
+ * 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 { parseRemoteUrl } from '../utils/git.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) };
+    const qualifiedMatch = ref.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+    if (qualifiedMatch)
+        return { owner: qualifiedMatch[1], repo: qualifiedMatch[2], prNumber: 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) };
+    }
+    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)}`);
+    }
+    return res.json();
+}
+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);
+    }
+    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';
+    }
+    const payload = {
+        owner: pr.owner,
+        repo: pr.repo,
+        prNumber: pr.prNumber,
+        bucket,
+        state: meta.merged ? 'merged' : meta.state,
+        title: meta.title,
+        headSha: meta.head.sha,
+        haystackUrl: `https://haystackeditor.com/review/${pr.owner}/${pr.repo}/${pr.prNumber}`,
+        mergeQueue: null,
+        lastTriage: synthesis?.haystackRating != null
+            ? {
+                rating: synthesis.haystackRating,
+                completedAt: new Date().toISOString(),
+                headSha: meta.head.sha,
+            }
+            : null,
+    };
+    if (opts.json) {
+        console.log(JSON.stringify(withSchema('pr', payload), null, 2));
+        return;
+    }
+    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}`);
+    }
+    console.log(`  ${chalk.dim(payload.haystackUrl)}\n`);
+}

package/dist/commands/rules.d.ts

@@ -0,0 +1,4 @@
+export declare function editRulesCommand(): Promise<void>;
+export declare function validateRulesCommand(opts?: {
+    silent?: boolean;
+}): Promise<void>;

package/dist/commands/rules.js

@@ -0,0 +1,98 @@
+/**
+ * `haystack rules edit|validate` — manage .haystack/pr-rules.yml.
+ *
+ * Why local, not server-round-trip:
+ *   pr-rules.yml is the source of truth, checked into the repo. The CLI's job
+ *   is to make it ergonomic to edit (open in $EDITOR) and to fail loudly if
+ *   the file would break the server-side parser (`packages/custom-rules`).
+ *   The same parser is used here so "validate passes locally" == "won't
+ *   break the next PR analysis."
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { resolve, dirname } from 'node:path';
+import chalk from 'chalk';
+const RULES_PATH = '.haystack/pr-rules.yml';
+const STARTER_YAML = `version: 1
+
+rules:
+  # Replace with your own rules. Each rule is either type: llm (judged by an
+  # LLM) or type: deterministic (regex / structural). See
+  # packages/custom-rules/README.md for the full schema.
+  - id: EXAMPLE001
+    name: Example rule
+    type: llm
+    severity: info
+    message: Replace this rule with one that matters to your team
+    llm:
+      prompt: >
+        This is a placeholder. Edit .haystack/pr-rules.yml and remove this rule.
+`;
+function rulesAbsPath() {
+    return resolve(process.cwd(), RULES_PATH);
+}
+export async function editRulesCommand() {
+    const path = rulesAbsPath();
+    if (!existsSync(path)) {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, STARTER_YAML, 'utf8');
+        console.log(chalk.dim(`Created ${RULES_PATH} with a starter rule.`));
+    }
+    const editor = process.env.VISUAL ?? process.env.EDITOR;
+    if (!editor) {
+        console.error(chalk.red('No $EDITOR or $VISUAL set.') +
+            `\nOpen ${chalk.bold(RULES_PATH)} manually, then run ` +
+            chalk.bold('haystack rules validate') + ' to check it.');
+        process.exit(2);
+    }
+    const before = statSync(path).mtimeMs;
+    const result = spawnSync(editor, [path], { stdio: 'inherit' });
+    if (result.status !== 0) {
+        console.error(chalk.red(`Editor exited with status ${result.status}.`));
+        process.exit(result.status ?? 1);
+    }
+    const after = statSync(path).mtimeMs;
+    if (after === before) {
+        console.log(chalk.dim('No changes.'));
+        return;
+    }
+    console.log(chalk.dim('Validating…'));
+    await validateRulesCommand({ silent: false });
+}
+export async function validateRulesCommand(opts = {}) {
+    const path = rulesAbsPath();
+    if (!existsSync(path)) {
+        console.error(chalk.red(`${RULES_PATH} not found.`));
+        console.error(`Run ${chalk.bold('haystack rules edit')} to create one.`);
+        process.exit(1);
+    }
+    const raw = readFileSync(path, 'utf8');
+    // Use the canonical parser. Importing dynamically keeps the CLI's hot path
+    // free of haystack-custom-rules unless this subcommand is actually run.
+    let parser = null;
+    try {
+        parser = (await import('haystack-custom-rules'));
+    }
+    catch (err) {
+        console.error(chalk.red('Could not load the rules parser (haystack-custom-rules).'), err instanceof Error ? err.message : err);
+        console.error(chalk.dim('The CLI uses the same parser as the server. If this failed, the workspace install is incomplete — run `pnpm install` from the repo root.'));
+        process.exit(1);
+    }
+    try {
+        const cfg = parser.parseRulesYaml(raw);
+        const ruleCount = cfg.rules?.length ?? 0;
+        if (!opts.silent) {
+            console.log(chalk.green(`✓ ${RULES_PATH} is valid (${ruleCount} rule${ruleCount === 1 ? '' : 's'}).`));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ ${RULES_PATH} is invalid:`));
+        if (err && typeof err === 'object' && 'message' in err) {
+            console.error(`  ${err.message}`);
+        }
+        else {
+            console.error('  ' + String(err));
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/schema-cmd.d.ts

@@ -0,0 +1,2 @@
+export declare function schemaCommand(name: string): void;
+export declare function listSchemas(): void;

package/dist/commands/schema-cmd.js

@@ -0,0 +1,41 @@
+/**
+ * `haystack schema <command>` — print the committed JSON Schema for the
+ * machine-readable `--json` output of a given command.
+ *
+ * Schemas live in packages/haystack-cli/schemas/<name>.v<major>.json and ship
+ * with the npm package. A CI guard fails if the schema_version in code drifts
+ * from the committed schema without a version bump.
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import chalk from 'chalk';
+import { SCHEMA_VERSIONS } from '../schema.js';
+// Derive valid schema names from the registry so adding a new schema only
+// requires editing SCHEMA_VERSIONS (PR008 — single source of truth).
+const VALID = Object.keys(SCHEMA_VERSIONS);
+export function schemaCommand(name) {
+    if (!VALID.includes(name)) {
+        console.error(chalk.red(`Unknown schema: "${name}".`) +
+            `\n\nAvailable: ${VALID.join(', ')}`);
+        process.exit(2);
+    }
+    const major = SCHEMA_VERSIONS[name].split('.')[0];
+    // dist/commands/schema-cmd.js → ../../schemas/<name>.v<major>.json
+    const schemaPath = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'schemas', `${name}.v${major}.json`);
+    try {
+        process.stdout.write(readFileSync(schemaPath, 'utf8'));
+    }
+    catch (err) {
+        console.error(chalk.red(`Could not read schema at ${schemaPath}:`), err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+}
+export function listSchemas() {
+    console.log(chalk.bold('Available --json schemas:\n'));
+    for (const name of VALID) {
+        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')}`);
+}

package/dist/commands/setup.js

@@ -344,6 +344,53 @@ async function addBootstrapLabels(owner, repo, prNumber, prUrl, token, autoMerge
         `Add these labels to the PR manually so Haystack picks it up: ${labels.join(', ')}. ` +
         `Don't re-run \`haystack setup\` — that opens a duplicate PR.`);
 }
+/**
+ * Assign the onboarding actor (the human running `haystack setup`) to the
+ * bootstrap PR.
+ *
+ * Load-bearing for backfill parity with the web wizard
+ * (src/features/onboarding/services/onboardingApi.ts → assignAuthorToPr): when
+ * the bootstrap PR merges, the webhook handler's
+ * `_extract_onboarding_backfill_actor` figures out whose existing open PRs to
+ * analyze by reading the merged PR's assignees. The PR is authored by
+ * haystack[bot] (excluded as a bot) and carries no actor marker, so WITHOUT an
+ * assignee the actor can't be determined and the backfill is silently skipped
+ * (`[ONBOARDING_BACKFILL] Could not determine onboarding actor`) — leaving a
+ * freshly-onboarded user's pre-existing PRs un-analyzed. The web wizard assigns
+ * the user; the CLI must do the same.
+ *
+ * Best-effort: the PR is already open + labeled (which is what gates onboarding
+ * completion), so a failed assignment must not fail setup. Tracked so we notice
+ * if it starts failing systemically (e.g. after a GitHub App permission
+ * narrowing).
+ */
+async function assignActorToPr(owner, repo, prNumber, login, token) {
+    if (!login) {
+        trackError('haystack_setup_assign_actor_no_login', { repo: `${owner}/${repo}`, pr_number: prNumber });
+        return;
+    }
+    try {
+        const res = await fetch(`${GITHUB_PROXY}/repos/${owner}/${repo}/issues/${prNumber}/assignees`, {
+            method: 'POST',
+            headers: ghHeaders(token),
+            body: JSON.stringify({ assignees: [login] }),
+        });
+        if (!res.ok) {
+            trackError('haystack_setup_assign_actor_failed', {
+                repo: `${owner}/${repo}`,
+                pr_number: prNumber,
+                status: res.status,
+            });
+        }
+    }
+    catch (err) {
+        trackError('haystack_setup_assign_actor_failed', {
+            repo: `${owner}/${repo}`,
+            pr_number: prNumber,
+            error_message: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
 /**
  * Protected-branch fallback: build ONE commit containing ALL the onboarding
  * files (`configFiles` + `.entire/settings.json`) via the Git Data API, CREATE
@@ -358,7 +405,7 @@ async function addBootstrapLabels(owner, repo, prNumber, prUrl, token, autoMerge
  * trace capture intent-drift triage runs on) must land in the single commit the
  * branch is created at. Mirrors the web wizard's PR-fallback path.
  */
-async function openBootstrapConfigPR(owner, repo, configFiles, token, defaultBranch, autoMergeEnabled) {
+async function openBootstrapConfigPR(owner, repo, configFiles, token, defaultBranch, autoMergeEnabled, assigneeLogin) {
     const baseSha = await getBranchSha(owner, repo, defaultBranch, token);
     // Branch prefix MUST stay `haystack/onboarding-` — the worker keys off it.
     // The timestamp avoids collisions when setup is re-run.
@@ -400,6 +447,11 @@ async function openBootstrapConfigPR(owner, repo, configFiles, token, defaultBra
     const commitSha = await createCommitWithFiles(owner, repo, baseSha, files, CONFIG_COMMIT_MSG, token);
     await createBranch(owner, repo, branchName, commitSha, token);
     const pr = await createBootstrapPR(owner, repo, branchName, defaultBranch, token, autoMergeEnabled);
+    // Assign the actor BEFORE labeling. The onboarding-bootstrap backfill keys off
+    // the merged PR's assignees, and the auto-merge label can let the merge-queue
+    // cron merge this PR promptly — so the assignee must be in place first, else
+    // the merge webhook fires without it and the backfill can't attribute the run.
+    await assignActorToPr(owner, repo, pr.number, assigneeLogin, token);
     // Always apply the onboarding-bootstrap marker so the PR stays recognized in
     // the user's tabs (isOnboardingBootstrapPR); enroll for auto-merge only when
     // the repo hasn't opted out. With auto-merge off the PR is still opened, marked,
@@ -415,9 +467,9 @@ async function openBootstrapConfigPR(owner, repo, configFiles, token, defaultBra
  * Haystack" PR. The PR is enrolled for auto-merge only when the user kept
  * auto-merge on; otherwise it waits for them to review and merge it.
  */
-async function writeOnboardingFilesToRepo(owner, repo, files, autoMergeEnabled, token) {
+async function writeOnboardingFilesToRepo(owner, repo, files, autoMergeEnabled, token, assigneeLogin) {
     const defaultBranch = await getDefaultBranch(owner, repo, token);
-    const bootstrapPR = await openBootstrapConfigPR(owner, repo, files, token, defaultBranch, autoMergeEnabled);
+    const bootstrapPR = await openBootstrapConfigPR(owner, repo, files, token, defaultBranch, autoMergeEnabled, assigneeLogin);
     return { bootstrapPR };
 }
 const SCAN_POLL_INTERVAL_MS = 1500;
@@ -980,7 +1032,7 @@ function buildOnboardingFiles(result, autoMerge) {
     files.push({ path: HAYSTACK_CONFIG_PATH, content: buildHaystackConfigJson(autoMerge) });
     return files;
 }
-async function stepConfirm(byRepo, token) {
+async function stepConfirm(byRepo, token, assigneeLogin) {
     const selectedRepos = [...byRepo.keys()];
     console.log(chalk.bold('\n  Step 4: Confirm & write configuration\n'));
     // Per-repo summary of what will be written.
@@ -1025,7 +1077,7 @@ async function stepConfirm(byRepo, token) {
         const files = buildOnboardingFiles(result, autoMerge);
         try {
             ui.progress(`Opening Configure Haystack PR for ${repoFullName}...`);
-            const writeResult = await writeOnboardingFilesToRepo(owner, repo, files, autoMerge, token);
+            const writeResult = await writeOnboardingFilesToRepo(owner, repo, files, autoMerge, token, assigneeLogin);
             ui.clearProgress();
             // Onboarding always opens a PR (never a direct commit). With auto-merge on,
             // Haystack merges it once its labels are processed; with auto-merge off it
@@ -1108,8 +1160,11 @@ async function runSetupFlow(options) {
     const byRepo = await stepScanRepos(selectedRepos, token);
     // Step 3: Review (toggle items off)
     await stepReview(byRepo);
-    // Step 4: Confirm & write the config files
-    const { confirmed, bootstrapPRs } = await stepConfirm(byRepo, token);
+    // Step 4: Confirm & write the config files. Pass the authenticated user's
+    // login so each bootstrap PR is assigned to them — the onboarding-bootstrap
+    // backfill keys off the merged PR's assignees to decide whose existing open
+    // PRs to analyze (parity with the web wizard).
+    const { confirmed, bootstrapPRs } = await stepConfirm(byRepo, token, user.login);
     if (!confirmed) {
         ui.result({ status: 'cancelled' });
         return;

package/dist/commands/submit.js

@@ -548,15 +548,26 @@ export async function submitCommand(options) {
                 console.log(chalk.bold('  Haystack Analysis Results'));
                 console.log(chalk.bold('━'.repeat(50) + '\n'));
                 if (verdict.state === 'good-to-merge') {
+                    // autoMerged here is the GH "merged: true" bit (not the
+                    // analysis's canAutoMerge eligibility). Only claim the PR was
+                    // merged when GitHub confirms it.
                     if (verdict.autoMerged) {
-                        console.log(chalk.green.bold('  ✓ Auto-merged\n'));
-                        console.log(chalk.dim('  No issues found. PR was automatically merged.'));
+                        console.log(chalk.green.bold('  ✓ Merged\n'));
+                        console.log(chalk.dim('  No blocking issues. PR is merged on GitHub.'));
                     }
                     else {
                         console.log(chalk.green.bold('  ✓ Good to merge\n'));
                         console.log(chalk.dim(`  ${verdict.summary}`));
                     }
                 }
+                else if (verdict.needsHumanReview) {
+                    // Distinct from generic needs-input: analysis is clean but
+                    // policy/sensitivity demands a human. Don't lump this in with
+                    // "issues found" — the user's action is "request a reviewer",
+                    // not "fix bugs".
+                    console.log(chalk.cyan.bold('  👤 Human review required\n'));
+                    console.log(chalk.dim(`  ${verdict.summary}`));
+                }
                 else if (options.autoFix) {
                     // Auto-fix flow: agent fixes straightforward issues in the background.
                     // Issues appear in Feed immediately — user can review while agent works.

package/dist/commands/tokens.d.ts

@@ -0,0 +1,14 @@
+export interface HeadlessLoginOptions {
+    label?: string;
+    scope?: string[];
+    /** Skip the browser handshake and accept a pre-minted token directly.
+     *  Useful for CI bootstrap (a one-time admin mints a token, stores it in
+     *  the CI secret store, and the CI job pastes it via this flag). */
+    token?: string;
+}
+export declare function headlessLoginCommand(opts: HeadlessLoginOptions): Promise<void>;
+export declare function headlessLogoutCommand(): Promise<void>;
+export declare function listTokensCommand(opts: {
+    json?: boolean;
+}): Promise<void>;
+export declare function revokeTokenCommand(id: string): Promise<void>;