flowviant 0.6.0 → 0.7.0

package/bin/lib/claude.mjs

@@ -25,13 +25,14 @@ Operate this loop:
 3. If you hit ANYTHING only a human can decide, call report_blocker with a clear
    question (and options when you can), then call get_blocker_resolution. If it is
    not yet resolved, output exactly BLOCKED:<blockerId> on its own line and STOP.
-4. Before finishing: for EACH acceptance criterion, call attach_evidence with concrete
-   proof it is met. This is what the human reviews instead of the diff.
-5. Ship: on a revision, \`git push\` to the SAME existing branch (the PR updates in place)
+4. Ship: on a revision, \`git push\` to the SAME existing branch (the PR updates in place)
    and re-call attach_pr with that PR URL; otherwise open ONE draft PR (git push +
-   \`gh pr create --draft\`) and call attach_pr. Then complete. NEVER merge — the human
-   approves the PR in Flowviant.
-6. Return to step 1.
+   \`gh pr create --draft\`) and call attach_pr. Then call complete with a plain-language
+   summary of what you built AND a criteria self-report (index into the brief's
+   "done when" list + met true/false + a short note) — that becomes your delivery
+   card in the task thread. NEVER merge — a human confirms done in the thread and
+   the merge runs separately.
+5. Return to step 1.
 
 Keep every change scoped to the claimed intent. If a tool errors, report_progress with
 the error, then retry or report_blocker.`;
@@ -53,12 +54,12 @@ Do EXACTLY ONE task this turn:
 3. If you hit ANYTHING only a human can decide, call report_blocker (with options when
    you can), then get_blocker_resolution. If unresolved, output exactly
    BLOCKED:<blockerId> on its own line and STOP. Do NOT guess past a real decision.
