@gr8ful/spf 0.6.0 → 0.8.0

package/dist/cli/commands/watch.js

@@ -16,11 +16,13 @@ import { isRepoAt, makeGit } from "../../core/git_helper.js";
 import { GitHubProvider } from "../../core/issues/github_provider.js";
 import { JiraProvider } from "../../core/issues/jira_provider.js";
 import { BitbucketProvider } from "../../core/issues/bitbucket_provider.js";
+import { isAuthoringProvider } from "../../core/issues/provider.js";
 import { createWatchState, tick } from "../../core/watch.js";
 import { findChain, resolveRequiredAgents, runChain as runChainDef } from "../../chains/index.js";
 import { ReviewOutput } from "../../core/data_types.js";
 import { SfDb } from "../../ui/server/db.js";
 import { parseCli } from "../../core/utils.js";
+import { isInteractive } from "../ask.js";
 /** Kept well under Slack's own 2900-char slice on `detail` (see `slack_channel.ts`) — a reviewer can emit a lot of findings, but the PR body/notification only needs enough to tell a human whether to look closer. */
 const MAX_REVIEW_DIGEST_CHARS = 1200;
 /**
@@ -107,7 +109,7 @@ function resolveIssueProvider(cfg) {
             console.error('JIRA_EMAIL and JIRA_API_TOKEN must both be set — spf watch needs an Atlassian account email plus an API token (id.atlassian.com -> Security -> API tokens). See README.md\'s "spf watch" section.');
             return null;
         }
-        return new JiraProvider(cfg.watch.jira.base_url, cfg.watch.jira.project_key, cfg.watch.label_prefix, email, token);
+        return new JiraProvider(cfg.watch.jira.base_url, cfg.watch.jira.project_key, cfg.watch.label_prefix, email, token, cfg.watch.jira.issue_types);
     }
     console.error(`watch.issue_provider ${JSON.stringify(cfg.watch.issue_provider)} is not supported`);
     return null;
@@ -177,6 +179,14 @@ function releaseLock(lockPath) {
  * machine needs, with sensible colors/descriptions. Doesn't touch git or
  * run anything, so it skips watchCommand's repo/chain checks entirely —
  * you can seed labels before ever wiring up a worktree-capable checkout.
+ *
+ * On Jira, with `watch.refine.enabled`, this also runs a READ-ONLY check of
+ * `watch.jira.issue_types` against the real project — the same check
+ * `watchCommand`'s own startup gate runs, exposed here too so a bad mapping
+ * can be caught (and fixed) before ever starting the daemon, not just at
+ * startup time. Labels themselves stay a pure report on Jira either way
+ * (Jira labels are freeform strings with no color/description registry to
+ * seed — see `jira_provider.ts`'s module comment).
  */
 export async function watchInitCommand(argv) {
     const { options } = parseCli(argv, ["cwd", "config"], []);
@@ -193,6 +203,15 @@ export async function watchInitCommand(argv) {
         console.log(`  ~ ${name} (updated color/description)`);
     for (const name of result.unchanged)
         console.log(`  = ${name} (already correct)`);
+    if (cfg.watch.refine.enabled && cfg.watch.issue_provider === "jira" && provider instanceof JiraProvider) {
+        const checks = await provider.validateIssueTypes();
+        console.log(`\nvalidating watch.jira.issue_types against ${cfg.watch.jira.project_key}:`);
+        for (const c of checks) {
+            console.log(`  ${c.exists ? "✓" : "✗"} ${c.kind} → ${c.jiraType}${c.exists ? "" : ` — no issue type named "${c.jiraType}" in ${cfg.watch.jira.project_key}`}`);
+        }
+        if (checks.some((c) => !c.exists))
+            return 1;
+    }
     return 0;
 }
 export async function watchCommand(argv) {
@@ -215,19 +234,37 @@ export async function watchCommand(argv) {
         return 1;
     }
     if (cfg.watch.refine.enabled) {
-        if (cfg.watch.issue_provider !== "github") {
-            // Fail loudly at startup, not silently every tick: JiraProvider
-            // doesn't implement IssueAuthoringProvider yet (see its module
-            // comment) — a refine lane that can never publish would otherwise
-            // just claim every spec-ready spec and block it, forever.
+        if (cfg.watch.issue_provider !== "github" && cfg.watch.issue_provider !== "jira") {
+            // Fail loudly at startup, not silently every tick: neither provider
+            // implements IssueAuthoringProvider besides these two — a refine lane
+            // that can never publish would otherwise just claim every spec-ready
+            // spec and block it, forever.
             console.error(`watch.refine.enabled is true but watch.issue_provider is ${JSON.stringify(cfg.watch.issue_provider)} — ` +
-                `the refine lane needs "github" (issue authoring isn't implemented for Jira yet)`);
+                `the refine lane needs "github" or "jira"`);
             return 1;
         }
         if (!findChain(cfg.watch.refine.chain)) {
             console.error(`watch.refine.chain ${JSON.stringify(cfg.watch.refine.chain)} is not a registered chain — run \`spf list\` to see every chain`);
             return 1;
         }
+        // Jira's issue-type mapping is user-configured (watch.jira.issue_types)
+        // and project-specific — validated here, at startup, for the same
+        // reason findChain() is: a bad mapping should stop the daemon before
+        // it starts, not fail silently every tick once the first spec-ready
+        // spec tries to publish. Silent on success, matching this function's
+        // other startup checks; loud (and the full per-kind report) on failure.
+        if (cfg.watch.issue_provider === "jira" && provider instanceof JiraProvider) {
+            const checks = await provider.validateIssueTypes();
+            const mismatches = checks.filter((c) => !c.exists);
+            if (mismatches.length > 0) {
+                console.error(`watch.jira.issue_types has ${mismatches.length} mismatch(es) against ${cfg.watch.jira.project_key}:`);
+                for (const c of checks) {
+                    console.error(`  ${c.exists ? "✓" : "✗"} ${c.kind} → ${c.jiraType}${c.exists ? "" : ` — no issue type named "${c.jiraType}" in ${cfg.watch.jira.project_key}`}`);
+                }
+                console.error(`Fix watch.jira.issue_types, or the project's issue types, before running spf watch unattended. Run \`spf watch init\` any time to re-check.`);
+                return 1;
+            }
+        }
     }
     const dataPaths = paths.resolveDataPaths(anchor, cfg.defaults.data_dir, cfg.observability.db);
     const lockPath = path.join(dataPaths.data_dir, "watch.lock");
@@ -422,6 +459,34 @@ export async function watchCommand(argv) {
         }
         return { accepted: true, adwId: opts.adwId, detail: "", created, questions };
     };
+    // `IssueAuthoringProvider`'s read-back half — `isAuthoringProvider()` is a
+    // structural check (see `provider.ts`), so both GitHub and Jira are
+    // recognized here without an `instanceof` chain that would need editing
+    // for every future authoring-capable provider. `null` on any tracker that
+    // ISN'T authoring-capable makes `rollUp` a logged no-op there rather than
+    // a startup failure the way `watch.refine.enabled` without authoring
+    // support is above: the build lane functions fine without container
+    // roll-up, unlike refine, which cannot function without authoring at all.
+    // Not a second `resolveAuthoringProvider()` call: that helper's own config
+    // validation already ran to produce `provider` itself.
+    const authoringProvider = isAuthoringProvider(provider) ? provider : null;
+    // Only for the one dispatch a human is actually watching a terminal for —
+    // `core/watch.ts` itself is untouched; this only ever swaps `deps.log`
+    // below and reads `state.inflight`/`state.refining` sizes after each
+    // `tick()`, exactly the seam the plan called for.
+    let dashboard;
+    if (isInteractive()) {
+        const { mountWatchDashboard } = await import("../ui/watch_dashboard.js");
+        dashboard = mountWatchDashboard({
+            repo: `${cfg.watch.issue_provider}+${cfg.watch.code_host}  ${cfg.watch.repo}`,
+            labelPrefix: cfg.watch.label_prefix,
+            chain: cfg.watch.chain,
+            concurrency: cfg.watch.concurrency,
+            refineChain: cfg.watch.refine.enabled ? cfg.watch.refine.chain : undefined,
+            refineConcurrency: cfg.watch.refine.enabled ? cfg.watch.refine.concurrency : undefined,
+            dryRun: Boolean(flags["dry-run"]),
+        });
+    }
     const deps = {
         provider,
         codeHost,
@@ -440,8 +505,12 @@ export async function watchCommand(argv) {
         linkDataDir,
         dryRun: Boolean(flags["dry-run"]),
         runChain,
-        log: (message) => console.log(message),
-        notify: (event) => notifier?.send(event),
+        listChildren: authoringProvider ? (parent) => authoringProvider.listChildren(parent) : undefined,
+        log: (message) => (dashboard ? dashboard.log(message) : console.log(message)),
+        notify: (event) => {
+            notifier?.send(event); // unaffected either way — see mountWatchDashboard's own doc comment
+            dashboard?.mirrorNotify(event);
+        },
     };
     const state = createWatchState();
     let stopping = false;
@@ -465,6 +534,7 @@ export async function watchCommand(argv) {
         interrupt?.();
         sigints++;
         if (sigints >= 2) {
+            dashboard?.unmountNow(); // best-effort cursor-visibility restore before the abrupt exit — see WatchDashboard.unmountNow's own comment
             console.error("\n[spf] watch     second interrupt — exiting immediately, without draining");
             releaseLock(lockPath);
             process.exit(130);
@@ -475,9 +545,15 @@ export async function watchCommand(argv) {
     };
     process.on("SIGINT", stop);
     process.on("SIGTERM", stop);
-    console.log(`[spf] watch     ${cfg.watch.issue_provider}+${cfg.watch.code_host}  ${cfg.watch.repo}  label "${cfg.watch.label_prefix}:*"  chain "${cfg.watch.chain}"  concurrency ${cfg.watch.concurrency}` +
-        (cfg.watch.refine.enabled ? `  refine "${cfg.watch.refine.chain}" concurrency ${cfg.watch.refine.concurrency}` : "") +
-        (flags["dry-run"] ? "  (dry run)" : ""));
+    // The dashboard already renders this exact information as its own live
+    // header (repo/label/chain/concurrency/dry-run) — printing it again here
+    // would both duplicate it and interleave a raw console.log with an
+    // active Ink region.
+    if (!dashboard) {
+        console.log(`[spf] watch     ${cfg.watch.issue_provider}+${cfg.watch.code_host}  ${cfg.watch.repo}  label "${cfg.watch.label_prefix}:*"  chain "${cfg.watch.chain}"  concurrency ${cfg.watch.concurrency}` +
+            (cfg.watch.refine.enabled ? `  refine "${cfg.watch.refine.chain}" concurrency ${cfg.watch.refine.concurrency}` : "") +
+            (flags["dry-run"] ? "  (dry run)" : ""));
+    }
     deps.notify({
         kind: "watch_started",
         level: "info",
@@ -490,15 +566,18 @@ export async function watchCommand(argv) {
     });
     try {
         for (;;) {
+            dashboard?.setNextPollAt(null); // clears any stale countdown while a tick is actually running
             await tick(deps, state);
+            dashboard?.setCounts(state.inflight.size, state.refining.size);
             if (flags["once"] || stopping)
                 break;
+            dashboard?.setNextPollAt(Date.now() + cfg.watch.poll_ms);
             await interruptibleSleep(cfg.watch.poll_ms);
             if (stopping)
                 break;
         }
         while (state.inflight.size > 0) {
-            console.log(`[spf] watch     draining ${state.inflight.size} in-flight issue(s)...`);
+            deps.log(`[spf] watch     draining ${state.inflight.size} in-flight issue(s)...`); // deps.log already routes to the dashboard when one is mounted, console.log otherwise
             await interruptibleSleep(1000);
             if (stopping && sigints >= 2)
                 break; // stop() itself already exits on the 2nd signal; this is belt-and-suspenders
@@ -511,5 +590,6 @@ export async function watchCommand(argv) {
         process.off("SIGINT", stop);
         process.off("SIGTERM", stop);
         releaseLock(lockPath);
+        await dashboard?.close();
     }
 }

package/dist/cli/index.js

@@ -49,7 +49,7 @@ const HELP = `spf — repeatable agents-plus-code workflows (ADWs)
   spf abort <adw_id>                        signal a run's process to stop
   spf version                               print the installed version
 
-Chain options: [--config <path>] [--adw-id <id>] [--cwd <dir>] [--agent <name>] [--base <ref>] [--issue <id>]
+Chain options: [--config <path>] [--adw-id <id>] [--cwd <dir>] [--agent <name>] [--base <ref>] [--issue <id>] [--priority p0|p1|p2|p3]
 Run budget: set defaults.max_run_cost (USD) and/or defaults.max_run_tokens in spf.config.yaml to stop the NEXT agent call once a run has already spent this much — checked before each call, never after, so a single call is never capped and a one-agent-dispatch chain (scout/prompt/build) can never trip it; absent (the default) = unbounded.
 Run \`spf list\` to see every chain and what it needs.`;
 /** A raw scan for `--cwd`, ahead of any command-specific argv parsing — every command that takes it means the same thing by it. */
@@ -151,7 +151,7 @@ export async function main() {
                 process.exitCode = await estimateCommand(rest);
                 return;
             case "list":
-                process.exitCode = listCommand();
+                process.exitCode = await listCommand();
                 return;
             case "init":
                 process.exitCode = await initCommand(rest);
@@ -177,10 +177,10 @@ export async function main() {
                 return;
             }
             case "sessions":
-                process.exitCode = sessionsCommand(rest);
+                process.exitCode = await sessionsCommand(rest);
                 return;
             case "phases":
-                process.exitCode = phasesCommand(rest);
+                process.exitCode = await phasesCommand(rest);
                 return;
             case "events":
                 process.exitCode = await eventsCommand(rest);

package/dist/cli/interview.js

@@ -286,16 +286,20 @@ export async function runInterview(asker, ctx) {
         watch = { issue_provider: issueProvider, code_host: codeHost, repo, label_prefix: labelPrefix, chain, base_branch: baseBranch };
         if (issueRepo)
             watch.issue_repo = issueRepo;
-        // Issue authoring (create + link a hierarchy) is only implemented on
-        // GitHubProvider today — see jira_provider.ts's module comment — so
-        // this lane isn't offered at all on a Jira tracker rather than asking a
-        // question that would just fail at `spf watch` startup.
-        if (issueProvider === "github") {
+        // Issue authoring (create + link a hierarchy) is implemented on both
+        // GitHubProvider and JiraProvider — see jira_provider.ts's module
+        // comment for how Jira's version works (native issue types + the
+        // `parent` field).
+        if (issueProvider === "github" || issueProvider === "jira") {
             const enableRefine = await asker.confirm(`Also enable the refine lane (decompose a "${labelPrefix}:spec-ready" product spec into a feature/story-or-bug tree)?`, false);
             if (enableRefine) {
                 const refineChainChoices = allChains().map((c) => ({ value: c.name, label: c.name, hint: c.source ? `${c.describe} (repo)` : c.describe }));
                 const refineChain = await asker.select("Chain to run per spec", refineChainChoices, "refine");
                 watch.refine = { enabled: true, chain: refineChain };
+                if (issueProvider === "jira") {
+                    asker.note('Jira issue types default to epic/feature -> "Epic", story -> "Story", bug -> "Bug", task -> "Task" — ' +
+                        "customize per-kind in watch.jira.issue_types if your project renames any of them, then run `spf watch init` to validate.");
+                }
             }
         }
         if (issueProvider === "jira") {

package/dist/cli/ui/fanout_dashboard.d.ts

@@ -0,0 +1,22 @@
+import { type FanoutAttempt } from "../../core/fanout.ts";
+export interface FanoutDashboard {
+    onAttempt: (attempt: FanoutAttempt) => void;
+    /** Routes `FanoutDeps.log()` here instead of `console.log` while this is mounted — see the module header for why a raw console write can't share the terminal with an active Ink instance. */
+    log: (message: string) => void;
+    /** Tears the Ink instance down. Call exactly once, after `runBestOf()` settles — the plain-text winner/basis lines after it are unaffected; only the redundant header + final table are skipped when a dashboard was used (see `cli/commands/fanout.ts`'s call site). */
+    close(): Promise<void>;
+    /**
+     * Synchronous, no flush-wait — for a signal handler, which stays
+     * synchronous by design and gets cut off by `process.exit()` immediately
+     * after: an `await` here would never get a chance to resume. Only
+     * restores terminal state (cursor visibility) on a best-effort basis; the
+     * final frame may not have caught up to the last attempt yet.
+     */
+    unmountNow(): void;
+}
+export declare function mountFanoutDashboard(opts: {
+    n: number;
+    chainName: string;
+    baseBranch: string;
+    baseAdwId: string;
+}): FanoutDashboard;

package/dist/cli/ui/fanout_dashboard.js

@@ -0,0 +1,102 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * A live results table for `spf fanout` — the same columns
+ * `cli/commands/fanout.ts`'s `printTable()` prints once at the end, updated
+ * row by row as each attempt settles instead. Reached only through a
+ * dynamic `import()` and only when `isInteractive()`; non-TTY keeps the
+ * exact one-shot `printTable()` path, byte for byte (`fanout_cli.test.ts`
+ * runs with no TTY, so it never touches this file).
+ *
+ * One persistent Ink instance for the whole `runBestOf()` call — same shape
+ * as `run_dashboard.tsx`: a `<Static>` history for `deps.log()`'s own
+ * lines (the "chain X x3 off main" opener, an "attempt N skipped" line —
+ * `cli/commands/fanout.ts` routes these here instead of straight to
+ * `console.log` specifically so nothing writes to stdout outside Ink while
+ * this is mounted; interleaving a raw `console.log` with an active Ink
+ * live region corrupts the redraw) plus a LIVE section below it — here,
+ * the whole results table, not one line, since every row can still change
+ * until the very last attempt settles and there's no "this phase is done"
+ * moment to freeze one into history the way `run_dashboard.tsx` does per
+ * phase. Nothing here calls `useInput`, so raw mode never engages.
+ */
+import { useState, useRef } from "react";
+import { render, Static, Box, Text } from "ink";
+import * as agents from "../../core/agents.js";
+import { attemptAdwId, attemptBranch } from "../../core/fanout.js";
+function statusLabel(row) {
+    if (!row)
+        return "running…";
+    return row.status;
+}
+function gatesLabel(row) {
+    if (!row || row.status === "skipped")
+        return "-";
+    return `${row.gate_passes}p/${row.gate_failures}f`;
+}
+function timeLabel(row) {
+    if (!row || row.status === "skipped")
+        return "-";
+    const seconds = row.wall_ms / 1000;
+    return seconds < 90 ? `${seconds.toFixed(1)}s` : `${Math.floor(seconds / 60)}m ${String(Math.round(seconds % 60)).padStart(2, "0")}s`;
+}
+function rowColor(row) {
+    if (!row)
+        return "dim";
+    if (row.status === "success")
+        return "green";
+    if (row.status === "fail" || row.status === "error")
+        return "red";
+    return undefined;
+}
+function FanoutRoot(props) {
+    const [rows, setRows] = useState(new Map());
+    const [log, setLog] = useState([]);
+    const keyRef = useRef(0); // a ref, not state — see ink_asker.tsx's identical comment on why two pushes in one tick must not collide
+    props.handleRef.current = {
+        setAttempt(attempt) {
+            setRows((prev) => {
+                const next = new Map(prev);
+                next.set(attempt.index, attempt);
+                return next;
+            });
+        },
+        pushLog(text) {
+            const key = keyRef.current++;
+            setLog((prev) => [...prev, { key, text }]);
+        },
+    };
+    const indices = Array.from({ length: props.n }, (_, i) => i + 1);
+    const widths = {
+        adw: Math.max(6, ...indices.map((i) => attemptAdwId(props.baseAdwId, i).length)),
+        branch: Math.max(6, ...indices.map((i) => attemptBranch(props.baseAdwId, i).length)),
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: log, children: (line) => _jsx(Text, { children: line.text }, line.key) }), _jsxs(Text, { children: ["fanout ", props.chainName, " \u2014 ", props.n, " attempt(s), base ", props.baseBranch] }), _jsxs(Box, { children: [_jsx(Box, { width: 3, children: _jsx(Text, { dimColor: true, children: "#" }) }), _jsx(Box, { width: widths.adw, marginRight: 2, children: _jsx(Text, { dimColor: true, children: "adw_id" }) }), _jsx(Box, { width: widths.branch, marginRight: 2, children: _jsx(Text, { dimColor: true, children: "branch" }) }), _jsx(Box, { width: 9, children: _jsx(Text, { dimColor: true, children: "status" }) }), _jsx(Box, { width: 9, children: _jsx(Text, { dimColor: true, children: "gates" }) }), _jsx(Box, { width: 10, children: _jsx(Text, { dimColor: true, children: "cost" }) }), _jsx(Text, { dimColor: true, children: "time" })] }), indices.map((i) => {
+                const row = rows.get(i) ?? null;
+                const color = rowColor(row);
+                return (_jsxs(Box, { children: [_jsx(Box, { width: 3, children: _jsx(Text, { color: color, children: i }) }), _jsx(Box, { width: widths.adw, marginRight: 2, children: _jsx(Text, { color: color, children: attemptAdwId(props.baseAdwId, i) }) }), _jsx(Box, { width: widths.branch, marginRight: 2, children: _jsx(Text, { color: color, children: attemptBranch(props.baseAdwId, i) }) }), _jsx(Box, { width: 9, children: _jsx(Text, { color: color, children: statusLabel(row) }) }), _jsx(Box, { width: 9, children: _jsx(Text, { color: color, children: gatesLabel(row) }) }), _jsx(Box, { width: 10, children: _jsx(Text, { color: color, children: row ? agents.formatUsd(row.cost) : "-" }) }), _jsx(Text, { color: color, children: timeLabel(row) })] }, i));
+            })] }));
+}
+export function mountFanoutDashboard(opts) {
+    const handleRef = { current: null };
+    const app = render(_jsx(FanoutRoot, { n: opts.n, chainName: opts.chainName, baseBranch: opts.baseBranch, baseAdwId: opts.baseAdwId, handleRef: handleRef }), 
+    // `interactive: true` overrides Ink's own CI auto-detection — see
+    // `ink_asker.tsx`'s identical `render()` call for why: the caller
+    // (`commands/fanout.ts`) only reaches this file after its own
+    // `isInteractive()` check has already passed.
+    { patchConsole: false, interactive: true });
+    return {
+        onAttempt(attempt) {
+            handleRef.current?.setAttempt(attempt);
+        },
+        log(message) {
+            handleRef.current?.pushLog(message);
+        },
+        async close() {
+            await app.waitUntilRenderFlush();
+            app.unmount();
+        },
+        unmountNow() {
+            app.unmount();
+        },
+    };
+}

package/dist/cli/ui/ink_asker.d.ts

@@ -0,0 +1,13 @@
+import type { Asker } from "../ask.ts";
+/**
+ * The real `stdin`/`stdout` pair the interview reads/writes — defaults to
+ * the process's own. `src/test/ink_asker.test.ts` passes a fake TTY pair
+ * instead (`node --test` has neither a real terminal nor raw-mode
+ * support), the same seam Ink's own render options already expose; this
+ * is not new surface, just threaded through so a test can reach it.
+ */
+export interface RenderStreams {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+}
+export declare function createInkAsker(streams?: RenderStreams): Asker;

package/dist/cli/ui/ink_asker.js

@@ -0,0 +1,247 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Ink-backed implementation of the `Asker` interface (`cli/ask.ts`) — a
+ * drop-in replacement for `createAsker()`'s readline prompts, used only
+ * when `inkAvailable()` says raw-mode stdin is there to drive it.
+ * `runInterview()` (`cli/interview.ts`) never sees this file: it only ever
+ * imports the `Asker` type, so it is byte-for-byte unchanged by this
+ * module existing, and every `createFakeAsker`-driven test still exercises
+ * it exactly as before.
+ *
+ * This file is reached only through a dynamic `import()` (see
+ * `commands/init.ts`) so the ~150-300ms cost of loading `ink`+`react` is
+ * never paid on a non-interactive run.
+ *
+ * ONE Ink instance is mounted lazily on the first prompt and kept alive for
+ * the whole interview, torn down only in `close()`. An earlier version
+ * mounted a fresh instance per question instead — that toggled raw mode
+ * off (on unmount) and back on (on the next mount) between every single
+ * question, and empirically, over a real pty, a keystroke landing in that
+ * gap got echoed to the screen instead of consumed, and could be lost or
+ * misrouted entirely (arrow-key-then-Enter on the second question the
+ * default readline-vs-Ink smoke test tried was the one that caught it —
+ * the model select accepted the arrow move but the following Enter never
+ * registered). Keeping raw mode continuously enabled for the interview's
+ * entire lifetime removes the gap outright, and is also just the correct
+ * Ink pattern for a multi-step wizard: finished questions accumulate in an
+ * `<Static>` list (rendered once, never touched again — exactly the
+ * "leaves the final frame in scrollback" transcript this asker owes
+ * `runInterview()`) while the current question lives in one live slot
+ * below it, both children of the SAME root, updated by `rerender()`.
+ *
+ * `exitOnCtrlC: false`: `spf watch` and `core/session.ts` own SIGINT/
+ * SIGTERM handling, and Ink's default Ctrl-C behavior would call
+ * `process.exit()` out from under both. Ctrl-C (and Ctrl-D, treated the
+ * same way the readline asker treats EOF) is instead caught once, at the
+ * root, and turned into the same `InterviewAborted` the readline asker
+ * throws — `initCommand` catches it and exits 130, writing nothing.
+ */
+import { useRef, useState } from "react";
+import { render, Static, Box, Text, useInput } from "ink";
+import { ConfirmInput, PasswordInput, TextInput } from "@inkjs/ui";
+import { InterviewAborted, maskForPrompt } from "../ask.js";
+import { paint } from "../../core/console.js";
+function InterviewRoot(props) {
+    const [history, setHistory] = useState([]);
+    const [prompt, setPrompt] = useState(null);
+    // A ref, not `useState` — two `pushHistory` calls can happen back to back
+    // synchronously (e.g. `heading()` immediately followed by `note()`, exactly
+    // how `runInterview()` opens each section) with no re-render in between to
+    // flush a `nextKey` state update, so both would read the same stale value
+    // and mint duplicate keys. A ref's mutation is immediate or it wouldn't be
+    // safe as a counter at all.
+    const keyRef = useRef(0);
+    props.handleRef.current = {
+        pushHistory(node) {
+            const key = keyRef.current++;
+            setHistory((h) => [...h, { key, node }]);
+        },
+        setPrompt,
+    };
+    useInput((input, key) => {
+        if (key.ctrl && (input === "c" || input === "d"))
+            props.onAbort();
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: history, children: (line) => _jsx(Box, { children: line.node }, line.key) }), prompt] }));
+}
+function TextPromptView(props) {
+    const [error, setError] = useState(null);
+    // `TextInput` is uncontrolled — `defaultValue` only seeds its FIRST value,
+    // so a rejected submit otherwise leaves the rejected text sitting in the
+    // box and whatever's typed next appends onto it instead of replacing it.
+    // Changing `key` forces React to unmount and remount a fresh instance
+    // (starting empty again) on every rejection, which is the standard way
+    // to "reset" an uncontrolled component.
+    const [attempt, setAttempt] = useState(0);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { children: props.label }), props.defaultValue ? _jsxs(Text, { dimColor: true, children: [" [", props.defaultValue, "]"] }) : null, _jsx(Text, { children: ": " }), _jsx(TextInput, { defaultValue: props.defaultValue, onSubmit: (value) => {
+                            const resolved = value || props.defaultValue || "";
+                            const problem = props.validate?.(resolved) ?? null;
+                            if (problem) {
+                                setError(problem);
+                                setAttempt((n) => n + 1);
+                                return;
+                            }
+                            props.onSubmit(resolved);
+                        } }, attempt)] }), error ? _jsxs(Text, { color: "red", children: ["  ", error] }) : null] }));
+}
+/**
+ * Hand-rolled instead of `@inkjs/ui`'s `Select` — that component's
+ * `onChange` only fires when its internal `value` differs from
+ * `previousValue` (`use-select-state.js`'s reducer + effect), and accepting
+ * the already-highlighted default via an immediate Enter, with no arrow
+ * key pressed first, never changes that value. That's the single most
+ * common interaction with any select prompt (take the default), so the
+ * bug isn't an edge case: every `select()` call whose first keypress is
+ * Enter would hang forever. Confirmed empirically before writing this —
+ * the same prompt resolves instantly the moment an arrow key precedes
+ * Enter. `ConfirmInput`/`TextInput`/`PasswordInput` call their callbacks
+ * unconditionally from their own input handlers and don't share this bug,
+ * so they're untouched.
+ */
+function SelectPromptView(props) {
+    const dfltIndex = props.choices.findIndex((c) => c.value === props.dflt);
+    const [index, setIndex] = useState(dfltIndex === -1 ? 0 : dfltIndex);
+    useInput((_input, key) => {
+        if (key.downArrow)
+            setIndex((i) => Math.min(props.choices.length - 1, i + 1));
+        if (key.upArrow)
+            setIndex((i) => Math.max(0, i - 1));
+        if (key.return)
+            props.onSubmit(props.choices[index].value);
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: props.label }), props.choices.map((c, i) => {
+                const focused = i === index;
+                const hint = c.hint ? paint("dim", ` — ${c.hint}`) : "";
+                return (_jsxs(Text, { color: focused ? "cyan" : undefined, children: [focused ? "❯ " : "  ", c.label ?? c.value, hint] }, c.value));
+            })] }));
+}
+function ConfirmPromptView(props) {
+    return (_jsxs(Box, { children: [_jsxs(Text, { children: [props.label, " "] }), _jsx(ConfirmInput, { defaultChoice: props.dflt ? "confirm" : "cancel", onConfirm: () => props.onSubmit(true), onCancel: () => props.onSubmit(false) })] }));
+}
+function SecretPromptView(props) {
+    return (_jsxs(Box, { children: [_jsx(Text, { children: props.label }), props.current ? _jsxs(Text, { dimColor: true, children: [" [keep current: ", maskForPrompt(props.current), "]"] }) : null, _jsx(Text, { children: ": " }), _jsx(PasswordInput, { onSubmit: props.onSubmit })] }));
+}
+export function createInkAsker(streams = {}) {
+    // Mirrors `createAsker()`'s own `aborted` flag: once a Ctrl-C/Ctrl-D fires,
+    // every later call throws immediately instead of showing a prompt that
+    // would just get torn down again.
+    let aborted = false;
+    // Whichever prompt is currently live — `InterviewRoot`'s single Ctrl-C/
+    // Ctrl-D handler rejects THIS, whatever it is, since only one prompt is
+    // ever showing at a time.
+    let currentReject = null;
+    let app;
+    const handleRef = { current: null };
+    function handle() {
+        if (!app) {
+            app = render(_jsx(InterviewRoot, { handleRef: handleRef, onAbort: () => {
+                    aborted = true;
+                    currentReject?.(new InterviewAborted());
+                } }), 
+            // `interactive: true` overrides Ink's own auto-detection
+            // (`stdout.isTTY` + the `is-in-ci` package) rather than relying on
+            // it: the caller here is `commands/init.ts`, which only ever
+            // reaches this file after `inkAvailable()` has ALREADY confirmed a
+            // real interactive terminal — that check is the one source of
+            // truth, and Ink's own CI detection is redundant at best. At
+            // worst it actively lies: GitHub Actions sets `CI=true`
+            // unconditionally, and `node --test` running there is exactly
+            // where this file's own test suite (`ink_asker.test.ts`) drives a
+            // real Ink instance against a fake TTY that reports `isTTY: true`
+            // — Ink's non-interactive mode then writes NOTHING incrementally
+            // (only the final frame, at unmount), so `stdout.frames` never
+            // grows and every keystroke-driven test hangs until its own
+            // timeout. Confirmed by reproducing the exact CI failure locally
+            // with `CI=1 node --test ...` before this fix, and confirming it
+            // disappears after.
+            { ...streams, exitOnCtrlC: false, patchConsole: false, interactive: true });
+        }
+        // `InterviewRoot` populates this synchronously during its first render,
+        // which `render()` above has already forced to happen by the time it
+        // returns.
+        return handleRef.current;
+    }
+    async function guarded(run) {
+        if (aborted)
+            throw new InterviewAborted();
+        try {
+            return await run(handle());
+        }
+        catch (error) {
+            if (error instanceof InterviewAborted)
+                aborted = true;
+            throw error;
+        }
+        finally {
+            currentReject = null;
+        }
+    }
+    return {
+        text(label, opts) {
+            return guarded((h) => new Promise((resolve, reject) => {
+                currentReject = reject;
+                h.setPrompt(_jsx(TextPromptView, { label: label, defaultValue: opts?.default, validate: opts?.validate, onSubmit: (value) => {
+                        h.setPrompt(null);
+                        h.pushHistory(_jsxs(Text, { children: [label, ": ", value] }));
+                        resolve(value);
+                    } }));
+            }));
+        },
+        select(label, choices, dflt) {
+            return guarded((h) => new Promise((resolve, reject) => {
+                currentReject = reject;
+                h.setPrompt(_jsx(SelectPromptView, { label: label, choices: choices, dflt: dflt, onSubmit: (value) => {
+                        const chosen = choices.find((c) => c.value === value);
+                        h.setPrompt(null);
+                        h.pushHistory(_jsxs(Text, { children: [label, " ", _jsxs(Text, { color: "cyan", children: ["\u276F ", chosen?.label ?? value] })] }));
+                        resolve(value);
+                    } }));
+            }));
+        },
+        confirm(label, dflt, opts) {
+            return guarded((h) => new Promise((resolve, reject) => {
+                let settled = false;
+                let timer;
+                currentReject = reject;
+                const finish = (value, note) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    if (timer)
+                        clearTimeout(timer);
+                    h.setPrompt(null);
+                    h.pushHistory(_jsxs(Text, { children: [label, " ", value ? "yes" : "no", note ? _jsxs(Text, { color: "yellow", children: [" (", note, ")"] }) : null] }));
+                    resolve(value);
+                };
+                if (opts?.timeoutMs !== undefined) {
+                    timer = setTimeout(() => finish(dflt, `timed out — using default (${dflt ? "yes" : "no"})`), opts.timeoutMs);
+                    timer.unref?.();
+                }
+                h.setPrompt(_jsx(ConfirmPromptView, { label: label, dflt: dflt, onSubmit: (value) => finish(value) }));
+            }));
+        },
+        secret(label, opts) {
+            return guarded((h) => new Promise((resolve, reject) => {
+                currentReject = reject;
+                h.setPrompt(_jsx(SecretPromptView, { label: label, current: opts?.current, onSubmit: (value) => {
+                        h.setPrompt(null);
+                        h.pushHistory(_jsxs(Text, { children: [label, ": ", value ? maskForPrompt(value) : "(unchanged)"] }));
+                        resolve(value);
+                    } }));
+            }));
+        },
+        note(text) {
+            if (aborted)
+                return;
+            handle().pushHistory(_jsxs(Text, { dimColor: true, children: ["  ", text] }));
+        },
+        heading(text) {
+            if (aborted)
+                return;
+            handle().pushHistory(_jsxs(Text, { bold: true, color: "cyan", children: ["\u2500\u2500 ", text, " \u2500\u2500"] }));
+        },
+        close() {
+            app?.unmount();
+        },
+    };
+}