flowviant 0.125.21 → 0.125.23

package/bin/lib/workAgentTurnExecution.mjs

@@ -2,7 +2,7 @@ import { reportLocalCleanup } from './localCleanupReport.mjs';
 import { createManagedLocalCleanup } from './managedLocalCleanup.mjs';
 import { createCaptureRetention } from './referenceCaptures.mjs';
 import { imageRevisionInstructions } from './artifactIteration.mjs';
-import { agentChildScope } from './agentQueueContext.mjs';
+import { agentChildScope, sourceChatText } from './agentQueueContext.mjs';
 import { measureTestFindings } from './testFindings.mjs';
 import { fetchResultInputs } from './resultInputs.mjs';
 import { agentWork } from './workActivity.mjs';
@@ -33,7 +33,7 @@ import { setRuntimeLimit } from './daemonState.mjs';
 import { gitOrNull } from './git.mjs';
 import { turnCommits } from './turnReceipts.mjs';
 import { addUsage } from './turnUsage.mjs';
-import { stashCard } from './agentCards.mjs';
+import { stashCard, stashGaps } from './agentCards.mjs';
 import { c } from './ui.mjs';
 import { runTurn } from './runTurn.mjs';
 import { liveGroups, processesSupported } from './processes.mjs';
@@ -67,6 +67,7 @@ import { codexSubagentsSafe } from './runtimeCodex.mjs';
 import { measuredRuntimeVersion } from './runtimeDetection.mjs';
 import { createIntermediateArtifacts } from './intermediateArtifacts.mjs';
 import { createUiReview } from './uiReview.mjs';
