flowviant 0.38.0 → 0.39.0

package/bin/lib/live.mjs

@@ -44,12 +44,25 @@ import {
   clearWip,
 } from './git.mjs';
 import { applyPatch, fileDiffs, ownerCurrentBranch, withPatchLock } from './patch.mjs';
+import { RUNTIMES } from './runtimes.mjs';
 import { loadPreviewConfig, startPreview } from './preview.mjs';
 import { materializeInto, scrub as envScrub } from './env.mjs';
 
 // Register a branch preview's tunnel URL with Flowviant (fleet-authed). The
 // reviewer then drives it via "Open live preview" in the node.
 const LIVE_TARGET_URL = FLEET_URL.replace(/\/agents\/?$/, '/live-target');
+
+/**
+ * What a live session can build, sent on every claim.
+ *
+ * Read off the registry rather than written as `['claude']` so that the day a
+ * second runtime gains an SDK session, marking `live: true` there is the whole
+ * change — a hand-written list here would keep withholding its work and the
+ * reason would be three files away from the flag that looks like it decides.
+ */
+const LIVE_RUNTIMES = Object.values(RUNTIMES)
+  .filter((r) => r.live === true && r.mcp && r.args)
+  .map((r) => r.id);
 // Short TTL + a heartbeat that re-asserts while the tunnel is alive. So a live
 // preview stays linked indefinitely (survives long reviews), but one whose
 // daemon DIED ungracefully (no more heartbeats) drops off the card within the
