flowviant 0.8.1 → 0.9.0

package/bin/cli.mjs

@@ -44,6 +44,33 @@ if (process.argv[2] === 'login') {
   process.exit(0);
 }
 
+// `flowviant clean` — reclaim the persistent worktrees (~/.flowviant/worktrees).
+// They're kept across runs so in-flight work survives Ctrl+C; this is the drain.
+// Repos self-heal: the daemon runs `git worktree prune` if a stale registration
+// blocks re-adding a path.
+if (process.argv[2] === 'clean') {
+  const { rmSync, existsSync } = await import('node:fs');
+  const { join } = await import('node:path');
+  const { homedir } = await import('node:os');
+  const { execFileSync } = await import('node:child_process');
+  const dir = join(homedir(), '.flowviant', 'worktrees');
+  if (!existsSync(dir)) {
+    console.log('nothing to clean — no worktrees at ~/.flowviant/worktrees.');
+    process.exit(0);
+  }
+  let size = '';
+  try {
+    const kb = Number(execFileSync('du', ['-sk', dir], { encoding: 'utf8' }).split('\t')[0]);
+    size = ` (${(kb / 1024).toFixed(0)} MB reclaimed)`;
+  } catch {
+    /* du unavailable — skip the size */
+  }
+  console.log('note: stop any running flowviant daemon first — in-flight local work is discarded.');
+  rmSync(dir, { recursive: true, force: true });
+  console.log(`cleaned ~/.flowviant/worktrees${size}.`);
+  process.exit(0);
+}
+
 if (!FLEET_TOKEN && tokens.length === 0) {
   console.error(
     'error: no credential found. Easiest:\n' +

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.8.1';
+export const VERSION = '0.9.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

@@ -5,10 +5,11 @@
  * MCP token, and only spawns Claude when the server says an agent has work.
  */
 
-import { mkdtempSync, rmSync, existsSync } from 'node:fs';
+import { mkdirSync, existsSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join, basename } from 'node:path';
 import {
   VERSION,
   FLEET_URL,
@@ -151,7 +152,21 @@ export async function runFleetDaemon() {
   console.log('');
   preflight({ needGit: true });
 
-  const baseDir = mkdtempSync(join(tmpdir(), 'flowviant-fleet-'));
+  // Persistent worktree home (0.9.0) — survives daemon restarts AND reboots,
+  // so Ctrl+C mid-task never loses local work. Keyed per repo path; each
+  // agent's worktree carries a task marker so a resumed claim keeps its files.
+  const repoKey = `${basename(repoRoot)}-${createHash('sha256').update(repoRoot).digest('hex').slice(0, 8)}`;
+  const baseDir = join(homedir(), '.flowviant', 'worktrees', repoKey);
+  mkdirSync(baseDir, { recursive: true });
+  try {
+    const kb = Number(execFileSync('du', ['-sk', baseDir], { encoding: 'utf8' }).split('\t')[0]);
+    if (kb > 1024)
+      info(
+        `disk   · worktrees ${(kb / 1024 / 1024).toFixed(1)} GB at ~/.flowviant/worktrees — \`flowviant clean\` reclaims`
+      );
+  } catch {
+    /* du unavailable (Windows) — skip the disk line */
+  }
   const tokenByAgent = new Map(); // agentId -> latest worker token
   const mintedAt = new Map(); // agentId -> ms when we last got a fresh token
   const hasWorkByAgent = new Map(); // agentId -> server says it has claimable work
@@ -159,6 +174,10 @@ export async function runFleetDaemon() {
   let mcpUrl = MCP_URL;
   const workers = new Map(); // agentId -> { state, promise, wt, label }
 
+  // Shutdown KEEPS the worktrees: in-flight local work survives Ctrl+C and
+  // resumes in place on the next run (the task marker matches). Worktrees are
+  // only removed when an agent is deleted from the roster, or by
+  // `flowviant clean`.
   const teardown = () => {
     for (const [, w] of workers) {
       w.state.alive = false;
@@ -167,21 +186,11 @@ export async function runFleetDaemon() {
       } catch {
         /* best-effort */
       }
-      try {
-        git(['worktree', 'remove', '--force', w.wt], repoRoot);
-      } catch {
-        /* best-effort */
-      }
-    }
-    try {
-      rmSync(baseDir, { recursive: true, force: true });
-    } catch {
-      /* best-effort */
     }
   };
   process.on('SIGINT', () => {
     console.log('');
-    note('shutting down — stopping workers and freeing worktrees…');
+    note('shutting down — stopping workers. Worktrees are kept: in-flight work resumes next run.');
     teardown();
     process.exit(130);
   });
@@ -377,7 +386,16 @@ export async function runFleetDaemon() {
       if (!workers.has(a.agentId)) {
         const wt = join(baseDir, `agent-${a.agentId}`);
         try {
-          if (!existsSync(wt)) git(['worktree', 'add', '--detach', wt, baseRef], repoRoot);
+          if (!existsSync(wt)) {
+            try {
+              git(['worktree', 'add', '--detach', wt, baseRef], repoRoot);
+            } catch {
+              // A stale registration (e.g. after `flowviant clean` rm'd the
+              // dir) blocks re-adding the same path — prune and retry once.
+              git(['worktree', 'prune'], repoRoot);
+              git(['worktree', 'add', '--detach', wt, baseRef], repoRoot);
+            }
+          }
         } catch (e) {
           fail(`could not create worktree for "${a.name}": ${e.message}`);
           continue;

package/bin/lib/live.mjs

@@ -16,6 +16,8 @@
  * live fleet + repo to shake out. Old (poll/sentinel) mode is untouched.
  */
 
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import {
   MCP_URL,
@@ -88,12 +90,14 @@ your branch is started for you automatically — you do NOT need to open a tunne
 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) {
+function seedPrompt(runId, brief, transcript, resumedInPlace) {
   return [
     `Your run id is ${runId}. Use it for every flowviant MCP tool call.`,
-    brief?.branch
-      ? `This is a REVISION — your prior branch "${brief.branch}" is checked out; address the review feedback and push to the SAME branch (the PR updates in place).`
-      : `Start from the clean base checkout and open a fresh draft PR when done.`,
+    resumedInPlace
+      ? `You are RESUMING after a daemon restart: your worktree still contains your own uncommitted work from before the interruption. Run \`git status\` and \`git diff\` first, take stock, and CONTINUE from there — do not start over.`
+      : brief?.branch
+        ? `This is a REVISION — your prior branch "${brief.branch}" is checked out; address the review feedback and push to the SAME branch (the PR updates in place).`
+        : `Start from the clean base checkout and open a fresh draft PR when done.`,
     ``,
     `Task brief:`,
     JSON.stringify(brief ?? {}, null, 2),
@@ -180,6 +184,29 @@ function makeInput(seedText) {
   };
 }
 
+// Task marker — WHICH intent this worktree was building, stored in the
+// worktree's own git dir (never the working tree, so the agent can't commit
+// it and `git clean` can't delete it). It's what lets a claim after a daemon
+// restart recognize its own half-built worktree and resume IN PLACE instead
+// of resetting away hours of uncommitted work.
+function markerPath(cwd) {
+  return join(git(['rev-parse', '--absolute-git-dir'], cwd), 'flowviant-task');
+}
+function readTaskMarker(cwd) {
+  try {
+    return readFileSync(markerPath(cwd), 'utf8').trim() || null;
+  } catch {
+    return null;
+  }
+}
+function writeTaskMarker(cwd, intentId) {
+  try {
+    writeFileSync(markerPath(cwd), `${intentId}\n`);
+  } catch {
+    /* best-effort — worst case the next restart resets to base */
+  }
+}
+
 // A stop word from any teammate halts the agent (interrupt at the next boundary,
 // then hold for direction) — the "stop, you're going the wrong way" valve.
 const STOP_RE = /(^|\W)stop(\W|$)/i;
@@ -225,22 +252,36 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resume
   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.
+  // Re-claiming the SAME intent this worker was just working — either this
+  // daemon's own memory (parked on a blocker, now resuming) or the persistent
+  // task marker (the daemon restarted mid-task). Its worktree holds hours of
+  // uncommitted work. Do NOT reset.
   const resuming = !!resumeIntentId && intentId === resumeIntentId;
+  const resumedInPlace = !resuming && readTaskMarker(cwd) === intentId;
 
   // Revision resumes its PR branch; a genuinely fresh task gets a clean base
-  // checkout; a resume keeps its dirty worktree untouched.
+  // checkout; a resume (in-memory or marker) keeps its dirty worktree untouched.
   if (brief.branch) {
     try {
       git(['fetch', 'origin', '--quiet'], cwd);
       git(['checkout', brief.branch], cwd);
     } catch {
-      if (!resuming) resetWorktree(cwd, baseRef);
+      if (!resuming && !resumedInPlace) resetWorktree(cwd, baseRef);
     }
-  } else if (!resuming) {
+  } else if (!resuming && !resumedInPlace) {
     resetWorktree(cwd, baseRef);
   }
+  writeTaskMarker(cwd, intentId);
+
+  if (resumedInPlace) {
+    // Thread honesty: the team must see this is a genuine continuation with
+    // files intact — deterministic, not left to the model's self-narration.
+    await mcpCall(mcpUrl, token, 'stream_turn', {
+      runId,
+      turnId: `resume:${runId}`,
+      text: '⟲ Resumed after a daemon restart — local work survived; continuing in place.',
+    }).catch(() => {});
+  }
 
   const env = { ...process.env };
   delete env.ANTHROPIC_API_KEY; // force the user's Claude Code subscription
@@ -255,7 +296,7 @@ export async function runLiveTask({ mcpUrl, token, cwd, baseRef, isAlive, resume
     .join('\n');
   let afterId = priorMsgs.length ? priorMsgs[priorMsgs.length - 1].id : null;
 
-  const input = makeInput(seedPrompt(runId, brief, transcript));
+  const input = makeInput(seedPrompt(runId, brief, transcript, resumedInPlace));
   const session = query({
     prompt: input.stream(),
     options: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.8.1",
+  "version": "0.9.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": {