@gr8ful/spf 0.6.0 → 0.8.0

package/dist/cli/commands/doctor.js

@@ -22,6 +22,30 @@ import { PROVIDER_ENV_KEYS } from "../../core/providers.js";
 import { probeServedOllamaTags, resolveTiering } from "../../core/tiering.js";
 import { isRepoAt } from "../../core/git_helper.js";
 import { allChains, findChain, repoChainProblems, resolveRequiredAgents, resolveRequiredSuites } from "../../chains/index.js";
+import { isInteractive } from "../ask.js";
+import { paint as paintPlain } from "../../core/console.js";
+/**
+ * A transient "checking X..." status line around a network probe — real
+ * work only starts inside `run()`; this doesn't touch the promise's timing.
+ * TTY-only: `\r` + erase-to-end-of-line only makes sense against a real
+ * terminal, and a non-TTY/CI log should show nothing extra, matching
+ * doctor's output exactly as it always has when piped. Not Ink-based on
+ * purpose — this is a plain transient ANSI line, not a component tree, and
+ * doctor's checks accumulate into one report printed at the very end
+ * regardless, so there's no persistent live region for a probe status to
+ * join.
+ */
+async function withProbeStatus(label, run) {
+    if (!isInteractive())
+        return run();
+    process.stdout.write(paintPlain("dim", `  checking ${label}...`));
+    try {
+        return await run();
+    }
+    finally {
+        process.stdout.write("\r\x1b[2K");
+    }
+}
 /**
  * `severity` is a display-only axis, orthogonal to `ok`/`report.ok`: an
  * "info"/"warn" check still reports `ok: true` (it never fails `spf doctor`
@@ -174,7 +198,7 @@ export async function doctorCommand(argv) {
     }
     catch (error) {
         check(report, "config parses", false, error.message);
-        return finish(report, flags["json"]);
+        return await finish(report, flags["json"]);
     }
     const dataPaths = paths.resolveDataPaths(anchor, cfg.defaults.data_dir, cfg.observability.db);
     check(report, "data_dir", true, dataPaths.data_dir);
@@ -254,7 +278,7 @@ export async function doctorCommand(argv) {
             const probeBase = doubledPath ? trimmed.replace(/\/v1$/, "") : trimmed;
             const claudeCodeAgent = cfg.agents.find((a) => a.coding_agent === "claude_code");
             const probeModel = claudeCodeAgent?.model || "claude-sonnet-5";
-            const result = await probeAnthropicMessages(probeBase, probeModel);
+            const result = await withProbeStatus("ANTHROPIC_BASE_URL reachability", () => probeAnthropicMessages(probeBase, probeModel));
             check(report, "ANTHROPIC_BASE_URL reachability", true, (result.ok
                 ? `${doubledPath ? `dropping the trailing "/v1" makes it ` : ""}reachable: POST ${probeBase}/v1/messages -> HTTP ${result.status}${result.note ? ` (${result.note})` : ""}`
                 : `unreachable: POST ${probeBase}/v1/messages -> ${result.error}`) +
@@ -288,7 +312,7 @@ export async function doctorCommand(argv) {
         // latency either way — strictly cheaper for a pure reachability check,
         // and there's no live-server dependency in this choice: doctor's probe
         // itself tolerates either endpoint being down (see `probeGet`).
-        const result = await probeGet(`${ollamaBase}/models`);
+        const result = await withProbeStatus("OLLAMA_BASE_URL reachability", () => probeGet(`${ollamaBase}/models`));
         check(report, "OLLAMA_BASE_URL reachability", true, // informational/warning only — see the ANTHROPIC_BASE_URL check above for why
         result.ok ? `reachable: GET ${ollamaBase}/models -> HTTP ${result.status}` : `unreachable: GET ${ollamaBase}/models -> ${result.error}`, result.ok ? "info" : "warn");
     }
@@ -379,7 +403,7 @@ export async function doctorCommand(argv) {
         // chain+prompt is `spf estimate`'s job, not doctor's. `required` is the
         // WHOLE roster, matching the "roster + suites validate" call above —
         // every routed role doctor's job covers, not just what one chain needs.
-        const servedOllamaTags = flags["no-probe"] ? null : await probeServedOllamaTags(cfg);
+        const servedOllamaTags = flags["no-probe"] ? null : await withProbeStatus("served Ollama tags", () => probeServedOllamaTags(cfg));
         const resolution = resolveTiering({
             cfg,
             chainName: "",
@@ -534,9 +558,11 @@ export async function doctorCommand(argv) {
         if (cfg.watch.refine.enabled) {
             const refineChain = findChain(cfg.watch.refine.chain);
             check(report, "watch.refine.chain", Boolean(refineChain), refineChain ? `${cfg.watch.refine.chain}${refineChain.source ? ` (repo: ${repoChainLabel(refineChain.source)})` : ""}` : `"${cfg.watch.refine.chain}" is not a registered chain`);
-            check(report, "watch.refine issue authoring", cfg.watch.issue_provider === "github", cfg.watch.issue_provider === "github"
+            check(report, "watch.refine issue authoring", cfg.watch.issue_provider === "github" || cfg.watch.issue_provider === "jira", cfg.watch.issue_provider === "github"
                 ? "github supports issue authoring (createIssue/sub-issues)"
-                : `watch.issue_provider is ${JSON.stringify(cfg.watch.issue_provider)} — the refine lane needs "github" (Jira issue authoring isn't implemented yet)`);
+                : cfg.watch.issue_provider === "jira"
+                    ? "jira supports issue authoring (createIssue/parent field) — run `spf watch init` to validate watch.jira.issue_types against the real project"
+                    : `watch.issue_provider is ${JSON.stringify(cfg.watch.issue_provider)} — the refine lane needs "github" or "jira"`);
         }
     }
     // OTel span export: informational in every direction. It is off unless
@@ -557,7 +583,9 @@ export async function doctorCommand(argv) {
             `${cfg.observability.otel.headers ? `, headers: ${Object.keys(cfg.observability.otel.headers).join(", ")}` : ""})` +
             (insecure ? " — WARNING: plain http to a non-loopback host sends this telemetry in cleartext" : ""), insecure ? "warn" : "info");
         if (!flags["no-probe"]) {
-            const result = await probeOtel(url, cfg.observability.otel.headers);
+            // Captured into a local: TS narrowing from the outer `if (cfg.observability.otel)` doesn't survive into this closure.
+            const otelHeaders = cfg.observability.otel.headers;
+            const result = await withProbeStatus("observability.otel reachability", () => probeOtel(url, otelHeaders));
             check(report, "observability.otel reachability", true, // informational/warning only — same rule as the base-URL probes above
             result.ok
                 ? `reachable: POST ${endpointLabel(url)} (empty batch) -> HTTP ${result.status}${result.status >= 400 ? " — reachable but rejecting; check the path (/v1/traces) and headers" : ""}`
@@ -577,16 +605,26 @@ export async function doctorCommand(argv) {
     }
     return finish(report, flags["json"]);
 }
-function finish(report, json) {
+async function finish(report, json) {
     if (json) {
         console.log(JSON.stringify(report, null, 2));
+        return report.ok ? 0 : 1;
+    }
+    const footer = { ok: report.ok, message: report.ok ? "spf doctor: clean" : "spf doctor: problems found above" };
+    if (isInteractive()) {
+        const { renderChecklist } = await import("../ui/reports.js");
+        await renderChecklist(report.checks.map((c) => ({
+            icon: c.severity === "warn" ? "warn" : c.severity === "info" ? "info" : c.ok ? "ok" : "fail",
+            name: c.name,
+            detail: c.detail,
+        })), footer);
     }
     else {
         for (const c of report.checks) {
             const icon = c.severity === "warn" ? "⚠" : c.severity === "info" ? "ℹ" : c.ok ? "✓" : "✗";
             console.log(`${icon} ${c.name}: ${c.detail}`);
         }
-        console.log(report.ok ? "\nspf doctor: clean" : "\nspf doctor: problems found above");
+        console.log(`\n${footer.message}`);
     }
     return report.ok ? 0 : 1;
 }

package/dist/cli/commands/fanout.js

@@ -31,6 +31,7 @@ import { ABORTED_EXIT, attemptAdwId, runBestOf, ZERO_METRICS, } from "../../core
 import { findChain, runChain as runChainDef } from "../../chains/index.js";
 import { SfDb } from "../../ui/server/db.js";
 import { newId, parseCli, resolvePrompt } from "../../core/utils.js";
+import { isInteractive } from "../ask.js";
 /**
  * A ceiling on `--n`, not a recommendation. Each attempt is a full chain run
  * with its own agents, so `--n` multiplies spend directly — and the machine
@@ -62,9 +63,30 @@ function formatGates(attempt) {
 /**
  * The result table. Fixed column widths over a `console.table`: every other
  * `spf` listing (`sessions`, `phases`) prints plain padded columns, and this
- * output is read in a terminal beside them.
+ * output is read in a terminal beside them. On a TTY, routes through the
+ * same `renderTable()` (`cli/ui/reports.tsx`) those two now use instead —
+ * `fanout_cli.test.ts` runs with no TTY, so it keeps exercising this exact
+ * plain-text path unchanged.
  */