@@ -568,7 +581,24 @@ export async function runLiveTask({
   sampleDiffstat,
   agentId,
 }) {
-  const claim = await mcpCall(mcpUrl, token, 'claim_next_task', {}).catch(() => null);
+  // SAY WHAT THIS WORKER CAN DRIVE. The claim is UNPINNED — this worker asks for
+  // whatever is next rather than for a named task — and that is deliberate (the
+  // roster hint is a prediction made before anything is claimed, so pinning to it
+  // would sometimes pin to the wrong task). The cost of not pinning is that the
+  // server decides, and until it was told, it decided using the MACHINE's
+  // capability report: on a box with Codex installed it would hand a
+  // codex-addressed task to this worker, which drives the Anthropic Agent SDK
+  // and nothing else, and Claude would build it. Nobody was told. The @mention is
+  // the only dispatch in this product, and silently answering it with a different
+  // CLI is the same class of bug as dispatching from the wrong surface.
+  //
+  // A live session is Claude-only by construction, not by configuration — it is
+  // an SDK, not a subprocess — so this list is exactly the runtimes marked
+  // `live` in the registry. An older server ignores the argument and behaves as
+  // before; that degrade is what `daemon:min` is for.
+  const claim = await mcpCall(mcpUrl, token, 'claim_next_task', {
+    runtimes: LIVE_RUNTIMES,
+  }).catch(() => null);
   if (!claim || claim.claimed !== true) return { outcome: 'nothing' };
   const { runId, intentId } = claim;
   const brief = claim.brief ?? {};

package/bin/lib/preflight.mjs

@@ -7,6 +7,7 @@
 import { execFileSync } from 'node:child_process';
 import { ok, warn, info, c } from './ui.mjs';
 import { addLocalBinToPath, promptYesNo, installClaude, installGh } from './install.mjs';
+import { RUNTIMES, detectRuntimes } from './runtimes.mjs';
 
 function present(cmd) {
   try {
@@ -28,28 +29,56 @@ function ghAuthed() {
 
 /** Prints a checklist and, when a missing prereq is auto-installable, OFFERS to
  *  install it (consent-based, never silent). Returns false only if a *fatal*
- *  prereq (claude, or git when worktrees are used) is still missing after. */
+ *  prereq (SOME drivable runtime, or git when worktrees are used) is still
+ *  missing after. */
 export async function preflight({ needGit = true } = {}) {
   addLocalBinToPath(); // find a gh/cloudflared we bundled on a previous run
-  let claude = present('claude');
   let gh = present('gh');
   const node18 = Number(process.versions.node.split('.')[0]) >= 18;
   const git = needGit ? present('git') : true;
 
   info('checking your setup (this tool drives these — it never sees their logins):');
 
-  // claude — fatal. Offer the official npm install (no-default: it's bigger and
-  // account-coupled, so we don't push it).
-  if (claude) {
-    ok(`claude installed ${c.dim('· must be signed in — run `claude` once if you haven’t')}`);
-  } else {
-    warn('claude NOT found — Claude Code is required.');
-    if (await promptYesNo('Install Claude Code now?', false)) {
-      if (installClaude((m) => info(m))) claude = present('claude');
+  // THE RUNTIMES. This used to test one binary — `present('claude')` — and treat
+  // its absence as fatal, which stopped being right the moment a second CLI could
+  // build a task: a machine with Codex and no Claude Code is a working machine,
+  // and it was refused at startup. What is fatal is having NOTHING to build with.
+  //
+  // Reported per runtime rather than as a single verdict, because the three
+  // states a user can be in need three different sentences: not installed
+  // (install it), installed but this daemon cannot drive it here (the live-mode
+  // note, or the registry's own `blocked` reason), and ready.
+  let detected = detectRuntimes({ refresh: true });
+  const shown = detected.filter((r) => r.installed || r.id === 'claude');
+  for (const r of shown) {
+    const rt = RUNTIMES[r.id];
+    if (r.dispatchable) {
+      ok(
+        `${rt.bin} installed ${c.dim(`· ${rt.label} · must be signed in — run \`${rt.login}\` once if you haven’t`)}`
+      );
+    } else if (r.installed) {
+      warn(`${rt.bin} installed but not usable here ${c.dim(`· ${r.blocked ?? 'unsupported'}`)}`);
+    } else if (r.id === 'claude') {
+      // Only Claude gets an install offer: it is the one whose installer we
+      // control and can verify. The others are named, not fetched.
+      warn('claude NOT found.');
+      if (await promptYesNo('Install Claude Code now?', false)) {
+        if (installClaude((m) => info(m))) detected = detectRuntimes({ refresh: true });
+      }
+      if (!detected.find((d) => d.id === 'claude')?.installed) {
+        warn('install Claude Code manually: https://claude.com/claude-code');
+      }
+    }
+  }
+  const drivable = detected.filter((r) => r.dispatchable);
+  // Name the alternatives once, and only when there is nothing to build with —
+  // a working machine does not need a catalogue of the CLIs it is not using.
+  if (drivable.length === 0) {
+    for (const rt of Object.values(RUNTIMES)) {
+      if (!detected.find((d) => d.id === rt.id)?.installed) {
+        info(`${c.dim(`or ${rt.label}: ${rt.install}`)}`);
+      }
     }
-    claude
-      ? ok('claude installed — run `claude` once to sign in')
-      : warn('install Claude Code manually: https://claude.com/claude-code');
   }
 
   // gh — needed to open PRs. Offer to fetch the isolated binary (yes-default:
@@ -72,6 +101,8 @@ export async function preflight({ needGit = true } = {}) {
   node18 ? ok(`node ${process.versions.node}`) : warn(`node ${process.versions.node} — need 18+`);
   console.log('');
 
-  if (!claude) warn('Without `claude` nothing can run — install + sign in, then restart.');
-  return claude && git;
+  if (drivable.length === 0) {
+    warn('No usable coding CLI — install and sign in to one of the above, then restart.');
+  }
+  return drivable.length > 0 && git;
 }

package/bin/lib/runtimes.mjs

@@ -31,7 +31,7 @@ import { execFileSync } from 'node:child_process';
 import { mkdtempSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { SAFE, MODEL, USER_AGENT } from './config.mjs';
+import { SAFE, MODEL, USER_AGENT, LIVE } from './config.mjs';
 
 /** Truncate for a one-line activity label. */
 const oneLine = (s, n = 140) =>
@@ -316,6 +316,29 @@ export const DISPATCHABLE = Object.values(RUNTIMES).filter((r) => r.mcp && r.arg
 
 export const runtimeById = (id) => RUNTIMES[id] ?? RUNTIMES.claude;
 
+/**
+ * Can the worker this daemon is running actually DRIVE this runtime right now?
+ *
+ * `dispatchable` answers "is the CLI installed and does this module know how to
+ * spawn it" — a fact about the machine. This answers a narrower question about
+ * THIS PROCESS, and the two came apart the moment live mode became the default.
+ *
+ * Live mode does not spawn a CLI at all: it drives the Anthropic Agent SDK
+ * in-process, which is why `claude.live` is the only `true` in the registry. So
+ * on a machine with Codex installed, `dispatchable` says codex and the live
+ * worker still cannot build a codex task — and it was claiming them anyway and
+ * building them with Claude, because a claim that names no runtime gets whatever
+ * is next in line.
+ *
+ * Reporting drivability rather than installation is what makes the app's answer
+ * true: "this machine cannot drive Codex" is a fact the user can act on (restart
+ * with FLOWVIANT_POLL=1, or wait for the live subprocess path), where "Codex is
+ * installed" plus a task that never starts is a mystery. Activity, never
+ * aspiration.
+ */
+export const drivableHere = (rt) =>
+  Boolean(rt.mcp && rt.args) && (LIVE ? rt.live === true : true);
+
 // ── Detection ──────────────────────────────────────────────────────────────
 
 /**
@@ -355,8 +378,15 @@ export function detectRuntimes({ refresh = false } = {}) {
       version,
       // Installed and drivable are different questions, and conflating them is
       // how a user ends up @mentioning something that silently never starts.
-      dispatchable: version !== null && Boolean(rt.mcp && rt.args),
-      blocked: rt.blocked ?? null,
+      // THREE questions, in fact — see `drivableHere`: the CLI can be installed,
+      // and this module can know how to spawn it, and the worker this daemon is
+      // running can still be unable to drive it.
+      dispatchable: version !== null && drivableHere(rt),
+      blocked:
+        rt.blocked ??
+        (version !== null && Boolean(rt.mcp && rt.args) && !drivableHere(rt)
+          ? 'this daemon is in live mode, which drives Claude in-process — run with FLOWVIANT_POLL=1 to build with this CLI'
+          : null),
     };
   });
   return detectedCache;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "flowviant",
-  "version": "0.38.0",
-  "description": "Run your own coding CLIs as headless build agents for Flowviant \u2014 Claude Code or Codex, on your own credentials. Claims dispatched work, opens PRs, captures review evidence, and routes questions back to you.",
+  "version": "0.39.0",
+  "description": "Run your own coding CLIs as headless build agents for Flowviant — Claude Code or Codex, on your own credentials. Claims dispatched work, opens PRs, captures review evidence, and routes questions back to you.",
   "type": "module",
   "bin": {
     "flowviant": "bin/cli.mjs"