flowviant 0.125.17 → 0.125.20

package/bin/lib/workAgentPrecheck.mjs

@@ -12,10 +12,12 @@ import { gitOrNull } from './git.mjs';
 import { parsePrecheck } from './agentPlan.mjs';
 import { readStash } from './agentCards.mjs';
 import { c, note } from './ui.mjs';
-import { runTurn } from './runTurn.mjs';
+import { runTurn as defaultRunTurn } from './runTurn.mjs';
 import { SYSTEM_PRECHECK, AGENT_PRECHECK_KICKOFF } from './prompts.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
-import { pickRuntimeFor } from './runtimeDetection.mjs';
+import { detectRuntimes as defaultDetectRuntimes } from './runtimeDetection.mjs';
+import { canRun, runtimeById } from './runtimes.mjs';
+import { brainFor } from './workBrain.mjs';
 import { runCappedTurn } from './workCappedTurn.mjs';
 import { taskIdsFromMessage } from './worktreeDiff.mjs';
 import { limitLine } from './cliLimit.mjs';
@@ -23,12 +25,12 @@ import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
 import { postFleetJson } from './fleetPost.mjs';
 import { agentBrowserHome } from './noWindowEnv.mjs';
 
-export function createWorkAgentPrecheck({ baseRef, admit, sessionMetaPath, workChildren }) {
+export function createWorkAgentPrecheck({ baseRef, admit, sessionMetaPath, workChildren, runTurn = defaultRunTurn, detectRuntimes = defaultDetectRuntimes }) {
   const AGENT_PRECHECK_URL = fleetEndpoint('agent-precheck', FLEET_URL);
 
   // ── THE AI PRE-REVIEW ──────────────────────────────────────────────────────
   //
-  // A FRESH Claude reads the branch before the human does. The owner asked for
+  // A fresh conversation reads the branch before the human does. The owner asked for
   // it in these words: "before having the user manually check, can we have the
   // daemon … spawn an agent to review the work so basically we get an ai to look
   // at the review before a human looks at it for a double check."
@@ -135,15 +137,14 @@ export function createWorkAgentPrecheck({ baseRef, admit, sessionMetaPath, workC
     return { text, taskIds: [...taskIds] };
   };
 
-  const runPrecheck = async (agentId, wt, agentName, repository) => {
-    /**
-     * WHICH CLI READS. `pickRuntimeFor('consult')` — the same picker the scratch
-     * planner uses, and for the same reason: this prompt was written against
-     * Claude, and a machine with no read-only-capable runtime simply does not
-     * produce a precheck. Nothing is posted and nothing is said on the row.
-     */
-    const rt = pickRuntimeFor('consult');
-    if (!rt) return;
+  const runPrecheck = async (agentId, wt, agentName, repository, source) => {
+    // A fresh read-only conversation, on this agent's CLI/model/effort.
+    // Missing provenance or a missing CLI skips this optional reading; it
+    // never licenses a machine-wide provider substitution.
+    if (!source) return;
+    const rt = source.runtime || 'claude';
+    if (!canRun(runtimeById(rt), 'consult') || !detectRuntimes().some(row => row.id === rt && row.installed)) return;
+    const brain = brainFor(source, rt);
     /**
      * THE PRESSURE GUARD, at the spawn, exactly as every other unattended lane
      * asks it. `churn` and never `interactive`: nobody is watching this, and a
@@ -232,6 +233,7 @@ export function createWorkAgentPrecheck({ baseRef, admit, sessionMetaPath, workC
           profile: 'consult',
           cwd: wt,
           runtime: rt,
+          ...brain,
           // The agent's own browser profile, in the worktree this reader stands
           // in; no display either way (noWindowEnv.mjs, 2026-09-29).
           browserHome: agentBrowserHome(sessionMetaPath, wt, agentId),
@@ -242,8 +244,7 @@ export function createWorkAgentPrecheck({ baseRef, admit, sessionMetaPath, workC
           work: { kind: 'pre-review', id: agentId, name: agentName },
           // The CLI's own count for this reading. Set, never accumulated: one
           // turn is one `result` event, and the adding-up is the server's.
-          // Tagged with the CLI, so a Claude pre-review of a Codex agent is
-          // charged as Claude's and not folded into the agent's own figure.
+          // Tagged with the same CLI as the associated agent.
           onUsage: (u) => {
             usage = { ...u, runtime: rt };
           },

package/bin/lib/workAgentReview.mjs

@@ -29,7 +29,7 @@ export function createWorkAgentReview({ runCheck, runPrecheck }) {
    * INSIDE the place's writer lock on a path whose callers settle real work —
    * `runAgentMerge` in particular reports a claimed merge after this returns.
    */
-  const runReviewEntry = async (agentId, wt, agentName, repository) => {
+  const runReviewEntry = async (agentId, wt, agentName, repository, brain) => {
     let result = { status: 'unknown' };
     try {
       result = await runCheck(agentId, wt, repository) ?? result;
@@ -37,7 +37,7 @@ export function createWorkAgentReview({ runCheck, runPrecheck }) {
       /* the row keeps its previous check answer, which is null the first time */
     }
     try {
-      await runPrecheck(agentId, wt, agentName, repository);
+      await runPrecheck(agentId, wt, agentName, repository, brain);
     } catch {
       /* no pre-review is posted, and absence renders nothing */
     }

package/bin/lib/workAgentTurnExecution.mjs

@@ -1,3 +1,5 @@
+import { reportLocalCleanup } from './localCleanupReport.mjs';
+import { createManagedLocalCleanup } from './managedLocalCleanup.mjs';
 import { imageRevisionInstructions } from './artifactIteration.mjs';
 import { agentChildScope } from './agentQueueContext.mjs';
 import { measureTestFindings } from './testFindings.mjs';
@@ -33,6 +35,7 @@ import { addUsage } from './turnUsage.mjs';
 import { stashCard } from './agentCards.mjs';
 import { c } from './ui.mjs';
 import { runTurn } from './runTurn.mjs';
+import { liveGroups, processesSupported } from './processes.mjs';
 import { killGroup } from './processGroup.mjs';
 import { AGENT_TASK_SPEC } from './prompts.mjs';
 import { agentKickoff, agentFollowupKickoff, agentTurnSystem } from './workAgentTurnShape.mjs';
@@ -247,7 +250,7 @@ export function createAgentTurnExecution({
       return;
     }
     /**
-     * …AND ITS SCRATCH BESIDE IT, EMPTY (0.115.0): a fenced shell's temp files
+     * …AND ITS SCRATCH BESIDE IT (0.115.0): a fenced shell's temp files
      * (a here-document, `mktemp`) go under `.flowviant/tmp`, which Codex's
      * design fence grants because `/tmp` is read-only in there
      * (`ensureFenceScratch`). Made for every file kind — one rule, no kind
@@ -427,6 +430,12 @@ export function createAgentTurnExecution({
       artifactsBefore.imageRevision = job.imageRevision;
       artifactInstructions += '\n\n' + imageRevisionInstructions(job.imageRevision, job.resultInputs);
     }
+    const cleanupPath = sessionMetaPath(wt, 'flowviant-managed-local', agentId);
+    const localCleanup = PROJECT_ID && cleanupPath ? createManagedLocalCleanup({
+      placeDir: wt, projectId: PROJECT_ID, agentId, path: cleanupPath,
+      codexHome: agentResume.codexHome,
+      outputCache: artifacts.cacheFor?.({ placeDir: wt, agentId }) ?? null,
+    }) : null;
     let projectTools = null;
     let orchestrator = null;
     let intermediateDelivery = null;
@@ -443,6 +452,7 @@ export function createAgentTurnExecution({
       }
       const tools = prepareCardTools({ rt, posture, wt, repoRoot, baseRef, sources: repositoryRun?.sources ?? [], repositoryTool: repositoryRun?.tool ?? null, orchestratorConfig: orchestrator?.config ?? null, orchestrated: Boolean(orchestrator), codexHome: agentResume.codexHome });
       projectTools = tools.projectTools;
+      localCleanup?.begin(turnId);
       const { toolsNote } = tools;
       const agentTurnArgs = {
         ...((liveInput || orchestrator) ? { liveMessages: (run.live = makeLiveMessages({
@@ -730,6 +740,7 @@ export function createAgentTurnExecution({
       // The ran marker and the thread this turn spoke under, written now
       // that the turn is over (workAgentResume.mjs).
       agentResume.persist();
+      localCleanup?.capture();
       /**
        * AN ACTION THAT CHANGES WHAT THE MACHINE WOULD MEASURE MUST CAUSE A
        * NEW MEASUREMENT — the rule every session settle keeps, and the one
@@ -794,6 +805,19 @@ export function createAgentTurnExecution({
       modelExports: intermediateDelivery?.modelExports,
     });
     if (body.outcome === 'delivered') intermediateDelivery?.commit();
+    // This place's writer lock is still held. Measure the exited children
+    // and their groups before releasing any file requirements. Dirty repository files are unrelated to managed scratch eligibility.
+    if (localCleanup) {
+      const cleanupResults = localCleanup.capture(); // binds newly uploaded exact image counterparts
+      const groups = new Set([...spawnedChildren].map(ch => ch.pid).filter(pid => Number.isInteger(pid) && pid > 1));
+      const drained = !run.interrupted && processesSupported() && groups.size > 0 &&
+        [...spawnedChildren].every(ch => ch.exitCode != null || ch.signalCode != null) && liveGroups(groups).size === 0;
+      cleanupResults.push(...localCleanup.completeTurn({ drained,
+        handoffComplete: body.outcome === 'delivered', uploadsComplete: artifacts.pendingCount?.() === 0 }));
+      cleanupResults.push(...await localCleanup.reclaim({ drained }));
+      for (const result of cleanupResults) reportLocalCleanup({ ...result,
+        projectId: PROJECT_ID, agentId, placeDir: wt, place, turnId });
+    }
     if (res) setRuntimeLimit(PROJECT_ID, rt, null);
     if (body.outcome === 'delivered' && job.task?.taskType === 'tests' && res?.testFindings) {
       body.testFindings = measureTestFindings(res.testFindings, repositoryRun?.sourcesNow() ?? [{ wt, baseRef: baseRef(), id: job.repos?.length === 1 ? job.repos[0] : null }], envScrub);
@@ -831,7 +855,7 @@ export function createAgentTurnExecution({
     // pre-review HERE, in the worktree we are already standing in and still
     // hold the lock on — see `runReviewEntry`. Only after the settle that may
     // say delivered: the three `nothing` settles never opened it.
-    if (final && reply?.review === true) await runReviewEntry(agentId, wt, job.agentName);
+    if (final && reply?.review === true) await runReviewEntry(agentId, wt, job.agentName, undefined, job);
     } finally { await repositoryRun?.tool?.close(); }
   };
 

package/bin/lib/workAgentTurns.mjs

@@ -322,7 +322,7 @@ export function createWorkAgentTurns({
           const wt = typeof held.body.worktree === 'string' ? held.body.worktree : null;
           if (reply?.review === true && isSafePathSegment(place) && wt && existsSync(wt)) {
             await inPlace(place, place.startsWith(AGENT_PLACE_PREFIX), () =>
-              runReviewEntry(String(job.agentId || ''), wt, job.agentName)
+              runReviewEntry(String(job.agentId || ''), wt, job.agentName, undefined, job)
             );
           }
         })()

package/bin/lib/workLocalCleanup.mjs

@@ -0,0 +1,125 @@
+/** Startup/idle runner for local-only cleanup. Recovery I/O is outside the
+ * writer lock; only a fresh prepared version may enter the short unlink phase. */
+import { randomUUID } from 'node:crypto';
+import { cleanupState } from './localCleanupState.mjs';
+import { agentIdFromPlace } from './workPlaces.mjs';
+
+export const LOCAL_CLEANUP_INTERVAL_MS = 15_000;
+export const LOCAL_CLEANUP_BACKOFF_MS = 60_000;
+const MAX_BACKOFF = 60 * 60_000;
+const keyOf = ref => JSON.stringify([ref.kind, ref.name, ref.localVersion]);
+
+export function createWorkLocalCleanup({ placeLocks, inPlace, targetsFor, eligible, permission = () => false,
+  now = Date.now, log = () => {}, onResult = () => {}, onIncomplete = () => {} }) {
+  let snapshot = null, sweeping = null, lastAt = -Infinity, placeCursor = 0;
+  const targetCursors = new Map();
+  const allowed = (place, locked = false) => {
+    if (!snapshot || snapshot.serving !== true || snapshot.draining !== false ||
+        !Array.isArray(snapshot.activeIds) || !Array.isArray(snapshot.heldElsewhere) ||
+        now() < snapshot.at || now() - snapshot.at > 15_000 || permission() !== true ||
+        !snapshot.activeIds.includes(place) || snapshot.heldElsewhere.includes(place)) return false;
+    const lock = placeLocks.get(place);
+    if (locked ? lock?.waiters?.length > 0 : placeLocks.has(place)) return false;
+    return eligible(place) === true;
+  };
+  const attemptTarget = async (place, target) => {
+    const identity = JSON.stringify({ place, placeDir: target.placeDir, agentId: target.agentId, projectId: target.projectId });
+    const store = cleanupState(target.statePath, identity), release = store.claim();
+    if (!release) return;
+    let locked = false;
+    const guard = () => allowed(place, locked);
+    const memo = new Map(); let preparedOnly = false;
+    try {
+      if (!guard()) return;
+      const state = store.load();
+      // Replay durable outcomes before selecting work, including when every
+      // version is already evicted. Stable ids make replay retry-safe.
+      const publish = () => {
+        let changed = false;
+        for (const entry of state.results) {
+          if (entry.reported === true) continue;
+          if (onResult(entry) !== false) { entry.reported = true; changed = true; }
+        }
+        if (changed) store.save(state);
+      };
+      publish();
+      for (const attempt of Object.values(state.attempts)) {
+        if (attempt.state !== 'running' || attempt.interruptionReported) continue;
+        if (onIncomplete({ id: `interrupted:${attempt.id}`, status: 'retained',
+          reason: 'interrupted-attempt-completion-unknown', incomplete: true,
+          projectId: target.projectId, agentId: target.agentId, placeDir: target.placeDir,
+          place, at: now(), nextAt: attempt.nextAt, tries: attempt.tries,
+          resumedAttempt: attempt.id, previousCompletion: 'unknown' }) !== false) {
+          attempt.interruptionReported = true; store.save(state);
+        }
+      }
+      const operations = target.operations({ guard, recoveryMemo: memo, preparedOnly: () => preparedOnly });
+      if (!operations.length) return;
+      let chosen = null;
+      for (let i = 0; i < Math.min(32, operations.length); i++) {
+        const index = (state.cursor + i) % operations.length, op = operations[index], key = keyOf(op.ref);
+        const previous = state.attempts[key];
+        if (op.ref.state === 'discarded' || (op.ref.state === 'evicted' && previous?.state !== 'running')) continue;
+        if (previous && previous.nextAt > now()) continue;
+        chosen = { op, key, previous }; state.cursor = (index + 1) % operations.length; break;
+      }
+      if (!chosen) { state.cursor = (state.cursor + 32) % operations.length; store.save(state); return; }
+      const { op, key, previous } = chosen, id = randomUUID();
+      const tries = Math.min(100, (previous?.tries ?? 0) + 1);
+      state.attempts[key] = { id, state: 'running', tries, nextAt: now() + LOCAL_CLEANUP_BACKOFF_MS, startedAt: now() };
+      // Persist before remote verification/unlink. A restart honours backoff
+      // and re-runs the prerequisite's current version/pin/recovery checks.
+      store.save(state);
+      let result = await op.prepare();
+      if (result.status === 'ready') {
+        if (!guard() || placeLocks.has(place)) result = { status: 'retained', reason: 'lifecycle-changed' };
+        else await inPlace(place, true, async () => {
+          locked = true; preparedOnly = true;
+          try {
+            if (!guard()) { result = { status: 'retained', reason: 'lifecycle-changed' }; return; }
+            const current = target.operations({ guard, recoveryMemo: memo, preparedOnly: () => preparedOnly })
+              .find(candidate => keyOf(candidate.ref) === key);
+            result = current ? await current.run() : { status: 'retained', reason: 'local-version-changed' };
+          } finally { locked = false; }
+        });
+      }
+      const retryable = result.status === 'failed' || result.incomplete === true || /remote|recovery|unreadable|unlink-failed/.test(result.reason ?? '');
+      const nextAt = now() + (retryable ? Math.min(MAX_BACKOFF, LOCAL_CLEANUP_BACKOFF_MS * 2 ** Math.min(tries - 1, 6)) : LOCAL_CLEANUP_BACKOFF_MS);
+      const entry = { ...result, id, kind: op.ref.kind, name: op.ref.name, localVersion: op.ref.localVersion,
+        projectId: target.projectId, agentId: target.agentId, placeDir: target.placeDir, place, at: now(),
+        bytes: result.status === 'reclaimed' ? result.bytes : 0, nextAt, tries,
+        ...(previous?.state === 'running' ? { resumedAttempt: previous.id, previousCompletion: 'unknown' } : {}) };
+      state.attempts[key] = { id, state: result.incomplete ? 'incomplete' : result.status, tries: retryable ? tries : 0, nextAt, result: entry };
+      state.results.push(entry); state.results = state.results.slice(-128);
+      const liveKeys = new Set(operations.map(candidate => keyOf(candidate.ref)));
+      for (const old of Object.keys(state.attempts)) if (!liveKeys.has(old)) delete state.attempts[old];
+      store.save(state);
+      publish();
+    } finally { memo.clear(); release(); }
+  };
+  const reconcileLocalCleanup = evidence => {
+    // Refresh even while an older verification is in flight. Lost serving
+    // permission, new foreground work and peer leases invalidate its guard.
+    snapshot = { ...evidence, at: now() };
+    if (sweeping || now() - lastAt < LOCAL_CLEANUP_INTERVAL_MS || permission() !== true ||
+        evidence?.serving !== true || evidence?.draining !== false || !Array.isArray(evidence.activeIds) || !Array.isArray(evidence.heldElsewhere)) return sweeping;
+    const places = evidence.activeIds.filter(place => agentIdFromPlace(place) && /^[A-Za-z0-9_-]+$/.test(place));
+    for (const place of targetCursors.keys()) if (!places.includes(place)) targetCursors.delete(place);
+    if (!places.length) return null;
+    lastAt = now(); const place = places[placeCursor++ % places.length];
+    if (!allowed(place)) return null;
+    sweeping = (async () => {
+      try {
+        const targets = targetsFor(place);
+        if (!targets.length) return;
+        const cursor = targetCursors.get(place) ?? 0;
+        const target = targets[cursor % targets.length];
+        targetCursors.set(place, cursor + 1);
+        await attemptTarget(place, target);
+      } catch (error) { log(`local cleanup incomplete: ${error.message}`); }
+      finally { sweeping = null; }
+    })();
+    return sweeping;
+  };
+  return { reconcileLocalCleanup, cleanupBusy: () => sweeping !== null };
+}

package/bin/lib/workMergeBatch.mjs

@@ -9,7 +9,7 @@ import { mergeBatchPrompt, MERGE_BATCH_SYSTEM } from './repositoryPrompts.mjs';
 import { runTurn } from './runTurn.mjs';
 import { runCappedTurn } from './workCappedTurn.mjs';
 import { candidateObjects } from './modelJson.mjs';
-import { pickRuntimeFor } from './runtimeDetection.mjs';
+import { brainFor } from './workBrain.mjs';
 import { fleetRequest } from './fleetPost.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
 import { FLEET_URL, DAEMON_INSTANCE } from './config.mjs';
@@ -20,6 +20,22 @@ import { isSafePathSegment, stripUrlUserinfo } from './git.mjs';
 import { killGroup } from './processGroup.mjs';
 import { readConfiguredCheck } from './workAgentCheck.mjs';
 
+/** A joint repair has no unique originating brain when its members differ. */
+export function mergeBatchBrain(members, coordinatorAgentId) {
+  if (!members?.length) throw new Error('The selected merge has no originating agent.');
+  if (coordinatorAgentId) {
+    const selected = members.find(member => member.agentId === coordinatorAgentId);
+    if (!selected) throw new Error('The selected merge coordinator is not part of this merge.');
+    const runtime = selected.runtime || 'claude';
+    return { runtime, ...brainFor(selected, runtime) };
+  }
+  const picks = members.map(member => ({ runtime: member.runtime || 'claude', model: member.model || null, effort: member.effort || null }));
+  const first = picks[0];
+  if (picks.some(pick => pick.runtime !== first.runtime || pick.model !== first.model || pick.effort !== first.effort))
+    throw new Error('The selected agents use different CLI/model/effort choices. Merge them separately so repair uses each agent’s own choice.');
+  return { runtime: first.runtime, ...brainFor(first, first.runtime) };
+}
+
 export function createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPlace, runCheck, workChildren, groupKillChildren, admit, onRepoChanged, landed, runCli = runTurn }) {
   const request = async (route, body) => {
     const response = await fleetRequest(fleetEndpoint(route, FLEET_URL), { body: { ...body, instance: DAEMON_INSTANCE } });
@@ -64,15 +80,14 @@ export function createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPl
             if (!result?.ok) throw new Error('Batch ownership or progress changed. Retry will remeasure base.');
           },
           coordinate: async (context) => {
-            const runtime = leader.runtime || pickRuntimeFor('build');
-            if (!runtime) throw new Error('No coding CLI is installed on this machine to coordinate the batch.');
+            const brain = mergeBatchBrain(spec.members, spec.coordinatorAgentId);
             let child;
             try {
               const result = await runCappedTurn({ runTurn: runCli, workChildren, releaseSlot: release,
                 transcriptCwd: context.repositories[0].integrationWorktree, capMs: 20 * 60_000, killChild: killGroup,
                 onSpawn: (ch) => { child = ch; groupKillChildren?.add(ch); },
                 turnArgs: { prompt: mergeBatchPrompt(context), system: MERGE_BATCH_SYSTEM,
-                  runtime, profile: 'build', knowledgeDir: knowledgeDirFor(repoRoot), model: leader.model || undefined, effort: leader.effort || undefined,
+                  ...brain, profile: 'build', knowledgeDir: knowledgeDirFor(repoRoot),
                   cwd: context.repositories[0].integrationWorktree, writableDirs: context.repositories.filter((r) => !r.alreadyLanded).map((r) => r.integrationWorktree),
                   answerFromResult: true, work } });
               if (result.wedged) throw new Error('The coordinating CLI ran out of time. Retry the batch to continue with its saved integration work.');

package/bin/lib/workSessionGroups.mjs

@@ -11,6 +11,7 @@
  * manager against a real registry file.
  */
 import { join } from 'node:path';
+import { constants, openSync, closeSync, fstatSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
 import { measureProcesses, liveGroups, processesSupported } from './processes.mjs';
@@ -162,5 +163,23 @@ export function createWorkSessionGroups({ repoRoot }) {
     return measureProcesses(alive, { scrub: envScrub });
   };
 
-  return { sessionGroups, noteSessionGroup, pruneSessionGroups, sessionProcesses };
+  /** Cleanup needs stronger evidence than a display: reload the durable
+   * registry to observe peer/orphan groups, and retain on missing/bad reads. */
+  const cleanupProcessesIdle = place => {
+    if (!processesSupported()) return null;
+    let fd;
+    try {
+      fd = openSync(GROUPS_FILE, constants.O_RDONLY | constants.O_NOFOLLOW);
+      const st = fstatSync(fd);
+      if (!st.isFile() || st.size > 256 * 1024) return null;
+      const entries = JSON.parse(readFileSync(fd, 'utf8'));
+      if (!Array.isArray(entries) || entries.length >= 32 || entries.some(e =>
+        typeof e?.sessionId !== 'string' || !Number.isInteger(e.pid) || e.pid <= 1 || typeof e.boot !== 'string' || !e.boot)) return null;
+      const groups = new Set(sessionGroups.get(place) ?? []);
+      for (const entry of entries) if (entry.sessionId === place && sameBoot(entry.boot, BOOT)) groups.add(entry.pid);
+      return liveGroups(groups).size === 0;
+    } catch { return null; }
+    finally { if (fd !== undefined) closeSync(fd); }
+  };
+  return { sessionGroups, noteSessionGroup, pruneSessionGroups, sessionProcesses, cleanupProcessesIdle };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.125.17",
+  "version": "0.125.20",
   "description": "Run your own coding CLIs as build agents for Flowviant \u2014 Claude Code, Codex or Antigravity, on your own credentials. Holds your sessions, keeps a worktree per tab, and ships branches on your word.",
   "type": "module",
   "bin": {