@gr8ful/spf 0.14.0 → 0.16.0

package/dist/cli/commands/loop.js

@@ -1,23 +1,3 @@
-/**
- * `spf loop <chain> "<goal>" --until-suite <name> --max N` — the wiring half
- * of `core/loop.ts` (which owns the driver, the ledger, and the breakers):
- * config, the issue fetch for `--issue`, the per-iteration `runChain`
- * dispatch, the sqlite readback, and the final table. Same split as
- * `core/fanout.ts` / `cli/commands/fanout.ts` for the same reason — `core/`
- * stays out of `src/chains/`'s dependency direction, so the driver is
- * testable with no chains, no agents, no real git.
- *
- * `--issue <id>` resolves the SAME `IssueProvider` `spf watch` does
- * (`resolveIssueProvider`, exported from `watch.ts` for exactly this reuse)
- * and builds the goal prompt the same way `core/watch.ts`'s `runIssue` does
- * — `${issue.title}\n\n${issue.body}`.trim() — so a ticket-pointed loop and
- * a hand-typed one share one prompt convention. This is deliberately the
- * ONLY thing `--issue` does: it does not claim, label, or comment on the
- * issue, and no daemon watches it. Filing the goal AS a ticket the daemon
- * picks up on its own is a different, larger feature (a `goal-ready` watch
- * lane) that needs its own crash-safe marker schema and is not this.
- */
-import { existsSync } from "node:fs";
 import * as agents from "../../core/agents.js";
 import * as paths from "../../core/paths.js";
 import * as quality from "../../core/quality.js";
@@ -43,8 +23,13 @@ function qualityRunLike(input) {
         phases: [{ phase_id: `${input.adwId}_00_loop_stop`, adw_id: input.adwId, seq: 0, params: { name: "loop_stop", kind: "code", owner: "quality", description: "loop stop check", retries: 0 }, status: "running", attempt: 0 }],
         context_handoff_dir: input.contextHandoffDir,
         repo_root: input.repoRoot,
-        console: { note: (message) => console.log(`[spf] loop    ${message}`) },
-        tracer: { event: () => "" },
+        console: {
+            note: (message) => {
+                console.log(`[spf] loop    ${message}`);
+                return Promise.resolve();
+            },
+        },
+        tracer: { event: () => Promise.resolve("") },
         adw_id: input.adwId,
     };
 }
@@ -154,23 +139,37 @@ export async function loopCommand(argv) {
         // total, not for deciding correctness.
         let tokens = 0;
         let cost = 0;
-        if (existsSync(dataPaths.db_path)) {
-            const db = new SfDb(dataPaths.db_path);
-            try {
-                const session = db.session(iteration.adw_id);
-                tokens = session?.total_tokens ?? 0;
-                cost = session?.total_cost ?? 0;
-            }
-            finally {
-                db.close();
+        // `SfDb.exists` covers both backends: `existsSync(dataPaths.db_path)`
+        // for local sqlite, and a cheap `sqlite_master` probe (false, not a
+        // throw, when the table isn't there yet) for d1. Both the existence
+        // check and the read itself are inside this loop's own try/catch —
+        // `runIteration` is documented as never throwing (see loop.ts's header),
+        // and a D1 hiccup reaching this readback must rank as zero, not abort
+        // the iteration, the same "never throw, rank as zero" discipline
+        // `fanout.ts`'s `readMetrics` already uses.
+        try {
+            if (await SfDb.exists(dataPaths)) {
+                const db = await SfDb.open(dataPaths.db, dataPaths.sessions_dir);
+                try {
+                    const session = await db.session(iteration.adw_id);
+                    tokens = session?.total_tokens ?? 0;
+                    cost = session?.total_cost ?? 0;
+                }
+                finally {
+                    await db.close();
+                }
             }
         }
+        catch {
+            // best-effort readback only — tokens/cost simply stay 0 for this
+            // iteration's ledger row.
+        }
         let commitSha = null;
         let stopVerdict = null;
         if (exitCode === 0 && error === null) {
             const git = makeGit(anchor.repo_root);
             commitSha = git.shortSha();
-            const result = quality.runSuite(qualityRunLike({ cfg, repoRoot: anchor.repo_root, contextHandoffDir: dataPaths.sessions_dir, adwId: iteration.adw_id }), stop.suite);
+            const result = await quality.runSuite(qualityRunLike({ cfg, repoRoot: anchor.repo_root, contextHandoffDir: dataPaths.sessions_dir, adwId: iteration.adw_id }), stop.suite);
             stopVerdict = { passed: result.passed, failures: result.failures, artifacts: result.artifacts };
         }
         return { exit_code: exitCode, error, commit_sha: commitSha, tokens, cost, stop_verdict: stopVerdict };

package/dist/cli/commands/migrate.js

@@ -101,7 +101,14 @@ export function migrateCommand(argv) {
             }
         }
     });
