flowviant 0.7.0 → 0.8.1

package/README.md

@@ -38,14 +38,16 @@ Prefer an explicit token? Create a fleet credential in the app and pass it direc
 FLOWVIANT_FLEET=fva_… npx flowviant
 ```
 
-## Live mode (opt-in)
+## Live mode (the default)
+
+Each task runs a **persistent** Claude session you can talk to mid-task from the app: the agent streams its work into the task's conversation, you `@`-mention it to steer or answer questions, and it resumes in place. Blockers park the session at zero cost until you answer. When it finishes, it posts a delivery card (summary + checklist self-report) in the thread — a human confirms done by merging there.
+
+Prefer the legacy one-shot poll mode (no streaming, no previews)? Escape hatch:
 
 ```bash
-FLOWVIANT_LIVE=1 npx flowviant
+FLOWVIANT_POLL=1 npx flowviant
 ```
 
-Each task runs a **persistent** Claude session you can talk to mid-task from the app: the agent streams its work into the task's conversation, you `@`-mention it to steer or answer questions, and it resumes in place. Blockers park the session at zero cost until you answer.
-
 ### Live previews
 
 For UI/API tasks, the daemon can start the branch's dev server in the agent's worktree and open a [cloudflared](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) quick tunnel so you can drive the real running change during review — no Cloudflare account needed (it's auto-fetched if missing). Configure it once per repo, or let it infer common setups:

package/bin/lib/config.mjs

@@ -4,7 +4,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
-export const VERSION = '0.7.0';
+export const VERSION = '0.8.1';
 
 // Credential stored by `flowviant login` (device auth) — the no-token,
 // no-env-var path. An explicit --fleet flag or FLOWVIANT_FLEET env still wins.
@@ -35,10 +35,12 @@ export const RECONCILE_SECONDS = Number(process.env.RECONCILE_SECONDS || 10);
 // so a long-lived daemon never silently 401s on an expired token.
 export const REFRESH_BEFORE_SECONDS = Number(process.env.REFRESH_BEFORE_SECONDS || 3600);
 export const SAFE = process.env.FLOWVIANT_SAFE === '1';
-// Opt-in phase-2 live mode: persistent Agent-SDK session per task (streams into
-// the task channel, injectable, blocker-parks in place) instead of one-shot
-// `claude -p` turns. Off = the proven poll/sentinel path, untouched.
-export const LIVE = process.env.FLOWVIANT_LIVE === '1';
+// Live mode (DEFAULT since 0.8.0): persistent Agent-SDK session per task —
+// streams into the task channel, injectable mid-task, blocker-parks in place,
+// delivery card on complete, branch preview tunnels. The legacy poll/sentinel
+// path (one-shot `claude -p` turns) survives behind FLOWVIANT_POLL=1 as the
+// escape hatch; FLOWVIANT_LIVE=1 is still honored for old scripts.
+export const LIVE = process.env.FLOWVIANT_POLL !== '1';
 // Sent on the daemon's own HTTP calls so Cloudflare Bot Fight Mode doesn't 403
 // them (Node's default UA is treated as a bot). Claude Code sends its own UA.
 export const USER_AGENT = `flowviant/${VERSION}`;

package/bin/lib/fleet.mjs

@@ -189,17 +189,19 @@ export async function runFleetDaemon() {
   // Merge jobs (Flowvy-commanded): approved PRs to squash-merge to main on the
   // user's own gh. `merging` guards against re-processing a job mid-flight.
   const MERGE_DONE_URL = FLEET_URL.replace(/\/agents\/?$/, '/merge-done');
+  const MERGE_FAILED_URL = FLEET_URL.replace(/\/agents\/?$/, '/merge-failed');
   const merging = new Set();
-  const reportMerged = async (intentId) => {
+  const mergeAttempts = new Map(); // job.id -> transient-failure count
+  const reportMergeOutcome = async (url, body) => {
     try {
-      await fetch(MERGE_DONE_URL, {
+      await fetch(url, {
         method: 'POST',
         headers: {
           Authorization: `Bearer ${FLEET_TOKEN}`,
           'User-Agent': USER_AGENT,
           'Content-Type': 'application/json',
         },
-        body: JSON.stringify({ intentId }),
+        body: JSON.stringify(body),
       });
     } catch {
       /* best-effort — the job reappears next poll if this failed */
@@ -213,6 +215,7 @@ export async function runFleetDaemon() {
         try {
           note(`${c.cyan('merge')} ${c.dim(`— ${job.title}`)}`);
           let merged = false;
+          let failedReason = null; // permanent — tell the thread, clear the flag
           try {
             execFileSync('gh', ['pr', 'merge', job.prUrl, '--squash', '--delete-branch'], {
               cwd: repoRoot,
@@ -221,14 +224,33 @@ export async function runFleetDaemon() {
             merged = true;
           } catch (e) {
             const err = e.stderr?.toString?.() || e.message || '';
+            const line = err.split('\n')[0] || 'gh pr merge failed';
             if (/already merged|not open|closed/i.test(err)) merged = true;
-            else if (/conflict|not mergeable|CONFLICTING/i.test(err))
-              warn(`"${job.title}" has a merge conflict — rebase the branch, then it'll merge.`);
-            else warn(`merge failed for "${job.title}": ${err.split('\n')[0]} — will retry`);
+            else if (/conflict|not mergeable|CONFLICTING/i.test(err)) {
+              // Permanent until a human/agent acts — don't spin on it.
+              failedReason = `merge conflict with ${baseRef} — the branch needs a rebase`;
+            } else {
+              // Transient (auth hiccup, network, CI requirement): retry a few
+              // polls, then surface it instead of silently looping forever.
+              const n = (mergeAttempts.get(job.id) ?? 0) + 1;
+              mergeAttempts.set(job.id, n);
+              if (n >= 3) failedReason = line;
+              else warn(`merge failed for "${job.title}": ${line} — will retry`);
+            }
           }
           if (merged) {
-            await reportMerged(job.id);
+            mergeAttempts.delete(job.id);
+            await reportMergeOutcome(MERGE_DONE_URL, { intentId: job.id });
             ok(`${c.cyan('merged')} ${c.dim(`— ${job.title} → ${baseRef}`)}`);
+          } else if (failedReason) {
+            // Report into the thread (server narrates + re-arms the merge
+            // button + notifies) — the job disappears from the roster.
+            mergeAttempts.delete(job.id);
+            await reportMergeOutcome(MERGE_FAILED_URL, {
+              intentId: job.id,
+              message: failedReason,
+            });
+            warn(`merge failed for "${job.title}": ${failedReason} — reported to the thread`);
           }
         } finally {
           merging.delete(job.id);
@@ -237,6 +259,56 @@ export async function runFleetDaemon() {
     }
   };
 