-function printTable(attempts) {
+async function printTable(attempts) {
+    const rows = attempts.map((a) => [
+        String(a.index),
+        a.adw_id,
+        a.branch,
+        a.status,
+        formatGates(a),
+        agents.formatUsd(a.cost),
+        a.status === "skipped" ? "-" : formatDuration(a.wall_ms),
+    ]);
+    if (isInteractive()) {
+        const { renderTable } = await import("../ui/reports.js");
+        await renderTable([["#", "adw_id", "branch", "status", "gates", "cost", "time"], ...rows], { rowColor: (i) => (i > 0 && attempts[i - 1].status === "fail" ? "red" : undefined) });
+        for (const a of attempts) {
+            if (a.error)
+                console.log(`      error: ${a.error}`);
+        }
+        return;
+    }
     const widths = {
         adw: Math.max(6, ...attempts.map((a) => a.adw_id.length)),
         branch: Math.max(6, ...attempts.map((a) => a.branch.length)),
@@ -343,11 +365,26 @@ export async function fanoutCommand(argv) {
     // this reliably buys, in the case it can't prevent, is telling the
     // operator the one thing the trace can't: which base adw_id to hand to
     // `--clean` afterwards.
+    // Mounted only on a real TTY — a live results table that updates row by
+    // row as each attempt settles, instead of the plain-text path's one-shot
+    // table at the very end. `dashboard` (not just its presence) is read by
+    // `onSignal` below, best-effort-unmounted before `process.exit()`: Ink's
+    // usual cleanup (restoring cursor visibility) never gets a chance to run
+    // on an abrupt exit otherwise, and this command's own SIGINT handler —
+    // unlike `spf watch`'s two-stage drain — already exits immediately by
+    // design (see its comment), so there's no "wait for it to finish" point
+    // to hook a graceful teardown into instead.
+    let dashboard;
+    if (isInteractive()) {
+        const { mountFanoutDashboard } = await import("../ui/fanout_dashboard.js");
+        dashboard = mountFanoutDashboard({ n, chainName: chain.name, baseBranch, baseAdwId });
+    }
     let interrupted = false;
     const onSignal = (signal) => {
         if (interrupted)
             return;
         interrupted = true;
+        dashboard?.unmountNow(); // best-effort cursor-visibility restore — see FanoutDashboard.unmountNow's own comment for why this isn't the awaited close()
         console.error(`\n[spf] fanout: ${signal} received — attempts already past their last checkpoint run to completion. ` +
             `Once everything has settled, clean up anything left under this base id with:\n` +
             `  spf fanout --clean ${baseAdwId}\n`);
@@ -370,10 +407,17 @@ export async function fanoutCommand(argv) {
             runAttempt,
             readMetrics,
             firstSuccess: flags["first-success"],
-            log: (message) => console.log(`[spf] ${message}`),
+            log: (message) => (dashboard ? dashboard.log(message) : console.log(`[spf] ${message}`)),
+            onAttempt: dashboard?.onAttempt,
         });
-        console.log(`\nfanout ${chain.name} — ${n} attempt(s), base ${baseBranch}`);
-        printTable(result.attempts);
+        await dashboard?.close();
+        // A dashboard already printed the header and kept the table live and
+        // in scrollback throughout the run — printing it again here would just
+        // duplicate what's already there. Only the non-TTY path needs both.
+        if (!dashboard) {
+            console.log(`\nfanout ${chain.name} — ${n} attempt(s), base ${baseBranch}`);
+            await printTable(result.attempts);
+        }
         if (!result.winner) {
             console.error(`\nno winner: ${result.basis}`);
             console.error(`Any attempt whose chain got far enough to open a session has its trace in the shared db — ` +

package/dist/cli/commands/init.js

@@ -27,7 +27,7 @@ import * as agents from "../../core/agents.js";
 import { ensureGitignore } from "../gitignore.js";
 import { parseCli } from "../../core/utils.js";
 import { paint } from "../../core/console.js";
-import { createAsker, isInteractive, InterviewAborted } from "../ask.js";
+import { createAsker, inkAvailable, isInteractive, InterviewAborted } from "../ask.js";
 import { gatherContext, runInterview } from "../interview.js";
 import { readEnvFile, upsertEnvFile, writeEnvExample } from "../env_file.js";
 import { installSkillCommand } from "./install-skill.js";
@@ -99,7 +99,10 @@ const STARTER_CONFIG = `# .spf/spf.config.yaml — merged ON TOP of spf's packag
 #   base_branch: main
 #   # Optional second lane: decompose a spf:spec-ready product spec into a
 #   # feature/story-or-bug tree of real issues. Off by default; needs
-#   # issue_provider: github — issue authoring isn't implemented for Jira yet.
+#   # issue_provider: github OR jira — both support issue authoring. On Jira,
+#   # each kind maps to a real issue type via watch.jira.issue_types
+#   # (defaults: epic/feature -> Epic, story -> Story, bug -> Bug,
+#   # task -> Task) — \`spf watch init\` validates this against the project.
 #   refine:
 #     enabled: true
 #     chain: refine
@@ -252,7 +255,12 @@ export async function initCommand(argv) {
         installSkill();
     }
     else {
-        const asker = createAsker();
+        // Ink needs raw-mode stdin to drive arrow-key selects and inline
+        // validation; `inkAvailable()` is `isInteractive()` plus one extra
+        // guard for the (practically never, but cheap to check) case where a
+        // TTY-reporting stdin still doesn't expose `setRawMode`. Either way
+        // falls back to the original readline asker, never to a hang.
+        const asker = inkAvailable() ? (await import("../ui/ink_asker.js")).createInkAsker() : createAsker();
         try {
             if (existsSync(configPath) && !flags["force"]) {
                 const overwrite = await asker.confirm(`${configPath} already exists — overwrite it?`, false);

package/dist/cli/commands/list.d.ts

@@ -1 +1 @@
-export declare function listCommand(): number;
+export declare function listCommand(): Promise<number>;

package/dist/cli/commands/list.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { allChains, repoChainProblems } from "../../chains/index.js";
+import { isInteractive } from "../ask.js";
 /**
  * A repo-defined chain's `source` is an absolute path into `.spf/chains/` by
  * construction (that's the one place `loadRepoChains` ever looks) — trim it
@@ -12,28 +13,46 @@ function repoChainLabel(source) {
     const idx = source.lastIndexOf(marker);
     return idx === -1 ? source : source.slice(idx);
 }
-export function listCommand() {
+export async function listCommand() {
     // Built-ins first, then repo chains — same order `allChains()` guarantees,
     // so this listing and `findChain`'s resolution order never disagree about
     // which chain wins on a name collision.
     const chains = allChains();
     const width = Math.max(...chains.map((c) => c.name.length));
-    for (const chain of chains) {
+    const entries = chains.map((chain) => {
         const agents = typeof chain.requiredAgents === "function" ? "(--agent picks who)" : chain.requiredAgents.join(", ") || "(none)";
         const suites = typeof chain.requiredSuites === "function" ? chain.requiredSuites({}) : chain.requiredSuites;
         const suiteNote = typeof chain.requiredSuites === "function" ? " (--suite overrides)" : "";
-        console.log(`${chain.name.padEnd(width)}  ${chain.phases}`);
-        console.log(`${"".padEnd(width)}  ${chain.describe}`);
-        console.log(`${"".padEnd(width)}  agents: ${agents}${suites.length ? `  ·  quality suites: ${suites.join(", ")}${suiteNote}` : ""}`);
-        // `source` is undefined for every built-in — only a chain loaded from a
-        // `.spf/chains/*.yaml` file carries one (see chains/repo_chains.ts).
-        if (chain.source) {
-            console.log(`${"".padEnd(width)}  (repo: ${repoChainLabel(chain.source)})`);
+        return {
+            name: chain.name,
+            phases: chain.phases,
+            describe: chain.describe,
+            agentsLine: `agents: ${agents}${suites.length ? `  ·  quality suites: ${suites.join(", ")}${suiteNote}` : ""}`,
+            // `source` is undefined for every built-in — only a chain loaded from a
+            // `.spf/chains/*.yaml` file carries one (see chains/repo_chains.ts).
+            repoLabel: chain.source ? repoChainLabel(chain.source) : undefined,
+        };
+    });
+    const usageLines = [
+        `spf <name> "<prompt>" [--config <path>] [--adw-id <id>] [--cwd <dir>] [--suite <name>]   (spf run <name> ... works identically)`,
+        `spf watch polls a tracker and runs one of these chains per issue — spf doctor shows the current config.`,
+    ];
+    if (isInteractive()) {
+        const { renderChainList } = await import("../ui/reports.js");
+        await renderChainList(entries, usageLines);
+    }
+    else {
+        for (const entry of entries) {
+            console.log(`${entry.name.padEnd(width)}  ${entry.phases}`);
+            console.log(`${"".padEnd(width)}  ${entry.describe}`);
+            console.log(`${"".padEnd(width)}  ${entry.agentsLine}`);
+            if (entry.repoLabel)
+                console.log(`${"".padEnd(width)}  (repo: ${entry.repoLabel})`);
+            console.log();
         }
-        console.log();
+        for (const line of usageLines)
+            console.log(line);
     }
-    console.log(`spf <name> "<prompt>" [--config <path>] [--adw-id <id>] [--cwd <dir>] [--suite <name>]   (spf run <name> ... works identically)`);
-    console.log(`spf watch polls a tracker and runs one of these chains per issue — spf doctor shows the current config.`);
     // Every malformed `.spf/chains/*.yaml` file (bad YAML, a schema/params
     // mismatch, a name naming a step factory that doesn't exist) becomes a
     // problem here instead of a chain in the list above — loadRepoChains()

package/dist/cli/commands/phases.d.ts

@@ -1 +1 @@
-export declare function phasesCommand(argv: string[]): number;
+export declare function phasesCommand(argv: string[]): Promise<number>;

package/dist/cli/commands/phases.js

@@ -1,6 +1,7 @@
 import { parseCli } from "../../core/utils.js";
 import { openTrace } from "./trace.js";
-export function phasesCommand(argv) {
+import { isInteractive } from "../ask.js";
+export async function phasesCommand(argv) {
     const { positionals, options, flags } = parseCli(argv, ["cwd", "config"], ["json"]);
     if (positionals.length < 1) {
         console.error("usage: spf phases <adw_id> [--cwd <dir>] [--config <path>] [--json]");
@@ -17,9 +18,22 @@ export function phasesCommand(argv) {
         console.log(`no phases recorded for ${adwId}`);
         return 1;
     }
-    for (const p of rows) {
-        const marker = p.status === "success" ? "✓" : p.status === "fail" ? "✗" : "…";
-        console.log(`${String(p.seq).padStart(2, "0")} ${marker} ${(p.name ?? "").padEnd(20)} ${(p.kind ?? "").padEnd(9)} ${(p.owner ?? "").padEnd(12)} ${p.error ?? ""}`);
+    const table = rows.map((p) => [
+        String(p.seq).padStart(2, "0"),
+        p.status === "success" ? "✓" : p.status === "fail" ? "✗" : "…",
+        p.name ?? "",
+        p.kind ?? "",
+        p.owner ?? "",
+        p.error ?? "",
+    ]);
+    if (isInteractive()) {
+        const { renderTable } = await import("../ui/reports.js");
+        await renderTable(table, { rowColor: (i) => (rows[i].status === "fail" ? "red" : undefined) });
+    }
+    else {
+        for (const [seq, marker, name, kind, owner, error] of table) {
+            console.log(`${seq} ${marker} ${name.padEnd(20)} ${kind.padEnd(9)} ${owner.padEnd(12)} ${error}`);
+        }
     }
     return 0;
 }

package/dist/cli/commands/run.js

@@ -1,11 +1,12 @@
 /** Shared by both `spf <chain> "..."` and `spf run <chain> "..."` — same dispatch. */
 import * as paths from "../../core/paths.js";
+import * as agents from "../../core/agents.js";
 import { parseCli, resolvePrompt } from "../../core/utils.js";
 import { runChain } from "../../chains/index.js";
 import { isInteractive } from "../ask.js";
-const KNOWN_OPTIONS = ["config", "adw-id", "cwd", "agent", "base", "issue", "suite"];
+const KNOWN_OPTIONS = ["config", "adw-id", "cwd", "agent", "base", "issue", "suite", "priority"];
 export function usageFor(chain) {
-    return `usage: spf ${chain.name} "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id <id>] [--cwd <dir>] [--suite <name>]`;
+    return `usage: spf ${chain.name} "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id <id>] [--cwd <dir>] [--suite <name>] [--priority p0|p1|p2|p3]`;
 }
 export async function dispatchChain(chain, argv) {
     const { positionals, options } = parseCli(argv, KNOWN_OPTIONS);
@@ -52,5 +53,32 @@ export async function dispatchChain(chain, argv) {
         chainOptions["base"] = options["base"];
     if (options["suite"] !== undefined)
         chainOptions["suite"] = options["suite"];
+    // Only `refine`'s `publishIssues()` step reads this (a ceiling clamped
+    // onto every node it creates — see `core/refine.ts`'s `publish()`); every
+    // other chain ignores it, so it's harmless to always pass through, same
+    // as `issue` above. `publishIssues()` itself validates the value —
+    // rejecting anything but p0|p1|p2|p3 — so this stays a plain passthrough.
+    if (options["priority"] !== undefined)
+        chainOptions["priority"] = options["priority"];
+    // A live dashboard only ever makes sense for the one dispatch a human is
+    // actually watching — `spf watch`'s per-issue runs and `spf fanout`'s
+    // per-attempt runs go through `runChain`/`startRun` directly, never this
+    // function, so they're untouched. Loaded here (not left to `startRun`'s
+    // own `loadConfig` call moments later) purely to read the ceilings the
+    // dashboard displays — a second, cheap parse of the same small YAML, not
+    // a second source of truth: `startRun` still owns the real, validated
+    // config the run actually executes against.
+    if (isInteractive()) {
+        const { mountRunDashboard } = await import("../ui/run_dashboard.js");
+        const cfg = agents.loadConfig(ctx.config_paths);
+        const dashboard = mountRunDashboard({ maxCost: cfg.defaults.max_run_cost, maxTokens: cfg.defaults.max_run_tokens });
+        ctx.render_hooks = { sink: dashboard.sink, observer: dashboard.observer, pause: dashboard.pause, resume: dashboard.resume };
+        try {
+            return await runChain(chain, ctx, chainOptions);
+        }
+        finally {
+            await dashboard.close();
+        }
+    }
     return runChain(chain, ctx, chainOptions);
 }

package/dist/cli/commands/sessions.d.ts

@@ -1 +1 @@
-export declare function sessionsCommand(argv: string[]): number;
+export declare function sessionsCommand(argv: string[]): Promise<number>;

package/dist/cli/commands/sessions.js

@@ -1,6 +1,7 @@
 import { parseCli } from "../../core/utils.js";
 import { openTrace } from "./trace.js";
-export function sessionsCommand(argv) {
+import { isInteractive } from "../ask.js";
+export async function sessionsCommand(argv) {
     const { options, flags } = parseCli(argv, ["cwd", "config", "limit"], ["json"]);
     const { db } = openTrace(options);
     const limit = options["limit"] ? Number.parseInt(options["limit"], 10) : 20;
@@ -13,8 +14,15 @@ export function sessionsCommand(argv) {
         console.log("no sessions yet");
         return 0;
     }
-    for (const s of rows) {
-        console.log(`${s.adw_id}  ${(s.status ?? "").padEnd(8)}  ${s.started_at}  ${(s.request ?? "").slice(0, 60)}`);
+    const table = rows.map((s) => [s.adw_id, s.status ?? "", s.started_at ?? "", (s.request ?? "").slice(0, 60)]);
+    if (isInteractive()) {
+        const { renderTable } = await import("../ui/reports.js");
+        await renderTable(table);
+    }
+    else {
+        for (const [adwId, status, startedAt, request] of table) {
+            console.log(`${adwId}  ${status.padEnd(8)}  ${startedAt}  ${request}`);
+        }
     }
     return 0;
 }

package/dist/cli/commands/watch.d.ts

@@ -21,6 +21,14 @@ export declare function formatReviewDigest(review: ReviewOutputT): string;
  * 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 declare function watchInitCommand(argv: string[]): Promise<number>;
 export declare function watchCommand(argv: string[]): Promise<number>;