flowviant 0.6.1 → 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

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.1';
+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

@@ -78,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 [
@@ -98,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');
 }
 
@@ -216,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);
   }
 
@@ -267,6 +274,25 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive }) {
     },
   });
 
+  // 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;
@@ -380,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?.();
@@ -406,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) {
@@ -462,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.1",
+  "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": {