@haystackeditor/cli 0.14.5 → 0.15.0

package/dist/commands/setup.d.ts

@@ -11,4 +11,19 @@
  * 7. Confirm & write .haystack.json to selected repos
  * 8. Install session tracking (Entire CLI + .entire/settings.json + local hooks)
  */
-export declare function setupCommand(): Promise<void>;
+/**
+ * Flags accepted by `haystack setup`. With none, it runs the interactive TTY
+ * wizard. `--json` switches to the coding-agent protocol (NDJSON on stdout,
+ * answers on stdin). Any pre-supplied answer (a flag or --answers entry) skips
+ * the matching prompt, so the same flow runs fully autonomously when every
+ * decision is known up-front.
+ */
+export interface SetupOptions {
+    json?: boolean;
+    repos?: string[];
+    yes?: boolean;
+    autoMerge?: boolean;
+    skipEntire?: boolean;
+    answersFile?: string;
+}
+export declare function setupCommand(options?: SetupOptions): Promise<void>;

package/dist/commands/setup.js

@@ -12,7 +12,6 @@
  * 8. Install session tracking (Entire CLI + .entire/settings.json + local hooks)
  */
 import chalk from 'chalk';
-import inquirer from 'inquirer';
 import { execFileSync, execSync } from 'child_process';
 import { mkdirSync } from 'fs';
 import { basename, join } from 'path';
@@ -20,6 +19,41 @@ import { resolveAuthContext } from '../utils/auth.js';
 import { hooksInstall } from './hooks.js';
 import { findGitRoot } from '../utils/hooks.js';
 import { trackError, trackSetupEvent } from '../utils/telemetry.js';
+import { createPrompter, loadAnswersFile } from '../utils/prompter.js';
+/** The active prompter for this `setup` invocation (TTY or JSON). */
+let ui;
+/**
+ * Translate CLI flags into a pre-supplied answer map keyed by question id.
+ * Explicit flags win; `--answers` fills the rest. Anything still missing is
+ * asked at runtime (TTY prompt or JSON `question` event).
+ */
+function buildAnswerMap(options) {
+    const answers = options.answersFile ? loadAnswersFile(options.answersFile) : {};
+    if (options.repos && options.repos.length > 0)
+        answers.select_repos = options.repos;
+    if (typeof options.autoMerge === 'boolean')
+        answers.auto_merge = options.autoMerge;
+    if (options.skipEntire) {
+        answers.install_entire = false;
+        answers.upgrade_entire = false;
+        answers.install_hooks = false;
+    }
+    if (options.yes) {
+        // Accept defaults non-interactively: don't open the toggle UI (keep every
+        // discovered item) and confirm the write. Only fill ids not already set.
+        if (!('want_to_toggle' in answers))
+            answers.want_to_toggle = false;
+        if (!('confirm_write' in answers))
+            answers.confirm_write = true;
+        if (!('auto_merge' in answers))
+            answers.auto_merge = true;
+        if (!('install_entire' in answers))
+            answers.install_entire = false;
+        if (!('install_hooks' in answers))
+            answers.install_hooks = false;
+    }
+    return answers;
+}
 // =============================================================================
 // Constants
 // =============================================================================
@@ -310,12 +344,16 @@ async function buildEntireSettingsContent(repoFullName, token) {
         return null;
     return { content: updatedContent, existingSha };
 }