-4. Before finishing: for EACH acceptance criterion call attach_evidence with concrete
-   proof it is met.
-5. Ship: if this is a revision, \`git push\` to the SAME existing branch (the open PR
+4. Ship: if this is a revision, \`git push\` to the SAME existing branch (the open PR
    updates in place) and re-call attach_pr with that same PR URL. Otherwise open ONE
-   draft PR (git push + \`gh pr create --draft\`) and call attach_pr. Then complete.
-   NEVER merge. Then output exactly DONE on its own line and stop.
+   draft PR (git push + \`gh pr create --draft\`) and call attach_pr. Then call complete
+   with a plain-language summary AND a criteria self-report (index into the brief's
+   "done when" list + met true/false + a short note) — your delivery card in the task
+   thread. NEVER merge. Then output exactly DONE on its own line and stop.
 
 Do NOT claim a second intent — exactly one per turn. Keep every change scoped to the
 claimed intent. If a tool errors, report_progress with the error, then retry or
@@ -127,7 +128,13 @@ export function runTurn({ prompt, resume, system, cwd, mcpConfig, label, onSpawn
     const args = [];
     if (resume) args.push('--continue');
     args.push('-p', prompt, '--mcp-config', mcpConfig, '--append-system-prompt', system, ...PERM);
-    const child = spawn('claude', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    // Force the user's Claude Code subscription — never the API. A key exported in
+    // the shell would otherwise silently bill every poll-mode turn as raw API
+    // usage (same invariant live mode enforces on its SDK session env).
+    const env = { ...process.env };
+    delete env.ANTHROPIC_API_KEY;
+    delete env.ANTHROPIC_AUTH_TOKEN;
+    const child = spawn('claude', args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
     onSpawn?.(child);
     let out = '';
     const pfx = label ? `${label} ` : '';

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.6.0';
+export const VERSION = '0.7.0';
 
 // Credential stored by `flowviant login` (device auth) — the no-token,
 // no-env-var path. An explicit --fleet flag or FLOWVIANT_FLEET env still wins.

package/bin/lib/fleet.mjs

@@ -128,8 +128,11 @@ async function runFleetWorker({ agentId, label, cwd, baseRef, getToken, getHasWo
     // don't fake a blocker or a completion.
     enter('reconnect', warn, `${c.yellow('no result')}${c.dim(' — refreshing token, retrying')}`);
     onTokenSuspect?.(agentId);
-    resuming = false;
-    needsReset = true;
+    // A no-sentinel turn while RESUMING a blocked task is a transient MCP/token
+    // failure, not completion — retry in place and KEEP the worktree. Resetting
+    // here would wipe the blocked task's uncommitted changes. Only a fresh-task
+    // turn (not resuming) warrants a clean slate next time.
+    if (!resuming) needsReset = true;
     await sleep(IDLE_SECONDS);
   }
   info(`${label} stopped`);

package/bin/lib/live.mjs

@@ -51,7 +51,21 @@ async function registerLiveTarget(intentId, kind, url) {
   }
 }
 
-const SAFE_TOOLS = ['Edit', 'Write', 'Read', 'Grep', 'Glob', 'Bash', 'mcp__flowviant'];
+// Safe mode's curated toolset. Bash is scoped to the specific CLIs the agent
+// needs (git/gh/npm/bun) — NOT bare `Bash`, which would auto-approve arbitrary
+// shell (rm -rf, curl|sh, reading ~/.ssh) and defeat the point of safe mode.
+const SAFE_TOOLS = [
+  'Edit',
+  'Write',
+  'Read',
+  'Grep',
+  'Glob',
+  'Bash(git:*)',
+  'Bash(gh:*)',
+  'Bash(npm:*)',
+  'Bash(bun:*)',
+  'mcp__flowviant',
+];
 
 // Appended to Claude Code's preset. The reliable copy of the contract also
 // rides in the seed message below, so this degrades gracefully if the preset
@@ -64,12 +78,15 @@ answered…" or teammate line as a new instruction and adapt. There is NO termin
 and NO interactive prompt — your only channel to a human is the flowviant MCP
 tools. When you hit a decision only a human can make, call report_blocker (with
 options when you can) and then STOP your turn — do not spin or guess; you will be
-resumed with the answer. When the work is done: call attach_evidence for EACH
-acceptance criterion (this is the floor the human reviews against); open ONE draft
-PR (git push + gh pr create --draft), call attach_pr, then call complete. A live
-preview of your branch is started for you automatically for the review — you do
-NOT need to open a tunnel or register a live target. NEVER merge — the human
-reviews and merging is handled separately.`;
+resumed with the answer. When the work is done: open ONE draft PR (git push +
+gh pr create --draft), call attach_pr, then call complete with a plain-language
+summary of what you built AND a criteria self-report (index into the brief's
+"done when" list + met true/false + a short note per item). That summary +
+self-report becomes your DELIVERY CARD in the task thread — it's what the team
+reads to confirm done, so write it for them, not for a log. A live preview of
+your branch is started for you automatically — you do NOT need to open a tunnel
+or register a live target. NEVER merge — a human confirms done in the thread
+(the merge card) and the merge runs separately.`;
 
 function seedPrompt(runId, brief, transcript) {
   return [
@@ -84,7 +101,7 @@ function seedPrompt(runId, brief, transcript) {
       ? [``, `Conversation so far (you may be resuming — pick up where this left off):`, transcript]
       : []),
     ``,
-    `${transcript ? 'Continue' : 'Begin'}. Post a short plan first, then: report_progress as you go; report_blocker + stop if you hit a human decision; attach_evidence, open a draft PR, attach_pr, then complete when done.`,
+    `${transcript ? 'Continue' : 'Begin'}. Post a short plan first, then: report_progress as you go; report_blocker + stop if you hit a human decision; open a draft PR, attach_pr, then complete (summary + criteria self-report — your delivery card) when done.`,
   ].join('\n');
 }
 
@@ -99,6 +116,9 @@ async function mcpCall(mcpUrl, token, name, args) {
       Authorization: `Bearer ${token}`,
       'Content-Type': 'application/json',
       Accept: 'application/json',
+      // Required: Node's default UA trips Cloudflare Bot Fight Mode (403) —
+      // without this every live MCP call fails against api.flowviant.com.
+      'User-Agent': USER_AGENT,
     },
     body: JSON.stringify({
       jsonrpc: '2.0',
@@ -199,22 +219,26 @@ async function waitForMessage(mcpUrl, token, runId, afterId, isAlive) {
 
 // One task: claim → seed → stream/mirror/inject/park → complete. Returns
 // { outcome: 'nothing' | 'done' | 'blocked' | 'stalled' | 'error' }.
-export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive }) {
+export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resumeIntentId, onChild }) {
   const claim = await mcpCall(mcpUrl, token, 'claim_next_intent', {}).catch(() => null);
   if (!claim || claim.claimed !== true) return { outcome: 'nothing' };
   const { runId, intentId } = claim;
   const brief = claim.brief ?? {};
   const title = brief.title ?? 'a task';
+  // Re-claiming the SAME intent this worker was just working (parked on a blocker,
+  // now resuming) — its worktree holds hours of uncommitted work. Do NOT reset.
+  const resuming = !!resumeIntentId && intentId === resumeIntentId;
 
-  // Revision resumes its PR branch; otherwise a clean base checkout.
+  // Revision resumes its PR branch; a genuinely fresh task gets a clean base
+  // checkout; a resume keeps its dirty worktree untouched.
   if (brief.branch) {
     try {
       git(['fetch', 'origin', '--quiet'], cwd);
       git(['checkout', brief.branch], cwd);
     } catch {
-      resetWorktree(cwd, baseRef);
+      if (!resuming) resetWorktree(cwd, baseRef);
     }
-  } else {
+  } else if (!resuming) {
     resetWorktree(cwd, baseRef);
   }
 
@@ -241,11 +265,34 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive }) {
       ...(SAFE ? { allowedTools: SAFE_TOOLS } : {}),
       systemPrompt: { type: 'preset', preset: 'claude_code', append: SYSTEM_LIVE },
       mcpServers: {
-        flowviant: { type: 'http', url: mcpUrl, headers: { Authorization: `Bearer ${token}` } },
+        flowviant: {
+          type: 'http',
+          url: mcpUrl,
+          headers: { Authorization: `Bearer ${token}`, 'User-Agent': USER_AGENT },
+        },
       },
     },
   });
 
+  // Mark this worker BUSY for the daemon's reconcile loop: buildHave keeps the
+  // worker's token while a session is live (never rotate a credential out from
+  // under it), and teardown/agent-removal can interrupt the SDK session via this
+  // marker's kill(). Cleared in finally. Mirrors poll mode's onChild(child).
+  onChild?.({
+    kill: () => {
+      try {
+        session.interrupt?.();
+      } catch {
+        /* already ending */
+      }
+      try {
+        session.return?.();
+      } catch {
+        /* already closed */
+      }
+    },
+  });
+
   let turnId = null;
   let turnText = '';
   let turnAt = null;
@@ -359,6 +406,7 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive }) {
   } catch (e) {
     return { outcome: 'error', error: e?.message ?? String(e), title, intentId };
   } finally {
+    onChild?.(null); // no longer busy — token may rotate between tasks
     input.close();
     try {
       await session.interrupt?.();
@@ -385,7 +433,12 @@ export async function runLiveWorker({
   getMcpUrl,
   isAlive,
   onTokenSuspect,
+  onChild,
 }) {
+  // The intent this worker is holding across iterations. When a task parks on a
+  // blocker its worktree keeps uncommitted work; on the resume claim we must NOT
+  // reset it. Cleared once the task finishes or the worker goes idle.
+  let lastIntentId = null;
   let phase = '';
   const enter = (p, fn, msg) => {
     if (phase !== p) {
@@ -441,13 +494,28 @@ export async function runLiveWorker({
     }
     let res;
     try {
-      res = await runLiveTask({ mcpUrl: getMcpUrl() ?? MCP_URL, token, cwd, baseRef, isAlive });
+      res = await runLiveTask({
+        mcpUrl: getMcpUrl() ?? MCP_URL,
+        token,
+        cwd,
+        baseRef,
+        isAlive,
+        resumeIntentId: lastIntentId,
+        onChild,
+      });
     } catch (e) {
       enter('error', warn, `${c.yellow('error')} ${c.dim(`— ${e?.message ?? e}`)}`);
       await sleep(IDLE_SECONDS);
       continue;
     }
     if (!isAlive()) break;
+    // Keep the held intent only while a task is genuinely in flight (parked /
+    // stalled / errored → same worktree resumes). Finishing or finding no work
+    // clears it so the next fresh task starts from a clean base.
+    lastIntentId =
+      res.outcome === 'parked' || res.outcome === 'stalled' || res.outcome === 'error'
+        ? res.intentId
+        : null;
     if (res.outcome === 'nothing') {
       enter('idle', info, 'idle — no work assigned');
       await sleep(IDLE_SECONDS);

package/bin/lib/preview.mjs

@@ -137,14 +137,36 @@ export async function startPreview({ worktree, kind, cmd, port, log, timeoutMs =
   const cf = await ensureCloudflared(log);
   if (!cf) return null; // fall back to captured evidence
   return new Promise((resolve) => {
-    const server = spawn(cmd, { cwd: worktree, shell: true, stdio: ['ignore', 'ignore', 'ignore'] });
+    // detached so each gets its own process group — `bun run dev` via a shell
+    // spawns a grandchild dev server that would otherwise SURVIVE a kill of the
+    // shell, keep port bound, and get silently re-fronted by the NEXT task's
+    // tunnel (reviewer sees the wrong branch). We kill the whole group instead.
+    const server = spawn(cmd, {
+      cwd: worktree,
+      shell: true,
+      detached: true,
+      stdio: ['ignore', 'ignore', 'ignore'],
+    });
     const tunnel = spawn(cf, ['tunnel', '--url', `http://localhost:${port}`], {
+      detached: true,
       stdio: ['ignore', 'pipe', 'pipe'],
     });
     let settled = false;
+    const killGroup = (child) => {
+      if (!child.pid) return;
+      try {
+        process.kill(-child.pid, 'SIGKILL'); // negative pid = the whole group
+      } catch {
+        try {
+          child.kill('SIGKILL');
+        } catch {
+          /* gone */
+        }
+      }
+    };
     const stop = () => {
-      try { server.kill('SIGKILL'); } catch { /* gone */ }
-      try { tunnel.kill('SIGKILL'); } catch { /* gone */ }
+      killGroup(server);
+      killGroup(tunnel);
     };
     const finish = (val) => {
       if (settled) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "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": {