+  // Cleanup jobs (task restarts): close the abandoned PR + delete its remote
+  // branch on the user's own gh, so a restart doesn't litter the repo.
+  const CLEANUP_DONE_URL = FLEET_URL.replace(/\/agents\/?$/, '/cleanup-done');
+  const cleaning = new Set();
+  const processCleanupJobs = (jobs) => {
+    for (const job of jobs ?? []) {
+      if (cleaning.has(job.id)) continue;
+      cleaning.add(job.id);
+      (async () => {
+        try {
+          note(`${c.cyan('cleanup')} ${c.dim(`— ${job.title} (restarted)`)}`);
+          if (job.prUrl) {
+            try {
+              execFileSync(
+                'gh',
+                [
+                  'pr',
+                  'close',
+                  job.prUrl,
+                  '--comment',
+                  'Task restarted in Flowviant — this attempt was discarded.',
+                  '--delete-branch',
+                ],
+                { cwd: repoRoot, stdio: ['ignore', 'pipe', 'pipe'] }
+              );
+            } catch (e) {
+              // Already closed/merged/missing = fine; anything else we still
+              // report done — a restart must never wedge on stale remotes.
+              const err = e.stderr?.toString?.() || e.message || '';
+              warn(`cleanup for "${job.title}": ${err.split('\n')[0] || 'gh pr close failed'}`);
+            }
+          } else if (job.branch) {
+            try {
+              execFileSync('git', ['push', 'origin', '--delete', job.branch], {
+                cwd: repoRoot,
+                stdio: ['ignore', 'pipe', 'pipe'],
+              });
+            } catch {
+              /* branch already gone — fine */
+            }
+          }
+          await reportMergeOutcome(CLEANUP_DONE_URL, { intentId: job.id });
+          ok(`${c.cyan('cleaned')} ${c.dim(`— ${job.title}`)}`);
+        } finally {
+          cleaning.delete(job.id);
+        }
+      })();
+    }
+  };
+
   let connected = false; // log the first successful poll once
   let rosterSig = null; // last roster membership, to log changes only
   let idleBeatAt = 0; // throttle the "still alive" idle heartbeat