-async function addBootstrapLabels(owner, repo, prNumber, prUrl, token) {
-    // CRITICAL, not best-effort: without BOTH labels the worker's bootstrap
-    // merge path never discovers the PR and it sits open forever. The label
-    // API failing is almost always transient, so retry a few times before
-    // giving up.
-    const labels = [AUTO_MERGE_LABEL, ONBOARDING_BOOTSTRAP_LABEL];
+async function addBootstrapLabels(owner, repo, prNumber, prUrl, token, autoMerge) {
+    // CRITICAL, not best-effort. ONBOARDING_BOOTSTRAP_LABEL is the identity marker
+    // that keeps the PR recognized in the user's Analyzing / Good to Merge tabs
+    // (isOnboardingBootstrapPR) and lets the worker's bootstrap path discover it —
+    // so it's ALWAYS applied. AUTO_MERGE_LABEL enrolls the PR for auto-merge, so add
+    // it only when auto-merge is on. The label API failing is almost always
+    // transient, so retry a few times before giving up.
+    const labels = autoMerge
+        ? [ONBOARDING_BOOTSTRAP_LABEL, AUTO_MERGE_LABEL]
+        : [ONBOARDING_BOOTSTRAP_LABEL];
     let lastErr = '';
     for (let attempt = 1; attempt <= 3; attempt++) {
         const res = await fetch(`${GITHUB_PROXY}/repos/${owner}/${repo}/issues/${prNumber}/labels`, {
@@ -444,14 +482,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);
-    // Only enroll the PR for auto-merge when the repo hasn't opted out. Applying
-    // the labels on an auto-merge-disabled repo would force-merge a config PR the
-    // user wants to review themselves (e.g. a repo set auto-merge-off via the web
-    // wizard, then re-run through `haystack setup`). Without labels the worker
-    // never picks it up; the PR is still opened and analyzed, it just waits.
-    if (autoMergeEnabled) {
-        await addBootstrapLabels(owner, repo, pr.number, pr.html_url, 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,
+    // and analyzed — it just waits for the user to merge it.
+    await addBootstrapLabels(owner, repo, pr.number, pr.html_url, token, autoMergeEnabled);
     return { prUrl: pr.html_url, entireSettingsBundled };
 }
 /**
@@ -551,7 +586,7 @@ async function runUnifiedScan(repo, token) {
         }
         if (statusResp.status === 404) {
             // State expired (TTL) or runId never registered — surface, don't hang.
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             throw new Error('Scan state expired — please retry.');
         }
         if (!statusResp.ok) {
@@ -570,14 +605,11 @@ async function runUnifiedScan(repo, token) {
             const key = `${state.progress.message}|${state.progress.detail ?? ''}`;
             if (key !== lastProgressKey) {
                 lastProgressKey = key;
-                process.stdout.write(`\r${chalk.dim('  ' + state.progress.message)}`);
-                if (state.progress.detail)
-                    process.stdout.write(chalk.dim(` — ${state.progress.detail}`));
-                process.stdout.write('\x1b[K');
+                ui.progress(state.progress.message, state.progress.detail);
             }
         }
         if (state.status === 'done') {
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             if (!state.result)
                 throw new Error('Scan completed but returned no result.');
             return {
@@ -587,11 +619,11 @@ async function runUnifiedScan(repo, token) {
             };
         }
         if (state.status === 'error') {
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             throw new Error(state.error || 'Scan failed');
         }
         if (state.status === 'running' && Date.now() - state.updatedAt > SCAN_STALE_MS) {
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             throw new Error('Scan stalled (no progress) — please retry.');
         }
     }
@@ -641,26 +673,33 @@ class InstallationsAuthError extends Error {
     }
 }
 async function fetchHaystackInstallations(token) {
-    // /user/installations lists App installations the OAuth-authenticated user
-    // can manage. Returns 200 with `installations: []` when none exist.
-    const res = await fetch(`${GITHUB_API}/user/installations?per_page=100`, {
+    // Detect the Haystack App via the auth-worker, NOT GitHub's
+    // `GET /user/installations`. That GitHub endpoint requires a GitHub App
+    // user-to-server token; the CLI's `haystack login` token is a classic OAuth
+    // token, so GitHub answers 403 ("must authenticate with an access token
+    // authorized to a GitHub App") — which made step 0 falsely report the App as
+    // uninstalled and exit. The auth-worker resolves installations server-side
+    // with the App's own JWT, so it works with the CLI's token. Every entry it
+    // returns IS a Haystack installation (the worker only knows about this App),
+    // so there's no app_slug to filter on.
+    const res = await fetch(`${HAYSTACK_API}/api/github/user-installations`, {
         headers: {
             Authorization: `Bearer ${token}`,
-            Accept: 'application/vnd.github.v3+json',
+            Accept: 'application/json',
             'User-Agent': 'Haystack-CLI',
         },
     });
     if (!res.ok) {
-        // 401/403 are auth-bucket failures — token revoked, expired, or missing
-        // the right scopes. Retrying never recovers; bail with a distinct error
-        // type so the poll loop can short-circuit and prompt re-auth.
+        // 401/403 here are genuine auth failures (the token the worker validates is
+        // bad), unlike the GitHub endpoint's spurious 403. Retrying won't recover;
+        // bail with a distinct error type so the poll loop can prompt re-auth.
         if (res.status === 401 || res.status === 403) {
             throw new InstallationsAuthError(res.status, `${res.status} ${await res.text()}`);
         }
         throw new Error(`failed to fetch installations: ${res.status} ${await res.text()}`);
     }
     const data = (await res.json());
-    return (data.installations ?? []).filter((i) => i.app_slug === HAYSTACK_APP_SLUG);
+    return data.installations ?? [];
 }
 function tryOpenBrowser(url) {
     // Best-effort browser open. Never blocks setup — the URL is also printed.
@@ -687,16 +726,24 @@ function tryOpenBrowser(url) {
         return false;
     }
 }
+/** True if the App is installed; tolerates transient errors (returns false so
+ *  the poll keeps waiting) but rethrows a genuine auth failure so the caller can
+ *  bail and prompt re-auth. */
+async function isAppInstalled(token) {
+    return (await fetchHaystackInstallations(token)).length > 0;
+}
 async function stepEnsureAppInstalled(token) {
     console.log(chalk.bold('  Step 0: Verify GitHub App'));
-    let installed;
+    // Initial check — distinguish a genuine auth failure (bail, prompt re-auth)
+    // from a transient probe error (refuse-to-fail and proceed).
     try {
-        installed = await fetchHaystackInstallations(token);
+        if (await isAppInstalled(token)) {
+            console.log(chalk.green('  ✓ Haystack App installed\n'));
+            return;
+        }
     }
     catch (err) {
         if (err instanceof InstallationsAuthError) {
-            // Token is dead — retrying won't help. Prompt re-auth and exit so the
-            // user doesn't waste a 10-minute poll on something that will never work.
             console.log(chalk.yellow(`\n  Your GitHub token is no longer valid (${err.status}).`));
             console.log(chalk.dim('  Run `haystack login` to re-authenticate, then re-run `haystack setup`.\n'));
             trackError('haystack_setup_installations_auth_failure', { status: err.status });
@@ -704,81 +751,47 @@ async function stepEnsureAppInstalled(token) {
         }
         console.log(chalk.yellow(`  Could not check App installations: ${err.message}`));
         console.log(chalk.dim(`  Continuing — install manually at ${HAYSTACK_APP_INSTALL_URL} if not yet installed.\n`));
-        // Probe failed but we proceed (refuse-to-fail UX so a transient blip can't
-        // brick setup). Still log so we can see if probes start failing
-        // systemically across users.
-        trackError('haystack_setup_installations_probe_failed', {
-            error_message: err.message,
-        });
-        return;
-    }
-    if (installed.length > 0) {
-        const accounts = installed.map((i) => i.account?.login).filter(Boolean).join(', ');
-        console.log(chalk.green(`  ✓ Haystack App installed${accounts ? ` (${accounts})` : ''}\n`));
+        trackError('haystack_setup_installations_probe_failed', { error_message: err.message });
         return;
     }
     console.log(chalk.yellow('  The Haystack GitHub App is not installed yet.'));
-    console.log(chalk.dim('  Without it, Haystack can\'t analyze, triage, or merge your PRs.'));
-    console.log('');
-    console.log(`  Install at: ${chalk.cyan(HAYSTACK_APP_INSTALL_URL)}`);
-    const opened = tryOpenBrowser(HAYSTACK_APP_INSTALL_URL);
-    if (opened) {
-        console.log(chalk.dim('  (Opened in your browser. Pick the repos to grant access.)'));
+    console.log(chalk.dim("  Without it, Haystack can't analyze, triage, or merge your PRs."));
+    // Only auto-open a browser for a local interactive user. Under a coding agent
+    // (JSON mode) the `action` event carries the URL for the agent to relay.
+    if (ui.interactive) {
+        const opened = tryOpenBrowser(HAYSTACK_APP_INSTALL_URL);
+        if (opened)
+            console.log(chalk.dim('  (Opened in your browser. Pick the repos to grant access.)'));
+    }
+    // ui.action emits an `action` event (JSON) or prints + spins (TTY), then polls
+    // until the App is detected or it times out. A mid-poll auth failure surfaces
+    // as a thrown InstallationsAuthError.
+    let installed = false;
+    try {
+        installed = await ui.action({
+            id: 'install_app',
+            message: 'Install the Haystack GitHub App, then it is detected automatically.',
+            url: HAYSTACK_APP_INSTALL_URL,
+            check: () => isAppInstalled(token),
+            pollIntervalMs: APP_INSTALL_POLL_INTERVAL_MS,
+            timeoutMs: APP_INSTALL_TIMEOUT_MS,
+        });
     }
-    console.log('');
-    console.log(chalk.dim('  Waiting for install to complete...'));
-    const startedAt = Date.now();
-    let consecutiveFailures = 0;
-    let lastError = null;
-    while (Date.now() - startedAt < APP_INSTALL_TIMEOUT_MS) {
-        await new Promise((resolve) => setTimeout(resolve, APP_INSTALL_POLL_INTERVAL_MS));
-        let current;
-        try {
-            current = await fetchHaystackInstallations(token);
-            consecutiveFailures = 0;
-            lastError = null;
-        }
-        catch (err) {
-            // Auth errors during the poll loop mean the token went bad mid-flow
-            // (e.g. user revoked it from GitHub settings). Same response as the
-            // initial check — bail with re-auth guidance instead of grinding for
-            // 10 minutes against a permanent failure.
-            if (err instanceof InstallationsAuthError) {
-                console.log(chalk.yellow(`\n  Your GitHub token became invalid (${err.status}) while waiting.`));
-                console.log(chalk.dim('  Run `haystack login` to re-authenticate, then re-run `haystack setup`.\n'));
-                trackError('haystack_setup_installations_auth_failure', { status: err.status, during: 'poll' });
-                process.exit(1);
-            }
-            // Per-tick failures are usually transient (token refresh race, brief
-            // GitHub API blip). Log the first one quietly so the user sees we're
-            // not silently spinning, but don't spam the terminal every 3s.
-            consecutiveFailures += 1;
-            lastError = err instanceof Error ? err.message : String(err);
-            if (consecutiveFailures === 1) {
-                console.log(chalk.dim(`  (Transient error checking installations: ${lastError} — retrying...)`));
-            }
-            continue;
-        }
-        if (current.length > 0) {
-            const accounts = current.map((i) => i.account?.login).filter(Boolean).join(', ');
-            console.log(chalk.green(`\n  ✓ App installed${accounts ? ` (${accounts})` : ''}\n`));
-            return;
+    catch (err) {
+        if (err instanceof InstallationsAuthError) {
+            console.log(chalk.yellow(`\n  Your GitHub token became invalid (${err.status}) while waiting.`));
+            console.log(chalk.dim('  Run `haystack login` to re-authenticate, then re-run `haystack setup`.\n'));
+            trackError('haystack_setup_installations_auth_failure', { status: err.status, during: 'poll' });
+            process.exit(1);
         }
+        throw err;
     }
-    // Timeout is a real failure — emit a structured telemetry event so we can
-    // route it to ops alerting (Slack via the existing trackError → PostHog
-    // pipeline). Include whether the polling itself was failing (lastError
-    // non-null after the final tick) so we can tell "user didn't click install"
-    // apart from "GitHub API was down."
-    trackError('haystack_setup_app_install_timeout', {
-        consecutive_failures: consecutiveFailures,
-        last_error: lastError,
-        timeout_ms: APP_INSTALL_TIMEOUT_MS,
-    });
-    console.log(chalk.yellow('\n  Timed out waiting for App install.'));
-    if (lastError) {
-        console.log(chalk.dim(`  Last error checking installations: ${lastError}`));
+    if (installed) {
+        console.log(chalk.green('\n  ✓ App installed\n'));
+        return;
     }
+    trackError('haystack_setup_app_install_timeout', { timeout_ms: APP_INSTALL_TIMEOUT_MS });
+    console.log(chalk.yellow('\n  Timed out waiting for App install.'));
     console.log(chalk.dim(`  Install at ${HAYSTACK_APP_INSTALL_URL}, then re-run \`haystack setup\`.\n`));
     process.exit(1);
 }
@@ -790,22 +803,15 @@ async function stepSelectRepos(token) {
         console.log(chalk.yellow('\n  No repositories found.\n'));
         process.exit(1);
     }
-    // Clear the "Fetching" message
-    process.stdout.write('\x1b[1A\x1b[K');
-    const { selectedRepos } = await inquirer.prompt([
-        {
-            type: 'checkbox',
-            name: 'selectedRepos',
-            message: 'Select repositories to configure:',
-            choices: repos.map((r) => ({ name: r, value: r })),
-            pageSize: 15,
-            validate: (answer) => {
-                if (answer.length === 0)
-                    return 'Select at least one repository.';
-                return true;
-            },
-        },
-    ]);
+    const selectedRepos = await ui.multiselect({
+        id: 'select_repos',
+        message: 'Select repositories to configure:',
+        choices: repos.map((r) => ({ name: r, value: r })),
+    });
+    if (selectedRepos.length === 0) {
+        console.log(chalk.yellow('\n  No repositories selected.\n'));
+        process.exit(1);
+    }
     console.log(chalk.green(`  ${selectedRepos.length} repo(s) selected\n`));
     return selectedRepos;
 }
@@ -879,14 +885,11 @@ async function stepReview(byRepo) {
             result.instructions.forEach((ins, i) => printInstruction(ins, i));
         }
     }
-    const { wantToToggle } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'wantToToggle',
-            message: 'Would you like to toggle any items?',
-            default: false,
-        },
-    ]);
+    const wantToToggle = await ui.confirm({
+        id: 'want_to_toggle',
+        message: 'Would you like to toggle any items?',
+        default: false,
+    });
     if (!wantToToggle)
         return;
     // NUL separates repo / kind / id in the checkbox value so it can't collide
@@ -896,7 +899,7 @@ async function stepReview(byRepo) {
     for (const [repo, result] of byRepo) {
         if (result.rules.length + result.policies.length + result.instructions.length === 0)
             continue;
-        allItems.push(new inquirer.Separator(`── ${repo} ──`));
+        allItems.push({ separator: `── ${repo} ──` });
         result.rules.forEach((r) => {
             allItems.push({
                 name: `${r.name} ${chalk.dim(`[rule · ${CATEGORY_LABELS[r.category] || r.category}]`)}`,
@@ -919,15 +922,11 @@ async function stepReview(byRepo) {
             });
         });
     }
-    const { enabled } = await inquirer.prompt([
-        {
-            type: 'checkbox',
-            name: 'enabled',
-            message: 'Select items to enable:',
-            choices: allItems,
-            pageSize: 20,
-        },
-    ]);
+    const enabled = await ui.multiselect({
+        id: 'review_enabled_items',
+        message: 'Select items to enable:',
+        choices: allItems,
+    });
     const enabledSet = new Set(enabled);
     for (const [repo, result] of byRepo) {
         result.rules.forEach((r) => { r.enabled = enabledSet.has(`${repo}${SEP}rule${SEP}${r.id}`); });
@@ -1083,22 +1082,16 @@ async function stepConfirm(byRepo, token) {
     // + the repo-level preferences.auto_merge opt-in model). When off, the
     // bootstrap PR is opened but NOT labeled, so the user merges it manually and
     // no PRs auto-merge.
-    const { autoMerge } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'autoMerge',
-            message: 'Enable auto-merge? (Haystack merges PRs automatically once they pass review)',
-            default: true,
-        },
-    ]);
-    const { confirmed } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'confirmed',
-            message: `Write Haystack config to ${selectedRepos.length} repo(s)?`,
-            default: true,
-        },
-    ]);
+    const autoMerge = await ui.confirm({
+        id: 'auto_merge',
+        message: 'Enable auto-merge? (Haystack merges PRs automatically once they pass review)',
+        default: true,
+    });
+    const confirmed = await ui.confirm({
+        id: 'confirm_write',
+        message: `Write Haystack config to ${selectedRepos.length} repo(s)?`,
+        default: true,
+    });
     if (!confirmed) {
         console.log(chalk.yellow('\n  Setup cancelled.\n'));
         return { confirmed: false, bootstrapPRs: new Map() };
@@ -1110,9 +1103,9 @@ async function stepConfirm(byRepo, token) {
         const result = byRepo.get(repoFullName);
         const files = buildOnboardingFiles(result, autoMerge);
         try {
-            process.stdout.write(chalk.dim(`  Writing to ${repoFullName}...`));
+            ui.progress(`Writing to ${repoFullName}...`);
             const writeResult = await writeOnboardingFilesToRepo(owner, repo, files, autoMerge, token);
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             if (writeResult.bootstrapPR) {
                 // Default branch was protected — config landed in a bootstrap PR. With
                 // auto-merge on, Haystack merges it once its labels are processed; with
@@ -1130,7 +1123,7 @@ async function stepConfirm(byRepo, token) {
             }
         }
         catch (err) {
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             console.log(chalk.red(`  ✗ ${repoFullName}: ${err.message}`));
             failedRepos.push(repoFullName);
         }
@@ -1145,7 +1138,18 @@ async function stepConfirm(byRepo, token) {
 // =============================================================================
 // Main command
 // =============================================================================
-export async function setupCommand() {
+export async function setupCommand(options = {}) {
+    // Create the prompter FIRST: in JSON mode it redirects console.* to stderr so
+    // stdout carries only NDJSON, which the steps below rely on.
+    ui = createPrompter({ json: options.json, answers: buildAnswerMap(options) });
+    try {
+        await runSetupFlow(options);
+    }
+    finally {
+        ui.close();
+    }
+}
+async function runSetupFlow(options) {
     console.log(chalk.cyan('\n  Haystack Setup Wizard\n'));
     // Step 0: Check login
     let authContext;
@@ -1182,12 +1186,27 @@ export async function setupCommand() {
     await stepReview(byRepo);
     // Step 4: Confirm & write the config files
     const { confirmed, bootstrapPRs } = await stepConfirm(byRepo, token);
-    if (!confirmed)
+    if (!confirmed) {
+        ui.result({ status: 'cancelled' });
         return;
+    }
     // Step 7: Install Entire CLI (session tracking). bootstrapPRs tells it
     // which repos had a protected default branch so it can commit
     // .entire/settings.json to the same PR instead of a doomed direct PUT.
-    await stepInstallEntire(selectedRepos, token, bootstrapPRs);
+    // --skip-entire skips the whole step (binary install, hooks, AND the remote
+    // .entire/settings.json write) — not just the install prompt.
+    if (options.skipEntire) {
+        console.log(chalk.dim('  Skipping session tracking (--skip-entire).\n'));
+    }
+    else {
+        await stepInstallEntire(selectedRepos, token, bootstrapPRs);
+    }
+    // Final structured outcome for non-interactive/agent callers.
+    ui.result({
+        status: 'complete',
+        repos: selectedRepos,
+        pullRequests: [...bootstrapPRs.entries()].map(([repo, pr]) => ({ repo, url: pr.prUrl })),
+    });
 }
 // =============================================================================
 // Step 7: Install Entire CLI for session tracking
@@ -1330,14 +1349,11 @@ async function stepInstallEntire(selectedRepos, token, bootstrapPRs) {
     }
     else if (status.installed) {
         console.log(chalk.dim(`  Stock Entire CLI detected: ${status.version.split('\n')[0]}`));
-        const { upgrade } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'upgrade',
-                message: 'Upgrade to Haystack fork? (adds transcript optimization — saves GB of git storage)',
-                default: true,
-            },
-        ]);
+        const upgrade = await ui.confirm({
+            id: 'upgrade_entire',
+            message: 'Upgrade to Haystack fork? (adds transcript optimization — saves GB of git storage)',
+            default: true,
+        });
         if (upgrade) {
             binaryReady = await installEntireBinary();
         }
@@ -1346,14 +1362,11 @@ async function stepInstallEntire(selectedRepos, token, bootstrapPRs) {
         }
     }
     else {
-        const { install } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'install',
-                message: 'Install Entire CLI? (tracks AI coding sessions for analysis)',
-                default: true,
-            },
-        ]);
+        const install = await ui.confirm({
+            id: 'install_entire',
+            message: 'Install Entire CLI? (tracks AI coding sessions for analysis)',
+            default: true,
+        });
         if (install) {
             binaryReady = await installEntireBinary();
         }
@@ -1392,14 +1405,14 @@ async function stepInstallEntire(selectedRepos, token, bootstrapPRs) {
                 continue;
             }
             try {
-                process.stdout.write(chalk.dim(`  Configuring ${repoFullName}...`));
+                ui.progress(`Configuring ${repoFullName}...`);
                 await configureEntireSettingsViaAPI(repoFullName, token);
-                process.stdout.write('\r\x1b[K');
+                ui.clearProgress();
                 console.log(chalk.green(`  ✓ ${repoFullName}`));
                 configured++;
             }
             catch (err) {
-                process.stdout.write('\r\x1b[K');
+                ui.clearProgress();
                 console.log(chalk.yellow(`  ⚠ ${repoFullName}: ${err instanceof Error ? err.message : err}`));
             }
         }
@@ -1422,14 +1435,11 @@ async function stepInstallEntire(selectedRepos, token, bootstrapPRs) {
         });
         if (repoName) {
             try {
-                const { installHooks } = await inquirer.prompt([
-                    {
-                        type: 'confirm',
-                        name: 'installHooks',
-                        message: `Install git hooks locally for ${repoName}? (agent detection, truncation checking, LLM rules)`,
-                        default: true,
-                    },
-                ]);
+                const installHooks = await ui.confirm({
+                    id: 'install_hooks',
+                    message: `Install git hooks locally for ${repoName}? (agent detection, truncation checking, LLM rules)`,
+                    default: true,
+                });
                 if (installHooks) {
                     console.log('');
                     await hooksInstall({ skipEntire: true, force: true });

package/dist/index.js

@@ -74,23 +74,48 @@ CI signals, and review policies.
     .action(initCommand);
 program
     .command('setup')
-    .description('Interactive onboarding wizard — scan repos for rules, signals, and policies')
+    .description('Onboarding wizard — scan repos for rules/policies and write Haystack config')
+    .option('--json', 'Agent mode: emit NDJSON events on stdout, read answers on stdin (no TTY prompts)')
+    .option('--repo <repo...>', 'Repo(s) to configure (owner/name); skips the repo picker')
+    .option('-y, --yes', 'Accept defaults non-interactively (keep all discovered items, confirm write)')
+    // Defining --no-auto-merge also accepts --auto-merge; default is "ask" unless
+    // one is explicitly passed (detected via getOptionValueSource below).
+    .option('--no-auto-merge', 'Set auto-merge in the written config (--auto-merge / --no-auto-merge; omit to be asked)')
+    .option('--skip-entire', 'Skip the Entire CLI / git-hooks (session tracking) step')
+    .option('--answers <file>', 'JSON file of {questionId: value} pre-supplied answers')
     .addHelpText('after', `
-This walks you through Haystack setup step by step:
+Steps: verify GitHub App → select repos → scan (rules/policies/instructions) →
+review → write .haystack/pr-rules.yml + review-policy.md + .haystack.json.
 
-  1. Select GitHub repositories to configure
-  2. Scan for coding rules (conventions your team follows)
-  3. Scan for CI/bot signals (checks to wait for before merging)
-  4. Scan for review policies (who should review what)
-  5. Review and toggle discovered items
-  6. Write .haystack.json to your repos
+Three ways to run:
+  • Interactive (default): prompts in your terminal.
+  • Autonomous/CI: supply every decision via flags, e.g.
+      haystack setup --repo owner/name --yes --no-auto-merge --skip-entire
+  • Coding agent: --json speaks NDJSON on stdout and reads answers on stdin, so an
+    agent can auto-answer or relay questions to the user. Pre-supplied answers
+    (flags / --answers) skip the matching question.
 
 Requires authentication — run \`haystack login\` first.
 
 Examples:
   haystack setup
+  haystack setup --repo owner/name --yes
+  haystack setup --json --repo owner/name
 `)
-    .action(setupCommand);
+    .action((options, command) => {
+    // Tri-state auto-merge: undefined (ask) unless --auto-merge/--no-auto-merge
+    // was explicitly passed. commander defaults autoMerge to true because of the
+    // --no- form, so check the value source rather than the value.
+    const autoMergeExplicit = command.getOptionValueSource('autoMerge') === 'cli';
+    return setupCommand({
+        json: options.json,
+        repos: options.repo,
+        yes: options.yes,
+        autoMerge: autoMergeExplicit ? options.autoMerge : undefined,
+        skipEntire: options.skipEntire,
+        answersFile: options.answers,
+    });
+});
 program
     .command('status')
     .description('Check if .haystack.json exists and is valid')

package/dist/triage/prompts.js

@@ -45,7 +45,7 @@ const INTENT_DRIFT_SCHEMA = `{
       "line": 42,
       "severity": "error | warning | info",
       "message": "Description of the drift or incomplete fulfillment",
-      "pattern": "intent_drift | incomplete_fulfillment | scope_creep"
+      "pattern": "intent_drift | incomplete_fulfillment | scope_creep | unspecified_decision | ignored_correction | weakened_posture | claimed_but_not_done"
     }
   ],
   "summary": "Brief 1-sentence summary",
@@ -286,6 +286,36 @@ The agent added functionality the user never asked for:
 - User asks for one feature → agent bundles in extra features "while we're at it"
 - Any new mechanism not traceable to a user instruction
 
+### Unspecified Decision
+The user authorized the task's GOAL, but the agent made a specific decision in HOW it carried it out that shapes the program's end output, externally observable behavior, or the data end-users/callers see — and the user never specified or approved that particular decision, and a reasonable user would plausibly want a say in it. Examples (general — do NOT pattern-match on specific keywords):
+- Silently dropping, capping, sampling, or transforming data that flows to the output
+- Picking a default that determines what end-users see
+- Resolving an ambiguous requirement one way when other materially different behaviors were equally valid
+- Choosing a fixed value where the choice changes results
+Do NOT flag internal implementation choices with no observable effect (naming, file layout, helper structure), decisions forced by correctness, or cosmetic defaults a user would not care about. When unsure whether a user would care, do not flag it — reserve this for decisions with real, user-visible ramifications. The difference from scope creep: scope creep is an unrequested *flow*; an unspecified decision is an unrequested, output-shaping choice *inside a requested flow*.
+
+### Ignored Correction
+The user gave an explicit correction or redirection and the final code does NOT honor it:
+- User said "don't use a global / use X instead / that's racy, do Y" and the agent shipped the thing it was told not to
+- Agent applied the correction, then quietly reverted it in a later step
+- A general later "looks good" does NOT cancel a specific earlier correction
+This is high severity by default: the user actively steered and was overridden.
+
+### Weakened Posture
+In service of an authorized goal, the agent relaxed or removed a security, safety, or correctness guard the user never asked to weaken:
+- Loosened an auth/permission/validation check, or broadened access (CORS, scopes)
+- Swallowed or silenced an error, removed an assertion/guard, hardcoded a bypass or credential
+- Disabled a test (.skip / xit), suppressed a type or lint check (any, @ts-ignore, disable comments)
+- Lowered a threshold/timeout that existed as a safeguard
+High severity by default. (If the user explicitly asked to remove the guard, it is not a finding.)
+
+### Claimed But Not Done
+The agent told the user it completed work that the diff does not actually contain, or contains only in a materially weaker form:
+- "I added error handling for timeouts" but no timeout handling exists in the diff
+- "Added tests for the edge case" but no test assertions exercise it
+- "Made the limit configurable" but the value is still hardcoded
+Compare each concrete claim the agent made to the user against what the diff actually shows. Only flag when the diff clearly contradicts or fails to support the claim; when unsure, do not flag.
+
 ## Red flags to search for in the diff
 
 - Fixed/hardcoded values where dynamic behavior was requested
@@ -293,6 +323,7 @@ The agent added functionality the user never asked for:
 - Empty function bodies or early returns
 - Interface fields that are declared but never assigned anywhere
 - New mechanisms (cooldowns, retries, caches, rate limits) not requested by the user
+- Decisions that drop, limit, or reshape data flowing to the output, or pick a default that changes what end-users see, with no instruction specifying it
 
 ## Output
 
@@ -303,9 +334,9 @@ ${INTENT_DRIFT_SCHEMA}
 \`\`\`
 
 - Set \`sessionsChecked\` to the number of trace files you read
-- Set \`passed\` to \`true\` if no drift, incomplete fulfillment, or scope creep found
-- Set \`passed\` to \`false\` if any issues with severity "error" were found
-- For each issue, set \`pattern\` to "intent_drift", "incomplete_fulfillment", or "scope_creep"
+- Set \`passed\` to \`true\` only when no intent-drift issues are found
+- Set \`passed\` to \`false\` when any issue is found (any pattern, any severity)
+- For each issue, set \`pattern\` to one of: "intent_drift", "incomplete_fulfillment", "scope_creep", "unspecified_decision", "ignored_correction", "weakened_posture", "claimed_but_not_done"
 - You MUST write the result file even if no issues are found
 
 ## Severity guidelines

package/dist/triage/types.d.ts

@@ -13,7 +13,7 @@ export interface TriageIssue {
     /** For rules validator: rule ID (e.g., PR001) */
     rule?: string;
     /** For intent drift: drift pattern */
-    pattern?: 'intent_drift' | 'incomplete_fulfillment' | 'scope_creep';
+    pattern?: 'intent_drift' | 'incomplete_fulfillment' | 'scope_creep' | 'unspecified_decision' | 'ignored_correction' | 'weakened_posture' | 'claimed_but_not_done';
 }
 export interface CodeReviewResult {
     checker: 'code-review';

package/dist/utils/prompter.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Prompter — decouples a wizard's *decisions* from *how they're answered*.
+ *
+ * `haystack setup` historically welded every decision to inquirer/TTY, so it
+ * couldn't run headless, in CI, or under a coding agent. The Prompter is the
+ * seam: step code calls `confirm` / `multiselect` / `action`, and the
+ * implementation decides how to source the answer.
+ *
+ * Three modes, one mechanism:
+ *   - TtyPrompter  — humans in a terminal (inquirer). Default.
+ *   - JsonPrompter — a coding agent: NDJSON events on stdout, answers on stdin.
+ *                    The agent can relay a `question` to the user OR auto-answer.
+ *   - Pre-supplied answers (flags / --answers file) short-circuit any question
+ *     by id, so the same code runs fully autonomously when every answer is known.
+ *
+ * Human-facing chrome stays as `console.*`; in JSON mode the JsonPrompter
+ * redirects `console.*` to stderr so stdout carries only NDJSON.
+ */
+/** A selectable option. A `{ separator }` entry renders a non-selectable group
+ *  header in TTY mode and is ignored in JSON mode. */
+export type Choice<T> = {
+    name: string;
+    value: T;
+    checked?: boolean;
+} | {
+    separator: string;
+};
+export interface Prompter {
+    /** True for the human TTY prompter — gates side effects like opening a browser
+     *  that only make sense for a local interactive user. */
+    readonly interactive: boolean;
+    /** Yes/no decision. */
+    confirm(q: {
+        id: string;
+        message: string;
+        default?: boolean;
+    }): Promise<boolean>;
+    /** Pick zero-or-more values. Items default-checked via `checked: true`. */
+    multiselect<T>(q: {
+        id: string;
+        message: string;
+        choices: Choice<T>[];
+    }): Promise<T[]>;
+    /**
+     * An action the user must take out-of-band (e.g. install the GitHub App).
+     * Polls `check()` until it returns true (satisfied) or `timeoutMs` elapses.
+     * A pre-supplied / stdin answer of "skip" resolves false without polling.
+     * Returns true when satisfied, false when skipped or timed out.
+     */
+    action(q: {
+        id: string;
+        message: string;
+        url?: string;
+        check: () => Promise<boolean>;
+        pollIntervalMs?: number;
+        timeoutMs?: number;
+    }): Promise<boolean>;
+    /** Transient progress line (scan ticker, per-repo write status). */
+    progress(message: string, detail?: string): void;
+    /** Clear the current progress line. */
+    clearProgress(): void;
+    /** Final structured outcome (emitted as a `result` event in JSON mode). */
+    result(data: Record<string, unknown>): void;
+    /** Release stdin/readline so the process can exit. */
+    close(): void;
+}
+/** Answers known up-front (from flags or an --answers file), keyed by question id. */
+export type AnswerMap = Record<string, unknown>;
+export declare function loadAnswersFile(path: string): AnswerMap;
+export interface PrompterOptions {
+    json?: boolean;
+    answers?: AnswerMap;
+}
+export declare function createPrompter(options?: PrompterOptions): Prompter;

package/dist/utils/prompter.js

@@ -0,0 +1,226 @@
+/**
+ * Prompter — decouples a wizard's *decisions* from *how they're answered*.
+ *
+ * `haystack setup` historically welded every decision to inquirer/TTY, so it
+ * couldn't run headless, in CI, or under a coding agent. The Prompter is the
+ * seam: step code calls `confirm` / `multiselect` / `action`, and the
+ * implementation decides how to source the answer.
+ *
+ * Three modes, one mechanism:
+ *   - TtyPrompter  — humans in a terminal (inquirer). Default.
+ *   - JsonPrompter — a coding agent: NDJSON events on stdout, answers on stdin.
+ *                    The agent can relay a `question` to the user OR auto-answer.
+ *   - Pre-supplied answers (flags / --answers file) short-circuit any question
+ *     by id, so the same code runs fully autonomously when every answer is known.
+ *
+ * Human-facing chrome stays as `console.*`; in JSON mode the JsonPrompter
+ * redirects `console.*` to stderr so stdout carries only NDJSON.
+ */
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import * as readline from 'node:readline';
+import { readFileSync } from 'node:fs';
+function isSeparator(c) {
+    return c.separator !== undefined;
+}
+export function loadAnswersFile(path) {
+    const raw = readFileSync(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`--answers file must be a JSON object of {questionId: value}`);
+    }
+    return parsed;
+}
+// ---------------------------------------------------------------------------
+// TTY (human) prompter
+// ---------------------------------------------------------------------------
+class TtyPrompter {
+    answers;
+    interactive = true;
+    constructor(answers) {
+        this.answers = answers;
+    }
+    async confirm(q) {
+        if (q.id in this.answers)
+            return Boolean(this.answers[q.id]);
+        const { value } = await inquirer.prompt([
+            { type: 'confirm', name: 'value', message: q.message, default: q.default ?? true },
+        ]);
+        return value;
+    }
+    async multiselect(q) {
+        if (q.id in this.answers)
+            return this.answers[q.id];
+        const choices = q.choices.map((c) => isSeparator(c) ? new inquirer.Separator(c.separator) : { name: c.name, value: c.value, checked: c.checked });
+        const { value } = await inquirer.prompt([
+            { type: 'checkbox', name: 'value', message: q.message, choices: choices, pageSize: 20 },
+        ]);
+        return value;
+    }
+    async action(q) {
+        if (this.answers[q.id] === 'skip')
+            return false;
+        if (await q.check())
+            return true;
+        console.log(chalk.yellow(`  ${q.message}`));
+        if (q.url)
+            console.log(`  ${chalk.cyan(q.url)}`);
+        console.log(chalk.dim('  Waiting...'));
+        const started = Date.now();
+        const timeout = q.timeoutMs ?? 10 * 60 * 1000;
+        const interval = q.pollIntervalMs ?? 3000;
+        while (Date.now() - started < timeout) {
+            await sleep(interval);
+            if (await q.check())
+                return true;
+        }
+        return false;
+    }
+    progress(message, detail) {
+        process.stdout.write(`\r${chalk.dim('  ' + message)}${detail ? chalk.dim(' — ' + detail) : ''}\x1b[K`);
+    }
+    clearProgress() {
+        process.stdout.write('\r\x1b[K');
+    }
+    result(_data) {
+        // Human output is rendered inline by the step code; nothing structured to emit.
+    }
+    close() {
+        /* nothing to release */
+    }
+}
+// ---------------------------------------------------------------------------
+// JSON (coding-agent) prompter
+// ---------------------------------------------------------------------------
+class JsonPrompter {
+    answers;
+    interactive = false;
+    rl = null;
+    pending = new Map();
+    buffered = new Map();
+    restoreConsole = null;
+    constructor(answers) {
+        this.answers = answers;
+        // Keep stdout pure NDJSON: route human chrome to stderr.
+        const origLog = console.log;
+        const origWarn = console.warn;
+        const origError = console.error;
+        const toErr = (...args) => process.stderr.write(args.map(stringifyArg).join(' ') + '\n');
+        console.log = toErr;
+        console.warn = toErr;
+        console.error = toErr;
+        this.restoreConsole = () => {
+            console.log = origLog;
+            console.warn = origWarn;
+            console.error = origError;
+        };
+    }
+    emit(event) {
+        process.stdout.write(JSON.stringify(event) + '\n');
+    }
+    /** Lazily open stdin only when we actually need an answer the agent must send. */
+    ensureStdin() {
+        if (this.rl)
+            return;
+        this.rl = readline.createInterface({ input: process.stdin });
+        this.rl.on('line', (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            let obj;
+            try {
+                obj = JSON.parse(trimmed);
+            }
+            catch {
+                return; // ignore non-JSON noise on stdin
+            }
+            if (!obj || typeof obj.id !== 'string')
+                return;
+            const resolve = this.pending.get(obj.id);
+            if (resolve) {
+                this.pending.delete(obj.id);
+                resolve(obj.value);
+            }
+            else {
+                this.buffered.set(obj.id, obj.value);
+            }
+        });
+    }
+    awaitAnswer(id) {
+        if (this.buffered.has(id)) {
+            const v = this.buffered.get(id);
+            this.buffered.delete(id);
+            return Promise.resolve(v);
+        }
+        this.ensureStdin();
+        return new Promise((resolve) => this.pending.set(id, resolve));
+    }
+    async confirm(q) {
+        if (q.id in this.answers)
+            return Boolean(this.answers[q.id]);
+        this.emit({ type: 'question', id: q.id, kind: 'confirm', prompt: q.message, default: q.default ?? true });
+        return Boolean(await this.awaitAnswer(q.id));
+    }
+    async multiselect(q) {
+        if (q.id in this.answers)
+            return this.answers[q.id];
+        const options = q.choices
+            .filter((c) => !isSeparator(c))
+            .map((c) => ({ value: c.value, label: c.name, default: c.checked ?? false }));
+        this.emit({ type: 'question', id: q.id, kind: 'multiselect', prompt: q.message, options });
+        return (await this.awaitAnswer(q.id));
+    }
+    async action(q) {
+        if (this.answers[q.id] === 'skip')
+            return false;
+        if (await q.check())
+            return true;
+        // Tell the agent an out-of-band action is needed; then poll until satisfied.
+        // An agent may also push {"id","value":"skip"|"done"} on stdin to override.
+        this.emit({ type: 'action', id: q.id, prompt: q.message, url: q.url, poll: true });
+        const started = Date.now();
+        const timeout = q.timeoutMs ?? 10 * 60 * 1000;
+        const interval = q.pollIntervalMs ?? 3000;
+        let override = null;
+        // Resolve the moment the agent answers, OR when polling detects completion.
+        this.ensureStdin();
+        const answerPromise = this.awaitAnswer(q.id).then((v) => {
+            override = v === 'skip' ? 'skip' : 'done';
+        });
+        while (Date.now() - started < timeout) {
+            if (await q.check())
+                return true;
+            if (override === 'skip')
+                return false;
+            if (override === 'done')
+                return (await q.check()); // agent says installed; trust but verify
+            await Promise.race([sleep(interval), answerPromise]);
+        }
+        return false;
+    }
+    progress(message, detail) {
+        this.emit({ type: 'progress', message, ...(detail ? { detail } : {}) });
+    }
+    clearProgress() {
+        /* no ephemeral line in JSON mode */
+    }
+    result(data) {
+        this.emit({ type: 'result', ...data });
+    }
+    close() {
+        this.rl?.close();
+        this.rl = null;
+        this.restoreConsole?.();
+        this.restoreConsole = null;
+    }
+}
+export function createPrompter(options = {}) {
+    const answers = options.answers ?? {};
+    return options.json ? new JsonPrompter(answers) : new TtyPrompter(answers);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stringifyArg(a) {
+    return typeof a === 'string' ? a : String(a);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haystackeditor/cli",
-  "version": "0.14.5",
+  "version": "0.15.0",
   "description": "Set up Haystack for your project — automated PR review, triage, and merge queue",
   "type": "module",
   "bin": {