+import { createVideoRender } from './videoRender.mjs';
 import { withUiReview, appendUiReviewEvidence } from './uiReviewTurn.mjs';
 
 export function createAgentTurnExecution({
@@ -98,6 +99,7 @@ export function createAgentTurnExecution({
   runTurnImpl = runTurn,
   exportModel,
   makeUiReview = createUiReview,
+  makeVideoRender = createVideoRender,
 }) {
   const reportDelivery = createDeliveryReporter();
   /** How long the final flush may hold the settle. Bounded because the settle
@@ -326,7 +328,7 @@ export function createAgentTurnExecution({
       stashCard(
         sessionMetaPath(wt, 'flowviant-agent-cards', agentId),
         job.task.id,
-        AGENT_TASK_SPEC(job.task, job.cardThread, files.card)
+        AGENT_TASK_SPEC(job.task, job.cardThread, files.card) + sourceChatText(job.queueContext, job.task.id)
       );
     }
 
@@ -404,9 +406,14 @@ export function createAgentTurnExecution({
     let uiReview = null;
     let uiReviewNote = '';
     let uiReviewEvidence = '';
+    // A video card's render tool (videoRender.mjs), and the words a turn
+    // gets when it could not be held, so it stops rather than guesses.
+    let videoRender = null;
+    let videoNote = '';
     const runCli = (args) => {
       if (run.interrupted) return Promise.resolve('');
       args = withUiReview(args, uiReviewNote, uiReview?.env);
+      args = withUiReview(args, videoNote);
       return runTurnImpl(args);
     };
     /**
@@ -468,6 +475,10 @@ export function createAgentTurnExecution({
           uiReviewEvidence = uiReviewNote;
         }
       }
+      if (taskKind === 'video') {
+        try { videoRender = await makeVideoRender({ wt, signal: setupController.signal }); }
+        catch (error) { videoNote = `The card_video render tool could not be started on this machine: ${envScrub(error.message)}. Without it no GIF, MP4 or WebM can be rendered: say so in your answer and stop.`; }
+      }
       if (orchestrating) {
         orchestrator = await createOrchestrator({ turnId, runtime: rt, trace, admit,
           assignmentContext: () => agentChildScope(job),
@@ -478,7 +489,7 @@ export function createAgentTurnExecution({
           notify: message => liveInput ? run.live?.inject(message) === true : false,
           taken: id => run.live?.onTaken(id) });
       }
-      const tools = prepareCardTools({ rt, posture, wt, repoRoot, baseRef, sources: repositoryRun?.sources ?? [], repositoryTool: repositoryRun?.tool ?? null, orchestratorConfig: orchestrator?.config ?? null, uiReviewConfig: uiReview?.config, orchestrated: Boolean(orchestrator), codexHome: agentResume.codexHome });
+      const tools = prepareCardTools({ rt, posture, wt, repoRoot, baseRef, sources: repositoryRun?.sources ?? [], repositoryTool: repositoryRun?.tool ?? null, orchestratorConfig: orchestrator?.config ?? null, uiReviewConfig: uiReview?.config, videoConfig: videoRender?.config ?? null, orchestrated: Boolean(orchestrator), codexHome: agentResume.codexHome });
       projectTools = tools.projectTools;
       localCleanup?.begin(turnId);
       const { toolsNote } = tools;
@@ -733,6 +744,7 @@ export function createAgentTurnExecution({
       // The builder has finished its fix/recheck loop. Close only resources
       // owned by its review tool, then bind evidence to the final source
       // before the existing artifact upload and delivery settlement.
+      try { await videoRender?.close(); } catch { /* a closed listener */ }
       try { await uiReview?.close(); }
       finally {
         try { uiReviewEvidence = uiReview?.finalize() ?? uiReviewEvidence; }
@@ -845,6 +857,9 @@ export function createAgentTurnExecution({
       modelExports: intermediateDelivery?.modelExports,
     });
     appendUiReviewEvidence(body, uiReviewEvidence);
+    // The agent's own account of what it did not deliver, for the pre-review.
+    if (job.kind === 'task' && job.task && body.outcome === 'delivered' && res?.gaps)
+      stashGaps(sessionMetaPath(wt, 'flowviant-agent-cards', agentId), job.task.id, res.gaps);
     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.

package/bin/lib/workAgentTurnOutcome.mjs

@@ -34,6 +34,7 @@ import { usableImageArtifact } from './imageArtifact.mjs';
 import { withoutTurnDeclaration } from './turnDeclaration.mjs';
 import { ANSWER_DELIVERED_USES, researchUseOf, withResearchHeader } from './researchUse.mjs';
 import { measuredModelExports } from './intermediateArtifacts.mjs';
+import { gapsMarkdown } from './turnGaps.mjs';
 
 /** Materialization runs only for a declared delivery; settlement remains the
  * sole parser and the sole authority deciding whether it really delivered. */
@@ -166,6 +167,11 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
     : prerequisite?.taskKind === 'image' && (job.runtime ?? 'claude') !== 'codex'
       ? 'This agent runs on a CLI that cannot generate images. Image cards require Codex’s own image generation; this agent cannot run the requested texture work.'
       : null;
+  /* WHAT IT SAYS IT DID NOT DELIVER (turnGaps.mjs), where the person reads
+     the delivery: Verification on a code card, which carries it; the summary
+     on every other kind, which has no Verification lane. */
+  const gaps = res.outcome === 'delivered' && !cannotRequest ? gapsMarkdown(res.gaps) : null;
+  const verification = [res.verification, kind.posture === 'build' ? gaps : null].filter(Boolean).join('\n\n');
   return report(
     {
       turnId,
@@ -173,16 +179,20 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
       outcome: res.outcome,
       answer: cannotRequest ?? envScrub((kind.posture === 'research' && researchUse
         ? withResearchHeader(researchUse, res.answer ?? '') : res.answer ?? '') +
-        (job.task?.taskType === 'tests' && res.raised?.length ? '\n\nAdditional CLI-reported findings (not filed as fixes):\n' + res.raised.map(r => `${r.title}\n${r.brief ?? ''}`).join('\n\n') : '')),
+        (job.task?.taskType === 'tests' && res.raised?.length ? '\n\nAdditional CLI-reported findings (not filed as fixes):\n' + res.raised.map(r => `${r.title}\n${r.brief ?? ''}`).join('\n\n') : '') +
+        (gaps && kind.posture !== 'build' ? `\n\n${gaps}` : '')),
       // CLI-authored evidence travels separately from the short answer and
       // measured commits/checks. Older turns simply send no report.
-      ...(kind.posture === 'build' && res.outcome === 'delivered' && res.verification
-        ? { verification: envScrub(res.verification) } : {}),
+      ...(kind.posture === 'build' && res.outcome === 'delivered' && verification
+        ? { verification: envScrub(verification) } : {}),
       ...(kind.posture === 'build' && res.outcome === 'delivered' && res.handover
         ? { handover: envScrub(res.handover) } : {}),
       ...(kind.posture === 'build' && res.outcome === 'delivered' && res.automation
         ? { automation: envScrub(res.automation) } : {}),
       ...(commits.length ? { commits } : {}),
+      // …and the same gaps as data, so the server can propose the parts no
+      // card owned (`gapFollowUps.ts`). A report: an older server drops it.
+      ...(gaps && res.gaps?.length ? { gaps: res.gaps } : {}),
       // SCRUBBED like the answer beside it: a raised card lands in the
       // project doc every member reads, and a brief quoting the `.env` the
       // agent just read ("value sk_live_… is logged in pay.ts") went out

package/bin/lib/worktreeDiff.mjs

@@ -13,6 +13,17 @@
  * uncommitted work in the same total. Untracked files count too: git calls them
  * nothing until they are added, and a human calls them new work.
  *
+ * …AND THAT WHOLE SPLIT IN TWO (2026-10-25). The agent page's Changes counts
+ * the branch's COMMITS, so beside the whole it read as a disagreement: "Native
+ * 3D viewer" said +78 −12 in Changes and +114 −15 on the branch row (a running
+ * card's commit on top), and "New task submission" said "Nothing committed
+ * yet" beside +613 −294 of work nobody had committed. `committed` is
+ * `<merge-base>..HEAD` — the figure Changes agrees with — and `uncommitted` is
+ * HEAD against the working tree, untracked files again counted as additions,
+ * with its own rows so the page can list it apart. The halves need not sum to
+ * the whole: a line a commit changed and the working tree changed back counts
+ * in both and in neither, which is git's arithmetic, relayed.
+ *
  * It also carries THIS BRANCH'S OWN COMMITS and the cards they name — see
  * `branchCommits` below. That rides here rather than on a route of its own
  * because this sweep is already standing in the right directory on the right
@@ -252,16 +263,104 @@ function countLines(buf) {
   return s.endsWith('\n') ? n - 1 : n;
 }
 
+/** One diffstat row. The path is clamped to the server's zod cap (file path ≤
+ *  300 — see the caps at worktreeDiff's return): one over-cap string would 400
+ *  the whole report batch, and a readout must degrade to a shorter label, never
+ *  to silence. Null for an empty path, which names nothing. */
+function fileRow(path, added, deleted, binary = false) {
+  if (!path) return null;
+  path = path.slice(0, 300);
+  return binary ? { path, added, deleted, binary } : { path, added, deleted };
+}
+
+/**
+ * `git diff --numstat -z <revs…> --`, read as rows — the one reader of that
+ * output, for the whole and both halves alike. Throws when git does.
+ *
+ * `-z`, for the reason gitRaw exists: git's LINE-based output C-quotes any path
+ * that is not plain ASCII, so an accented filename arrives as "n\303\251w.txt"
+ * — a string that is not the path and reads as escaped garbage in the rail.
+ * And `--numstat -z` frames a normal change as one field, "added\tdeleted\tpath",
+ * but a RENAME as three: "added\tdeleted\t" (empty path), then the old path,
+ * then the new one. An empty path is therefore the rename marker and the next
+ * two fields belong to it — read line-wise, a rename would report a file
+ * literally named "old => new".
+ */
+function numstatRows(revs, wt) {
+  const rows = [];
+  const fields = splitNul(gitRaw(['diff', '--numstat', '-z', ...revs, '--'], wt));
+  for (let i = 0; i < fields.length; i++) {
+    const [a, d, ...rest] = fields[i].split('\t');
+    let path = rest.join('\t');
+    if (!path) {
+      path = fields[i + 2] ?? fields[i + 1]; // the post-rename name is what exists now
+      i += 2;
+      if (!path) continue;
+    }
+    const binary = a === '-' || d === '-';
+    const row = fileRow(path, binary ? 0 : Number(a) || 0, binary ? 0 : Number(d) || 0, binary);
+    if (row) rows.push(row);
+  }
+  return rows;
+}
+
+/** The same rows, or NULL when git would not answer — kept apart from an
+ *  empty diff, so a failed read omits its half rather than reporting zeros. */
+function numstatOrNull(revs, wt) {
+  try {
+    return numstatRows(revs, wt);
+  } catch {
+    return null;
+  }
+}
+
+/** A diffstat summed from its rows: totals and `fileCount` over ALL of them,
+ *  and the biggest MAX_FILES as the rows reported, `truncated` saying how many
+ *  were left out. */
+function diffstat(rows) {
+  // Biggest first: with a 20-row cap, the rows that survive should be the ones
+  // worth looking at. Ties break by path so the list doesn't shuffle per sweep.
+  const files = [...rows].sort(
+    (x, y) => y.added + y.deleted - (x.added + x.deleted) || (x.path < y.path ? -1 : 1)
+  );
+  let additions = 0;
+  let deletions = 0;
+  for (const f of files) {
+    additions += f.added;
+    deletions += f.deleted;
+  }
+  return {
+    additions,
+    deletions,
+    fileCount: files.length,
+    truncated: Math.max(0, files.length - MAX_FILES),
+    files: files.slice(0, MAX_FILES),
+  };
+}
+
 /**
  * @param {string} wt   the worktree directory
  * @param {string} baseRef  the project's base ref (e.g. `origin/main`)
- * @returns {null | {branch:string, path:string, ahead:number, behind:number,
- *   baseLabel:string, baseCommits:{sha:string, subject:string, author:string}[],
+ * @returns {null | {branch:string, headSha?:string, path:string, ahead:number,
+ *   behind:number, baseLabel:string,
+ *   baseCommits:{sha:string, subject:string, author:string}[],
  *   dirty:boolean, additions:number, deletions:number, fileCount:number,
  *   truncated:number,
  *   files:{path:string, added:number, deleted:number, binary?:boolean}[],
+ *   committed?:{additions:number, deletions:number, fileCount:number},
+ *   uncommitted?:{additions:number, deletions:number, fileCount:number,
+ *     truncated:number,
+ *     files:{path:string, added:number, deleted:number, binary?:boolean}[]},
  *   commits:{sha:string, subject:string, author:string, at:string,
  *     additions:number, deletions:number, taskIds:string[]}[]}}
+ *
+ * The top-level additions/deletions/fileCount/truncated/files are the WHOLE
+ * (merge-base against the working tree, untracked included) — what the tab
+ * rails read. `committed` (`<merge-base>..HEAD`) and `uncommitted` (HEAD
+ * against the working tree, untracked included, with its own rows) split it
+ * for the agent page, which agrees with the first and lists the second apart.
+ * `committed` is absent without a merge-base; either half is absent when its
+ * git read failed — unknown, never a fabricated zero.
  */
 export function worktreeDiff(wt, baseRef) {
   if (!wt || !existsSync(wt)) return null;
@@ -289,52 +388,24 @@ export function worktreeDiff(wt, baseRef) {
        HEAD below, which still reports the uncommitted half honestly */
   }
 
-  const files = [];
-  let additions = 0;
-  let deletions = 0;
-  const push = (path, added, deleted, binary = false) => {
-    if (!path) return;
-    // Clamped to the server's zod cap (file path ≤ 300 — see the caps at the
-    // return, below): one over-cap string would 400 the whole report batch,
-    // and a readout must degrade to a shorter label, never to silence.
-    path = path.slice(0, 300);
-    files.push(binary ? { path, added, deleted, binary } : { path, added, deleted });
-    additions += added;
-    deletions += deleted;
-  };
-
   // Tracked: working tree vs base. `git diff <base>` (no --cached, no second
-  // ref) is exactly "everything this session did", committed or not. `-z`, for
-  // the reason gitRaw exists: git's LINE-based output C-quotes any path that
-  // is not plain ASCII, so an accented filename arrives as "n\303\251w.txt" —
-  // a string that is not the path and reads as escaped garbage in the rail.
-  try {
-    // `--numstat -z` frames a normal change as one field, "added\tdeleted\tpath",
-    // but a RENAME as three: "added\tdeleted\t" (empty path), then the old path,
-    // then the new one. An empty path is therefore the rename marker and the
-    // next two fields belong to it — read line-wise, a rename would report a
-    // file literally named "old => new".
-    const fields = splitNul(gitRaw(['diff', '--numstat', '-z', base || 'HEAD', '--'], wt));
-    for (let i = 0; i < fields.length; i++) {
-      const [a, d, ...rest] = fields[i].split('\t');
-      let path = rest.join('\t');
-      if (!path) {
-        path = fields[i + 2] ?? fields[i + 1]; // the post-rename name is what exists now
-        i += 2;
-        if (!path) continue;
-      }
-      const binary = a === '-' || d === '-';
-      push(path, binary ? 0 : Number(a) || 0, binary ? 0 : Number(d) || 0, binary);
-    }
-  } catch {
-    /* report what we have */
-  }
+  // ref) is exactly "everything this session did", committed or not. Without a
+  // merge-base it is HEAD, which is the uncommitted half alone — kept as rows
+  // OR NULL, so that half can reuse this read below without mistaking a failed
+  // one for a clean tree.
+  const trackedRows = numstatOrNull([base || 'HEAD'], wt);
 
   // Untracked, minus everything gitignored — new files are the most visible
   // work a session does and they would otherwise show as nothing at all. `-z`
   // here is not cosmetic: a C-quoted untracked name fails the statSync below,
   // and the catch swallowed the row — a session's brand-new `café.txt` simply
-  // vanished from the rail.
+  // vanished from the rail. Scanned ONCE: these rows belong to the whole and to
+  // the uncommitted half alike, and the scan opens files.
+  const untracked = [];
+  const pushUntracked = (path, added, binary = false) => {
+    const row = fileRow(path, added, 0, binary);
+    if (row) untracked.push(row);
+  };
   try {
     const others = splitNul(gitRaw(['ls-files', '--others', '--exclude-standard', '-z'], wt));
     for (const path of others.slice(0, MAX_UNTRACKED_SCAN)) {
@@ -343,12 +414,12 @@ export function worktreeDiff(wt, baseRef) {
         const st = statSync(full);
         if (!st.isFile()) continue;
         if (st.size > MAX_COUNT_BYTES) {
-          push(path, 0, 0, true);
+          pushUntracked(path, 0, true);
           continue;
         }
         const lines = countLines(readFileSync(full));
-        if (lines === null) push(path, 0, 0, true);
-        else push(path, lines, 0);
+        if (lines === null) pushUntracked(path, 0, true);
+        else pushUntracked(path, lines);
       } catch {
         /* vanished between listing and reading — it wasn't there to report */
       }
@@ -357,6 +428,37 @@ export function worktreeDiff(wt, baseRef) {
     /* report what we have */
   }
 
+  const whole = diffstat([...(trackedRows ?? []), ...untracked]);
+
+  // THE WHOLE, SPLIT IN TWO — see the header. Each half is its own git read
+  // and each degrades alone: a half git would not answer is OMITTED, because
+  // a zero there would claim a clean side nobody measured.
+  //
+  // Committed: `git diff <merge-base> HEAD`, only with a merge-base. Without
+  // one there is no "this branch's commits" to count, and the fallback above
+  // already diffed HEAD, which is the other half.
+  let committed = null;
+  if (base) {
+    const rows = numstatOrNull([base, 'HEAD'], wt);
+    if (rows) {
+      const { additions, deletions, fileCount } = diffstat(rows);
+      committed = { additions, deletions, fileCount };
+    }
+  }
+  // Uncommitted: `git diff HEAD` plus the untracked rows. An UNBORN HEAD has
+  // no commit, so everything there is uncommitted and the half is the whole —
+  // `git diff HEAD` fails on it, and that failure must not drop the half
+  // (defensive today: the branch read above already returns null on an unborn
+  // HEAD). With no merge-base the whole's tracked read already WAS `git diff
+  // HEAD`, so it is reused rather than run twice.
+  let uncommitted = null;
+  if (!headSha) {
+    uncommitted = { ...whole };
+  } else {
+    const rows = base ? numstatOrNull(['HEAD'], wt) : trackedRows;
+    if (rows) uncommitted = diffstat([...rows, ...untracked]);
+  }
+
   let ahead = 0;
   try {
     if (base) ahead = Number(git(['rev-list', '--count', `${base}..HEAD`], wt)) || 0;
@@ -403,11 +505,6 @@ export function worktreeDiff(wt, baseRef) {
     /* leave at false */
   }
 
-  // Biggest first: with a 20-row cap, the rows that survive should be the ones
-  // worth looking at. Ties break by path so the list doesn't shuffle per sweep.
-  files.sort(
-    (x, y) => y.added + y.deleted - (x.added + x.deleted) || (x.path < y.path ? -1 : 1)
-  );
   // Every string here is clamped to the server's own zod caps (branch ≤ 200,
   // baseLabel ≤ 120, subject ≤ 200, author ≤ 80, file path ≤ 300): the report
   // rides in a BATCH, so a single over-cap string — a generated branch name, a
@@ -421,11 +518,13 @@ export function worktreeDiff(wt, baseRef) {
     baseLabel: String(baseRef).replace(/^origin\//, '').slice(0, 120),
     baseCommits,
     dirty,
-    additions,
-    deletions,
-    fileCount: files.length,
-    truncated: Math.max(0, files.length - MAX_FILES),
-    files: files.slice(0, MAX_FILES),
+    additions: whole.additions,
+    deletions: whole.deletions,
+    fileCount: whole.fileCount,
+    truncated: whole.truncated,
+    files: whole.files,
+    ...(committed ? { committed } : {}),
+    ...(uncommitted ? { uncommitted } : {}),
     commits: branchCommits(wt, base),
   };
 }

package/package.json

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