@@ -276,6 +348,7 @@ export async function runFleetDaemon() {
     if (roster.mcpUrl) mcpUrl = roster.mcpUrl;
     if (roster.leaseTtlSeconds) leaseTtlSeconds = roster.leaseTtlSeconds;
     processMergeJobs(roster.mergeJobs);
+    processCleanupJobs(roster.cleanupJobs);
     const rosterIds = new Set(roster.agents.map((a) => a.agentId));
 
     // Announce roster size only when it changes (not every poll).

package/bin/lib/live.mjs

@@ -1,5 +1,5 @@
 /**
- * Live mode (phase 2, opt-in via FLOWVIANT_LIVE=1). Instead of one-shot
+ * Live mode (the DEFAULT since 0.8.0; FLOWVIANT_POLL=1 = legacy path). Instead of one-shot
  * `claude -p` turns + sentinels, each task runs a PERSISTENT Agent-SDK session:
  * the daemon claims, seeds the session with the brief, mirrors the model's
  * streamed reply into the task channel (stream_turn), injects human @-messages
@@ -302,14 +302,26 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resume
   let nudges = 0;
   let held = false; // asked to stop — park for direction, don't nudge
 
+  // Liveness heartbeat: stream_turn refreshes the lease, but a long stretch of
+  // silent tool work streams no text — the app would read "stalled" while the
+  // agent is grinding. Beat at most once a minute on ANY session activity.
+  let lastBeat = Date.now();
+  const beat = () => {
+    if (Date.now() - lastBeat < 60_000) return;
+    lastBeat = Date.now();
+    void mcpCall(mcpUrl, token, 'heartbeat', { runId }).catch(() => {});
+  };
+
   const flush = async () => {
-    if (turnId && turnText.trim())
+    if (turnId && turnText.trim()) {
+      lastBeat = Date.now(); // stream_turn refreshes the lease itself
       await mcpCall(mcpUrl, token, 'stream_turn', {
         runId,
         turnId,
         text: turnText.trim(),
         createdAt: turnAt,
       }).catch(() => {});
+    }
   };
   const inject = (msgs) => {
     afterId = msgs[msgs.length - 1].id;
@@ -319,6 +331,7 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resume
   try {
     for await (const m of session) {
       if (!isAlive()) return { outcome: 'blocked', title, intentId };
+      beat(); // any session traffic = alive (throttled to 1/min)
 
       if (m.type === 'assistant') {
         if (!turnId) {
@@ -368,6 +381,11 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resume
           runId,
           ...(afterId ? { afterId } : {}),
         }).catch(() => null);
+        // Torn down out from under us (restart / reassign in Flowviant): the
+        // server killed this run — abandon the session, don't keep building.
+        if (poll && poll.ok === false && poll.reason === 'run_not_active') {
+          return { outcome: 'torn_down', title, intentId };
+        }
         const fresh = (poll?.messages ?? []).filter((x) => x.role === 'user');
 
         if (fresh.some((f) => STOP_RE.test(f.content))) {
@@ -466,7 +484,16 @@ export async function runLiveWorker({
     const cfg = loadPreviewConfig(cwd);
     const kind = cfg?.ui ? 'ui' : cfg?.api ? 'api' : null;
     const entry = kind ? cfg[kind] : null;
-    if (!entry || !intentId) return; // no preview config → captured evidence only
+    if (!entry || !intentId) {
+      // Say WHY there's no preview instead of skipping silently — this was a
+      // real "where's my preview?" support case.
+      info(
+        `${label} ${c.dim(
+          'no live preview: add .flowviant/preview.json ({"ui":{"cmd":"npm run dev","port":5173}}) — the framework could not be inferred from package.json.'
+        )}`
+      );
+      return;
+    }
     info(`${label} ${c.dim('starting a live preview of the branch for review…')}`);
     preview = await startPreview({
       worktree: cwd,
@@ -527,6 +554,13 @@ export async function runLiveWorker({
       await startReviewPreview(res.intentId);
       continue;
     }
+    if (res.outcome === 'torn_down') {
+      // The human restarted/reassigned the task in Flowviant. Drop everything —
+      // the next fresh claim resets the worktree to base.
+      info(`${label} ${c.dim(`"${res.title}" was restarted/reassigned — abandoned this attempt`)}`);
+      phase = '';
+      continue;
+    }
     if (res.outcome === 'parked') {
       // Idle-parked too long on a blocker: we freed the Claude process. The intent
       // stays claimed; a later poll re-claims + resumes (with transcript) once the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Run your own Claude Code as headless build agents for Flowviant — on your own credentials. Claims dispatched work, opens PRs, captures review evidence, and routes questions back to you.",
   "type": "module",
   "bin": {