-    const oldDbPath = resolveOld(oldConfig?.observability?.db ?? "adws/adw_data/spf.db");
+    // `observability.db` predates this schema's `{kind:"sqlite"|"d1",...}`
+    // object form (SPF #66) — a stamped `adws/` tree can only ever have written
+    // a bare path here, but a `typeof` guard costs nothing and keeps a
+    // legacy-config-carrying-a-d1-shaped-object from crashing `path.resolve()`
+    // with a TypeError, same explicit non-string handling `abort.ts` gives a
+    // d1-backed repo rather than letting it fail deep inside a file op.
+    const oldDbRaw = oldConfig?.observability?.db;
+    const oldDbPath = resolveOld(typeof oldDbRaw === "string" ? oldDbRaw : "adws/adw_data/spf.db");
     const oldSessionsDir = path.join(path.dirname(oldDbPath), "sessions");
     if (existsSync(oldDbPath)) {
         actions.push({ kind: "copy-file", detail: `${path.relative(anchor.repo_root, oldDbPath)} -> ${newDbRel} (WAL-checkpointed first)` });

package/dist/cli/commands/phases.js

@@ -8,8 +8,8 @@ export async function phasesCommand(argv) {
         return 1;
     }
     const adwId = positionals[0];
-    const { db } = openTrace(options);
-    const rows = db.phases(adwId);
+    const { db } = await openTrace(options);
+    const rows = await db.phases(adwId);
     if (flags["json"]) {
         console.log(JSON.stringify(rows, null, 2));
         return 0;

package/dist/cli/commands/sessions.js

@@ -3,9 +3,9 @@ import { openTrace } from "./trace.js";
 import { isInteractive } from "../ask.js";
 export async function sessionsCommand(argv) {
     const { options, flags } = parseCli(argv, ["cwd", "config", "limit"], ["json"]);
-    const { db } = openTrace(options);
+    const { db } = await openTrace(options);
     const limit = options["limit"] ? Number.parseInt(options["limit"], 10) : 20;
-    const rows = db.sessions(limit);
+    const rows = await db.sessions(limit);
     if (flags["json"]) {
         console.log(JSON.stringify(rows, null, 2));
         return 0;

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

@@ -8,19 +8,39 @@ export interface TraceHandle {
     /** Already loaded by this same resolution — `spf estimate` needs it (ceilings, resolveTiering) and reusing it means one loadConfig, not two. */
     cfg: SFConfig;
 }
-export declare function openTrace(options: Record<string, string>): TraceHandle;
 /**
- * Like `openTrace`, but never throws on a missing db file: `db` is `null`
- * in that one slot instead. `anchor`/`dataDir`/`cfg` still come from the
- * SAME `resolveTrace` call either way — a cold start (no `spf.db` yet)
- * still carries a real, loaded `cfg`, which is what lets `spf estimate`
- * echo `defaults.max_run_tokens`/`max_run_cost` and resolve planned routing
+ * The one place anchor/config/data-path resolution happens, so `openTrace`
+ * and `openTraceIfExists` cannot diverge on it. Exported (not just used
+ * internally) so a caller that needs to inspect `dataPaths.db.kind` BEFORE
+ * deciding whether to open anything at all — `abort.ts`'s d1 guard — can
+ * reuse this exact resolution instead of a second, divergence-prone copy.
+ */
+export declare function resolveTrace(options: Record<string, string>): {
+    dataPaths: paths.DataPaths;
+    anchor: paths.RepoAnchor;
+    dataDir: string;
+    cfg: SFConfig;
+};
+export declare function openTrace(options: Record<string, string>): Promise<TraceHandle>;
+/**
+ * Like `openTrace`, but never throws on a db that has never been written
+ * to: `db` is `null` in that one slot instead. `anchor`/`dataDir`/`cfg`
+ * still come from the SAME `resolveTrace` call either way — a cold start
+ * (no `spf.db` yet, or a fresh D1 database with no `sessions` table) still
+ * carries a real, loaded `cfg`, which is what lets `spf estimate` echo
+ * `defaults.max_run_tokens`/`max_run_cost` and resolve planned routing
  * before it exits, rather than crashing with `SfDb`'s "point spf ui at a
  * target repo" message (which is about `spf ui`, not `spf estimate`).
+ *
+ * `SfDb.exists` covers both backends: `existsSync(dataPaths.db_path)` for
+ * local sqlite, and a cheap `sqlite_master` probe (false, not a throw, when
+ * the `sessions` table isn't there yet) for d1 — so `spf estimate`'s
+ * documented cold-start path (report + exit 3) actually reaches on a fresh
+ * D1 repo instead of crashing.
  */
-export declare function openTraceIfExists(options: Record<string, string>): {
+export declare function openTraceIfExists(options: Record<string, string>): Promise<{
     db: SfDb | null;
     anchor: paths.RepoAnchor;
     dataDir: string;
     cfg: SFConfig;
-};
+}>;

package/dist/cli/commands/trace.js

@@ -1,29 +1,42 @@
 /** Shared by sessions/phases/events/abort/estimate — resolve the workspace and open its trace db. */
-import { existsSync } from "node:fs";
 import * as agents from "../../core/agents.js";
 import * as paths from "../../core/paths.js";
 import { SfDb } from "../../ui/server/db.js";
-/** The one place anchor/config/data-path resolution happens, so `openTrace` and `openTraceIfExists` cannot diverge on it. */
-function resolveTrace(options) {
+/**
+ * The one place anchor/config/data-path resolution happens, so `openTrace`
+ * and `openTraceIfExists` cannot diverge on it. Exported (not just used
+ * internally) so a caller that needs to inspect `dataPaths.db.kind` BEFORE
+ * deciding whether to open anything at all — `abort.ts`'s d1 guard — can
+ * reuse this exact resolution instead of a second, divergence-prone copy.
+ */
+export function resolveTrace(options) {
     const anchor = paths.resolveAnchor(options["cwd"]);
     const cfg = agents.loadConfig(paths.resolveConfigPaths(anchor, options["config"]).paths);
     const dataPaths = paths.resolveDataPaths(anchor, cfg.defaults.data_dir, cfg.observability.db);
-    return { dbPath: dataPaths.db_path, anchor, dataDir: dataPaths.data_dir, cfg };
+    return { dataPaths, anchor, dataDir: dataPaths.data_dir, cfg };
 }
-export function openTrace(options) {
-    const { dbPath, anchor, dataDir, cfg } = resolveTrace(options);
-    return { db: new SfDb(dbPath), anchor, dataDir, cfg };
+export async function openTrace(options) {
+    const { dataPaths, anchor, dataDir, cfg } = resolveTrace(options);
+    return { db: await SfDb.open(dataPaths.db, dataPaths.sessions_dir), anchor, dataDir, cfg };
 }
 /**
- * Like `openTrace`, but never throws on a missing db file: `db` is `null`
- * in that one slot instead. `anchor`/`dataDir`/`cfg` still come from the
- * SAME `resolveTrace` call either way — a cold start (no `spf.db` yet)
- * still carries a real, loaded `cfg`, which is what lets `spf estimate`
- * echo `defaults.max_run_tokens`/`max_run_cost` and resolve planned routing
+ * Like `openTrace`, but never throws on a db that has never been written
+ * to: `db` is `null` in that one slot instead. `anchor`/`dataDir`/`cfg`
+ * still come from the SAME `resolveTrace` call either way — a cold start
+ * (no `spf.db` yet, or a fresh D1 database with no `sessions` table) still
+ * carries a real, loaded `cfg`, which is what lets `spf estimate` echo
+ * `defaults.max_run_tokens`/`max_run_cost` and resolve planned routing
  * before it exits, rather than crashing with `SfDb`'s "point spf ui at a
  * target repo" message (which is about `spf ui`, not `spf estimate`).
+ *
+ * `SfDb.exists` covers both backends: `existsSync(dataPaths.db_path)` for
+ * local sqlite, and a cheap `sqlite_master` probe (false, not a throw, when
+ * the `sessions` table isn't there yet) for d1 — so `spf estimate`'s
+ * documented cold-start path (report + exit 3) actually reaches on a fresh
+ * D1 repo instead of crashing.
  */
-export function openTraceIfExists(options) {
-    const { dbPath, anchor, dataDir, cfg } = resolveTrace(options);
-    return { db: existsSync(dbPath) ? new SfDb(dbPath) : null, anchor, dataDir, cfg };
+export async function openTraceIfExists(options) {
+    const { dataPaths, anchor, dataDir, cfg } = resolveTrace(options);
+    const db = (await SfDb.exists(dataPaths)) ? await SfDb.open(dataPaths.db, dataPaths.sessions_dir) : null;
+    return { db, anchor, dataDir, cfg };
 }

package/dist/cli/commands/ui.js

@@ -6,23 +6,33 @@ import { runUi } from "../../ui/server/serve.js";
 export async function uiCommand(argv) {
     const { options, flags } = parseCli(argv, ["cwd", "config", "db", "port"], ["no-open"]);
     const anchor = paths.resolveAnchor(options["cwd"]);
-    let dbPath;
+    let db;
+    let sessionsDir;
+    let label;
     if (options["db"]) {
-        dbPath = path.resolve(anchor.cwd, options["db"]);
+        // `--db <path>` always names a local sqlite file — there is no D1
+        // equivalent of "point at this one file" from the CLI yet.
+        const dbPath = path.resolve(anchor.cwd, options["db"]);
+        db = { kind: "sqlite", path: dbPath };
+        label = dbPath;
     }
     else {
         const cfg = agents.loadConfig(paths.resolveConfigPaths(anchor, options["config"]).paths);
-        dbPath = paths.resolveDataPaths(anchor, cfg.defaults.data_dir, cfg.observability.db).db_path;
+        const dataPaths = paths.resolveDataPaths(anchor, cfg.defaults.data_dir, cfg.observability.db);
+        db = dataPaths.db;
+        sessionsDir = dataPaths.sessions_dir;
+        label = db.kind === "sqlite" ? db.path : `d1:${db.database_id}`;
     }
     try {
         const handle = await runUi({
-            dbPath,
+            db,
+            sessionsDir,
             webDir: paths.WEB_DIR,
             port: options["port"] ? Number.parseInt(options["port"], 10) : undefined,
             open: !flags["no-open"],
         });
         console.log(`[spf] ui        ${handle.url}`);
-        console.log(`[spf] db        ${dbPath}`);
+        console.log(`[spf] db        ${label}`);
         // runUi() already registers SIGINT/SIGTERM handlers that exit the
         // process; just keep this call from returning until then.
         await new Promise(() => { });

package/dist/cli/commands/watch.js

@@ -100,7 +100,7 @@ export function resolveIssueProvider(cfg) {
             console.error('GITHUB_TOKEN is not set — spf watch needs a classic PAT with "repo" scope (or "public_repo" for a public-only repo). See README.md\'s "GITHUB_TOKEN scope" section.');
             return null;
         }
-        return new GitHubProvider(repo, cfg.watch.label_prefix, token);
+        return new GitHubProvider(repo, cfg.watch.label_prefix, token, cfg.watch.github.project_number, cfg.watch.github.status_map);
     }
     if (cfg.watch.issue_provider === "jira") {
         if (!cfg.watch.jira.base_url.trim() || !cfg.watch.jira.project_key.trim()) {
@@ -113,7 +113,7 @@ export 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, cfg.watch.jira.issue_types);
+        return new JiraProvider(cfg.watch.jira.base_url, cfg.watch.jira.project_key, cfg.watch.label_prefix, email, token, cfg.watch.jira.issue_types, cfg.watch.jira.status_map);
     }
     console.error(`watch.issue_provider ${JSON.stringify(cfg.watch.issue_provider)} is not supported`);
     return null;
@@ -136,7 +136,7 @@ function resolveCodeHostProvider(cfg) {
             console.error('GITHUB_TOKEN is not set — spf watch needs a classic PAT with "repo" scope (or "public_repo" for a public-only repo). See README.md\'s "GITHUB_TOKEN scope" section.');
             return null;
         }
-        return new GitHubProvider(cfg.watch.repo, cfg.watch.label_prefix, token);
+        return new GitHubProvider(cfg.watch.repo, cfg.watch.label_prefix, token, cfg.watch.github.project_number, cfg.watch.github.status_map);
     }
     if (cfg.watch.code_host === "bitbucket") {
         const email = process.env["BITBUCKET_EMAIL"];
@@ -196,17 +196,35 @@ export async function watchInitCommand(argv) {
         if (checks.some((c) => !c.exists))
             return 1;
     }
+    if (cfg.watch.issue_provider === "jira" && provider instanceof JiraProvider && Object.values(cfg.watch.jira.status_map).some(Boolean)) {
+        const checks = await provider.validateStatusMap();
+        console.log(`\nvalidating watch.jira.status_map against ${cfg.watch.jira.project_key}:`);
+        for (const c of checks) {
+            console.log(`  ${c.exists ? "✓" : "✗"} ${c.state} → ${c.jiraStatus}${c.exists ? "" : ` — no status named "${c.jiraStatus}" in ${cfg.watch.jira.project_key}`}`);
+        }
+        if (checks.some((c) => !c.exists))
+            return 1;
+    }
+    if (cfg.watch.issue_provider === "github" && provider instanceof GitHubProvider && Object.values(cfg.watch.github.status_map).some(Boolean)) {
+        const checks = await provider.validateStatusMap();
+        console.log(`\nvalidating watch.github.status_map against Projects v2 #${cfg.watch.github.project_number}:`);
+        for (const c of checks) {
+            console.log(`  ${c.exists ? "✓" : "✗"} ${c.state} → ${c.githubStatus}${c.exists ? "" : ` — no Status option named "${c.githubStatus}" on Projects v2 #${cfg.watch.github.project_number}`}`);
+        }
+        if (checks.some((c) => !c.exists))
+            return 1;
+    }
     return 0;
 }
 /** Shared by `runChain`/`runRefine`/the fan-out lane's dispatch: best-effort enrichment of a generic "didn't succeed" message with the first phase that actually failed, read back from the worktree's own (symlinked) trace db. Top-level (not a `watchCommand` local) so `makeWatchFanoutDispatch` below can share it — see that factory's own doc comment for why. */
-function detailFromFailedPhase(cfg, cwd, adwId, prefix) {
+async function detailFromFailedPhase(cfg, cwd, adwId, prefix) {
     let detail = prefix;
     let db;
     try {
         const wtAnchor = paths.resolveAnchor(cwd);
         const wtDataPaths = paths.resolveDataPaths(wtAnchor, cfg.defaults.data_dir, cfg.observability.db);
-        db = new SfDb(wtDataPaths.db_path);
-        const failed = db.phases(adwId).find((p) => p.status === "fail");
+        db = await SfDb.open(wtDataPaths.db, wtDataPaths.sessions_dir);
+        const failed = (await db.phases(adwId)).find((p) => p.status === "fail");
         if (failed)
             detail += ` Phase "${failed.name}" failed: ${failed.error ?? "(no detail)"}`;
     }
@@ -214,7 +232,7 @@ function detailFromFailedPhase(cfg, cwd, adwId, prefix) {
         // best-effort — the generic message above still points at where to look
     }
     finally {
-        db?.close();
+        await db?.close();
     }
     return detail;
 }
@@ -227,14 +245,13 @@ function detailFromFailedPhase(cfg, cwd, adwId, prefix) {
  * is a nice-to-have, not something that gets to block the PR-open flow
  * it's decorating. Top-level for the same reason as `detailFromFailedPhase`.
  */
-function reviewSummaryFor(cfg, cwd, adwId) {
+async function reviewSummaryFor(cfg, cwd, adwId) {
     let db;
     try {
         const wtAnchor = paths.resolveAnchor(cwd);
         const wtDataPaths = paths.resolveDataPaths(wtAnchor, cfg.defaults.data_dir, cfg.observability.db);
-        db = new SfDb(wtDataPaths.db_path);
-        const envelope = db
-            .envelopes(adwId)
+        db = await SfDb.open(wtDataPaths.db, wtDataPaths.sessions_dir);
+        const envelope = (await db.envelopes(adwId))
             .filter((e) => e.output_type === ReviewOutput.name)
             .at(-1); // the LATEST verdict — a revise loop can produce several
         if (!envelope?.payload_json)
@@ -246,7 +263,7 @@ function reviewSummaryFor(cfg, cwd, adwId) {
         return undefined; // best-effort — see the doc comment above
     }
     finally {
-        db?.close();
+        await db?.close();
     }
 }
 /**
@@ -291,14 +308,14 @@ export function makeWatchFanoutDispatch(cfg, configPaths, dataPaths, chainDef) {
      * a shared handle in — the same per-call shape `detailFromFailedPhase`/
      * `reviewSummaryFor` above already use against the same WAL db.
      */
-    const readMetrics = (adwId) => {
-        if (!existsSync(dataPaths.db_path))
-            return { gate_passes: 0, gate_failures: 0, cost: 0, tokens: 0 };
+    const readMetrics = async (adwId) => {
         let db;
         try {
-            db = new SfDb(dataPaths.db_path);
-            const gates = db.gates(adwId);
-            const session = db.session(adwId);
+            if (!(await SfDb.exists(dataPaths)))
+                return { gate_passes: 0, gate_failures: 0, cost: 0, tokens: 0 };
+            db = await SfDb.open(dataPaths.db, dataPaths.sessions_dir);
+            const gates = await db.gates(adwId);
+            const session = await db.session(adwId);
             // `passed` is a SQLite integer boolean that CAN be NULL on a row an
             // older tracer wrote. Counted explicitly in both directions, never as
             // `!g.passed`: a NULL is unknown, and letting it read as a failure
@@ -314,7 +331,7 @@ export function makeWatchFanoutDispatch(cfg, configPaths, dataPaths, chainDef) {
             return { gate_passes: 0, gate_failures: 0, cost: 0, tokens: 0 };
         }
         finally {
-            db?.close();
+            await db?.close();
         }
     };
     /**
@@ -323,24 +340,25 @@ export function makeWatchFanoutDispatch(cfg, configPaths, dataPaths, chainDef) {
      * candidate id. Safe direction is FALSE (see `WatchFanoutDeps.adwIdsFree`'s
      * own doc comment): an unreadable db reports "taken" rather than "free".
      */
-    const adwIdsFree = (adwIds) => {
-        if (!existsSync(dataPaths.db_path))
-            return true; // no db yet — nothing to collide with
+    const adwIdsFree = async (adwIds) => {
         let db;
         try {
-            db = new SfDb(dataPaths.db_path);
-            return adwIds.every((id) => db.session(id) === null);
+            if (!(await SfDb.exists(dataPaths)))
+                return true; // no db yet — nothing to collide with
+            db = await SfDb.open(dataPaths.db, dataPaths.sessions_dir);
+            const results = await Promise.all(adwIds.map((id) => db.session(id)));
+            return results.every((session) => session === null);
         }
         catch {
             return false;
         }
         finally {
-            db?.close();
+            await db?.close();
         }
     };
-    const reviewFor = (opts) => ({
+    const reviewFor = async (opts) => ({
         reviewRequired: resolveRequiredAgents(chainDef, opts.chainOptions).includes("reviewer"),
-        reviewSummary: reviewSummaryFor(cfg, opts.cwd, opts.adwId),
+        reviewSummary: await reviewSummaryFor(cfg, opts.cwd, opts.adwId),
     });
     return { runAttempt, readMetrics, adwIdsFree, reviewFor };
 }
@@ -396,6 +414,49 @@ export async function watchCommand(argv) {
             }
         }
     }
+    // watch.jira.status_map applies to every build-lane transition, independent
+    // of watch.refine.enabled — validated at startup for the same reason
+    // issue_types is: a bad status name should stop the daemon before it
+    // starts, not fail silently (well, log-and-skip — see jira_provider.ts's
+    // syncStatus()) on every single transition once it's running. Silent when
+    // status_map is empty (the default, opt-in feature) or has no mismatches.
+    if (cfg.watch.issue_provider === "jira" && provider instanceof JiraProvider) {
+        const configured = Object.values(cfg.watch.jira.status_map).some(Boolean);
+        if (configured) {
+            const checks = await provider.validateStatusMap();
+            const mismatches = checks.filter((c) => !c.exists);
+            if (mismatches.length > 0) {
+                console.error(`watch.jira.status_map has ${mismatches.length} mismatch(es) against ${cfg.watch.jira.project_key}:`);
+                for (const c of checks) {
+                    console.error(`  ${c.exists ? "✓" : "✗"} ${c.state} → ${c.jiraStatus}${c.exists ? "" : ` — no status named "${c.jiraStatus}" in ${cfg.watch.jira.project_key}`}`);
+                }
+                console.error(`Fix watch.jira.status_map, or the project's statuses, before running spf watch unattended. Run \`spf watch init\` any time to re-check.`);
+                return 1;
+            }
+        }
+    }
+    // watch.github.status_map applies to every build-lane transition,
+    // independent of watch.refine.enabled — validated at startup for the same
+    // reason watch.jira.issue_types is: a bad Status option name should stop
+    // the daemon before it starts, not fail silently (well, log-and-skip —
+    // see github_provider.ts's syncStatus()) on every single transition once
+    // it's running. Silent when status_map is empty (the default, opt-in
+    // feature) or has no mismatches.
+    if (cfg.watch.issue_provider === "github" && provider instanceof GitHubProvider) {
+        const configured = Object.values(cfg.watch.github.status_map).some(Boolean);
+        if (configured) {
+            const checks = await provider.validateStatusMap();
+            const mismatches = checks.filter((c) => !c.exists);
+            if (mismatches.length > 0) {
+                console.error(`watch.github.status_map has ${mismatches.length} mismatch(es) against Projects v2 #${cfg.watch.github.project_number}:`);
+                for (const c of checks) {
+                    console.error(`  ${c.exists ? "✓" : "✗"} ${c.state} → ${c.githubStatus}${c.exists ? "" : ` — no Status option named "${c.githubStatus}" on Projects v2 #${cfg.watch.github.project_number}`}`);
+                }
+                console.error(`Fix watch.github.status_map (and watch.github.project_number), or the project's Status options, before running spf watch unattended. Run \`spf watch init\` any time to re-check.`);
+                return 1;
+            }
+        }
+    }
     // watch.fanout.n > 1 startup gates — all guarded so watch.fanout.n: 1 (the
     // default) reaches none of them, and a bad configuration stops the daemon
     // before it starts rather than failing silently every tick.
@@ -525,9 +586,9 @@ export async function watchCommand(argv) {
         // is reflected here too, not just each chain's static/YAML default.
         const reviewRequired = resolveRequiredAgents(chainDef, opts.chainOptions).includes("reviewer");
         if (code === 0) {
-            return { accepted: true, adwId: opts.adwId, detail: "", reviewRequired, reviewSummary: reviewSummaryFor(cfg, opts.cwd, opts.adwId) };
+            return { accepted: true, adwId: opts.adwId, detail: "", reviewRequired, reviewSummary: await reviewSummaryFor(cfg, opts.cwd, opts.adwId) };
         }
-        const detail = detailFromFailedPhase(cfg, opts.cwd, opts.adwId, `Chain "${cfg.watch.chain}" (adw_id ${opts.adwId}) did not complete successfully. Run \`spf phases ${opts.adwId} --cwd ${opts.cwd}\` for detail.`);
+        const detail = await detailFromFailedPhase(cfg, opts.cwd, opts.adwId, `Chain "${cfg.watch.chain}" (adw_id ${opts.adwId}) did not complete successfully. Run \`spf phases ${opts.adwId} --cwd ${opts.cwd}\` for detail.`);
         return { accepted: false, adwId: opts.adwId, detail, reviewRequired };
     };
     /**
@@ -559,7 +620,7 @@ export async function watchCommand(argv) {
         // comment for the KNOWN LIMITATION this fixes.
         const code = await withRunScope(opts.adwId, () => runChainDef(chainDef, ctx, opts.chainOptions));
         if (code !== 0) {
-            const detail = detailFromFailedPhase(cfg, opts.cwd, opts.adwId, `Refine chain "${cfg.watch.refine.chain}" (adw_id ${opts.adwId}) did not complete successfully. Run \`spf phases ${opts.adwId} --cwd ${opts.cwd}\` for detail.`);
+            const detail = await detailFromFailedPhase(cfg, opts.cwd, opts.adwId, `Refine chain "${cfg.watch.refine.chain}" (adw_id ${opts.adwId}) did not complete successfully. Run \`spf phases ${opts.adwId} --cwd ${opts.cwd}\` for detail.`);
             return { accepted: false, adwId: opts.adwId, detail, created: [], questions: [], split: [] };
         }
         const wtAnchor = paths.resolveAnchor(opts.cwd);

package/dist/cli/index.js

@@ -8,6 +8,7 @@ import path from "node:path";
 import * as agents from "../core/agents.js";
 import * as agentCc from "../core/agent_cc.js";
 import * as agentFlue from "../core/agent_flue.js";
+import * as agentOpencode from "../core/agent_opencode.js";
 import * as notify from "../core/notify/notifier.js";
 import * as otel from "../core/otel.js";
 import * as paths from "../core/paths.js";
@@ -212,7 +213,7 @@ export async function main() {
                 process.exitCode = await eventsCommand(rest);
                 return;
             case "abort":
-                process.exitCode = abortCommand(rest);
+                process.exitCode = await abortCommand(rest);
                 return;
             default: {
                 const chain = findChain(cmd);
@@ -243,6 +244,7 @@ export async function main() {
         // agent_cc.ts's shutdown() just kills any still-running claude children.
         await agentFlue.shutdown();
         await agentCc.shutdown();
+        await agentOpencode.shutdown();
         // Belt-and-braces alongside the per-run `sandbox.withRunScope` wraps in
         // dispatchChain/watch/fanout: catches any sandboxed run's lease this
         // process still holds when the CLI exits (a per-run wrap that itself

package/dist/cli/interview.d.ts

@@ -6,6 +6,7 @@ export interface DetectedContext {
     gitName?: string;
     scripts: Record<string, string>;
     claudeOnPath: boolean;
+    opencodeOnPath: boolean;
     /** Whatever's already in `.env` — shown masked so a re-run can offer "keep current" instead of asking blind. */
     existingEnv: Map<string, string>;
     /** The packaged roster's agent names (planner, builder, scout, reviewer, documenter today) — read from the built-in config so a 6th agent added there needs no interview change. */