flowviant 0.125.18 → 0.125.21

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/bin/lib/workToolLog.mjs

@@ -9,6 +9,7 @@
  */
 import { toolEventOf } from './runtimeEvents.mjs';
 import { scrubCut, scrub as envScrub } from './uplinkScrub.mjs';
+import { observeWebsite } from './websiteAccess.mjs';
 
 /**
  * THE TURN'S TOOL LOG — the structured relay behind the transcript's
@@ -47,7 +48,15 @@ export function createToolLog(cwd) {
     e.outcome = !meta.result ? 'unknown' : failed ? 'failed' :
       meta.runtime === 'codex' && code === undefined ? 'unknown' : 'success';
     if (code !== undefined) e.exitCode = code;
-    if (failed) {
+    if (e.website) {
+      observeWebsite(e, meta, envScrub);
+      if (e.errorTruncated) toolLog.state = 'partial';
+    }
+    if (e.outcome === 'failed') {
+      if (e.website) {
+        if (!toolLog.firstFailure) { toolLog.firstFailure = structuredClone(e); toolLog.recovery = []; }
+        return;
+      }
       const output = scrubCut(meta.output ?? '', 16_384);
       const guardAt = output.indexOf('flowviant: this turn is read-only, so ');
       const guard = guardAt >= 0 ? output.slice(guardAt).split('\n', 1)[0] : undefined;
@@ -67,8 +76,19 @@ export function createToolLog(cwd) {
   };
   const pushToolEvent = (name, input, meta = {}) => {
     const id = typeof meta.id === 'string' && meta.id && meta.id.length <= 160 ? meta.id : undefined;
-    const existing = id && correlated.get(id);
+    const key = id && JSON.stringify([meta.agentId ?? null, id]);
+    const existing = key && correlated.get(key);
     if (existing) {
+      // Codex may only name the web action/URL on completion. Enrich that
+      // same native request instead of keeping its provisional search label.
+      if (existing.website && name) {
+        const request = toolEventOf(name, input, cwd, envScrub)?.website;
+        if (request) {
+          existing.website.method = request.method;
+          existing.website.tool = request.tool;
+          if (request.requestedUrl) existing.website.requestedUrl = request.requestedUrl;
+        }
+      }
       if (meta.result) observe(existing, meta);
       refresh();
       return existing;
@@ -87,7 +107,7 @@ export function createToolLog(cwd) {
     if (typeof meta.agentId === 'string' && meta.agentId) e.agentId = scrubCut(meta.agentId, 160);
     if (e.agentId && typeof meta.agentTitle === 'string' && meta.agentTitle) e.agentTitle = scrubCut(meta.agentTitle, 120);
     if (e.t !== 'plan') {
-      if (id) { e.id = scrubCut(id, 160); correlated.set(id, e); }
+      if (id) { e.id = scrubCut(id, 160); correlated.set(key, e); }
       if (name === 'Read') for (const key of ['offset', 'limit']) {
         if (Number.isSafeInteger(input?.[key]) && input[key] >= 0) e[key] = input[key];
       }
@@ -115,6 +135,7 @@ export function createToolLog(cwd) {
         last.errorCategory === e.errorCategory &&
         last.offset === e.offset && last.limit === e.limit &&
         last.t === e.t &&
+        !e.website && !last.website &&
         last.p === e.p &&
         last.q === e.q &&
         last.c === e.c;

package/package.json

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