flowviant 0.73.0 → 0.74.0

package/bin/lib/claude.mjs

@@ -197,7 +197,7 @@ const oneLine = (s, n = 160) => String(s).replace(/\s+/g, ' ').trim().slice(0, n
 // every intermediate text block still NARRATES, but only the final `result`
 // event contributes text — otherwise the same sentences arrive twice, once as
 // they stream and once in the result, and the tab posts the duplicate.
-function handleStreamLine(line, { cwd, emit, onActivity, appendText, answerFromResult, onInit }) {
+function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText, answerFromResult, onInit }) {
   let ev;
   try {
     ev = JSON.parse(line);
@@ -222,6 +222,10 @@ function handleStreamLine(line, { cwd, emit, onActivity, appendText, answerFromR
         push({ kind: 'say', label: oneLine(b.text) });
       } else if (b.type === 'tool_use') {
         push(humanizeToolUse(b.name, b.input || {}, cwd));
+        // The STRUCTURED form of the same event, for the transcript's tool
+        // cards — raw name + input, so the collector can keep what the
+        // one-line humanizer drops (an Edit's counts, the plan's items).
+        onToolEvent?.(b.name, b.input || {});
       }
     }
   } else if (ev.type === 'system' && ev.subtype === 'init') {
@@ -270,7 +274,7 @@ function handleStreamLine(line, { cwd, emit, onActivity, appendText, answerFromR
 // returned string for sentinel detection, and each activity is handed to
 // `onActivity` so the caller can forward progress. Build-agent turns leave it
 // off and keep the raw text passthrough + line sentinels.
-export function runTurn({ prompt, resume, system, cwd, mcpConfig, mcpArgs, mcpEnv, runtime = 'claude', label, onSpawn, streamJson, answerFromResult, onActivity, onInit, onThreadId, wikiPerm, readOnly, planPerm, vaultDir, resultSchemaArgs, model, effort, adoptResumeId, resumeThreadId, resumeConversationId }) {
+export function runTurn({ prompt, resume, system, cwd, mcpConfig, mcpArgs, mcpEnv, runtime = 'claude', label, onSpawn, streamJson, answerFromResult, onActivity, onToolEvent, onInit, onThreadId, wikiPerm, readOnly, planPerm, vaultDir, resultSchemaArgs, model, effort, adoptResumeId, resumeThreadId, resumeConversationId }) {
   return new Promise((resolve) => {
     const rt = runtimeById(runtime);
     if (!rt.args) {
@@ -401,7 +405,7 @@ export function runTurn({ prompt, resume, system, cwd, mcpConfig, mcpArgs, mcpEn
       /** One line of the child's stdout, in whichever dialect it speaks. */
       const onLine = (line) => {
         if (!rt.parse)
-          return handleStreamLine(line, { cwd, emit, onActivity, appendText, answerFromResult, onInit });
+          return handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText, answerFromResult, onInit });
         const ev = rt.parse(line, cwd);
         if (!ev) return;
         // The conversation id, when the runtime announces one (codex's

package/bin/lib/runtimes.mjs

@@ -89,11 +89,87 @@ export function humanizeClaudeTool(name, input = {}, cwd = '') {
         command: String(input.command ?? '').slice(0, 2000),
         label: `$ ${oneLine(input.command, 60)}`,
       };
+    case 'TodoWrite': {
+      // The CLI's own todo list — the plan the transcript's PLAN card renders.
+      // The label narrates the change ("plan: 2 of 5 — cut over /api/session");
+      // the structured items ride through toolEventOf below.
+      const todos = Array.isArray(input.todos) ? input.todos : [];
+      if (todos.length === 0) return null;
+      const done = todos.filter((t) => t?.status === 'completed').length;
+      const active = todos.find((t) => t?.status === 'in_progress');
+      return {
+        kind: 'plan',
+        label: `plan: ${done} of ${todos.length}${active?.content ? ` — ${oneLine(active.content, 60)}` : ''}`,
+      };
+    }
     default:
       return null; // other tools: silent
   }
 }
 
+/**
+ * Tool-call → ONE STRUCTURED EVENT for the transcript's tool cards — the
+ * relay's durable form, where `humanizeClaudeTool` above is its one-line live
+ * form. Same source (the CLI's own tool_use input), zero inference: every
+ * field is something the CLI emitted, and a tool this doesn't know renders as
+ * nothing rather than as a guess.
+ *
+ * Wire vocabulary (compact keys — this rides a 1.5s-throttled POST):
+ *   t: read|edit|write|grep|glob|bash|task|plan
+ *   p: path (worktree-relative)   q: pattern/description   c: command
+ *   a/d: line counts added/deleted (from the input's own strings)
+ *   dl: a few "-/+" prefixed preview lines of an Edit
+ *   items: the plan's todos, x = text, s = done|active|open
+ *
+ * The CALLER scrubs (work.mjs envScrub) — this stays a pure shape function so
+ * it is testable without a vault.
+ */
+export function toolEventOf(name, input = {}, cwd = '') {
+  const rel = (p) => shortPath(p, cwd).slice(0, 300);
+  const lines = (s) => (s ? String(s).split('\n').length : 0);
+  switch (name) {
+    case 'Read':
+      return { t: 'read', p: rel(input.file_path) };
+    case 'Write':
+      return { t: 'write', p: rel(input.file_path), a: lines(input.content) };
+    case 'Edit': {
+      const oldS = String(input.old_string ?? '');
+      const newS = String(input.new_string ?? '');
+      // A MINI-DIFF, not the diff: the first lines of each side, enough to
+      // recognise the change at a glance. The real diff lives in git.
+      const dl = [
+        ...oldS.split('\n').slice(0, 2).map((l) => `- ${l}`),
+        ...newS.split('\n').slice(0, 3).map((l) => `+ ${l}`),
+      ].map((l) => l.slice(0, 160));
+      return { t: 'edit', p: rel(input.file_path), a: lines(newS), d: lines(oldS), dl };
+    }
+    case 'Grep':
+      return {
+        t: 'grep',
+        q: String(input.pattern ?? '').slice(0, 200),
+        ...(input.path ? { p: rel(input.path) } : {}),
+      };
+    case 'Glob':
+      return { t: 'glob', q: String(input.pattern ?? '').slice(0, 200) };
+    case 'Bash':
+      return { t: 'bash', c: String(input.command ?? '').slice(0, 200) };
+    case 'Task':
+      return { t: 'task', q: String(input.description ?? '').slice(0, 200) };
+    case 'TodoWrite': {
+      const todos = Array.isArray(input.todos) ? input.todos.slice(0, 20) : [];
+      const items = todos
+        .map((td) => ({
+          x: String(td?.content ?? '').slice(0, 120),
+          s: td?.status === 'completed' ? 'done' : td?.status === 'in_progress' ? 'active' : 'open',
+        }))
+        .filter((i) => i.x);
+      return items.length ? { t: 'plan', items } : null;
+    }
+    default:
+      return null;
+  }
+}
+
 // ── Codex ──────────────────────────────────────────────────────────────────
 
 /**

package/bin/lib/work.mjs

@@ -55,7 +55,7 @@ import {
   WORK_TURN_KICKOFF_PLAIN,
 } from './prompts.mjs';
 import { materializeInto, hasMaterialized, excludeInWorktree, scrub as envScrub } from './env.mjs';
-import { detectRuntimes, canRun, recordSkills, RUNTIMES } from './runtimes.mjs';
+import { detectRuntimes, canRun, recordSkills, toolEventOf, RUNTIMES } from './runtimes.mjs';
 
 /** The place id meaning "the checkout", not a worktree. Must match the
  *  server's REPO_PLACE — it is a wire value, not a local convention. */
@@ -336,6 +336,7 @@ export function createWorkManager({
       // an action that changes what the machine would measure must cause a new
       // measurement, and the 60s sweep is not that.
       void reportPlaceWorktrees(sessionId).catch(() => {});
+      burstListeners(sessionId);
       // …and the REPO picture changed too: the session branch is gone and base
       // moved. Without this the Repository block keeps counting a branch the
       // ship just deleted.
@@ -364,7 +365,7 @@ export function createWorkManager({
    *  line over the finished reply — the server drops narration for a turn
    *  that is no longer pending. (A session-level pending count can't tell the
    *  settled turn's stale line from the queued NEXT turn's fresh one.) */
-  const makeNarrator = (sessionId, turnId) => {
+  const makeNarrator = (sessionId, turnId, getTools) => {
     const recent = [];
     let lastSent = 0;
     let dirty = false;
@@ -386,7 +387,15 @@ export function createWorkManager({
             'Content-Type': 'application/json',
           },
           signal: AbortSignal.timeout(10_000),
-          body: JSON.stringify({ sessionId, turnId, lines }),
+          body: JSON.stringify({
+            sessionId,
+            turnId,
+            lines,
+            // The structured tool log so far, riding the same throttled beat.
+            // Same lifecycle as the lines: overwritten as the turn moves,
+            // cleared server-side at settle. Absent until something ran.
+            ...(getTools ? { tools: getTools() } : {}),
+          }),
         });
       } catch {
         /* narration is decoration — a dropped line is not an incident */
@@ -649,6 +658,69 @@ export function createWorkManager({
     const reports = ids.map(sessionWorktreeReport).filter(Boolean);
     if (reports.length) await postWorktrees(reports);
   };
+
+  /**
+   * THE FIRST MINUTE AFTER A SETTLE — when "run the dev server" actually binds.
+   *
+   * The settle-time report fires the moment the reply lands, but a dev server
+   * the agent just started usually takes a few more seconds to open its socket
+   * (vite boots, next compiles). It therefore missed the settle measurement and
+   * waited the full 60s sweep — up to a minute of "nothing is running here"
+   * over a server that was already up, which is the slowest link in the whole
+   * "ask for dev → see the preview" chain. Asked directly: "how do we make it
+   * more responsive when the user prompts claude to run dev to waiting for it
+   * to appear on the preview?"
+   *
+   * A DECAYING BURST, and it re-CHECKS before it re-REPORTS: each beat walks
+   * /proc for the place's listeners (purely local, no git, no network) and only
+   * when the PORT SET actually changed does the full place report run and post.
+   * A settle where nothing ever binds costs five /proc walks and zero posts; a
+   * dev server that binds at +7s is on the wire at +9 instead of +60. The burst
+   * for a place restarts on its next settle, so overlapping turns cannot stack
+   * timers, and every timer is unref'd — a readout must never hold the process
+   * open.
+   *
+   * This also serves the OPPOSITE transition for free: a stopped dev server
+   * (the panel's Stop, a ctrl-C in a terminal) vanishes from the port set the
+   * same way it appeared, so the preview's "origin gone" story starts in
+   * seconds too.
+   */
+  const LISTEN_BURST_DELAYS_MS = [4_000, 9_000, 16_000, 30_000, 55_000];
+  const listenBursts = new Map(); // place -> timers[]
+  const listenSignature = (wt) => {
+    try {
+      const l = measureListeners(wt);
+      return l.rows.map((r) => r.port).sort((a, b) => a - b).join(',');
+    } catch {
+      return '';
+    }
+  };
+  const burstListeners = (sessionId) => {
+    try {
+      const place = placeOf(sessionId);
+      for (const t of listenBursts.get(place) ?? []) clearTimeout(t);
+      const wt = placeDir(sessionId);
+      // Captured alongside the settle report, so only a CHANGE after this
+      // moment triggers a post — the settle report already said the rest.
+      let last = listenSignature(wt);
+      const timers = LISTEN_BURST_DELAYS_MS.map((d) =>
+        setTimeout(() => {
+          try {
+            const sig = listenSignature(wt);
+            if (sig === last) return;
+            last = sig;
+            void reportPlaceWorktrees(sessionId).catch(() => {});
+          } catch {
+            /* a readout — the sweep still carries it */
+          }
+        }, d)
+      );
+      for (const t of timers) t.unref?.();
+      listenBursts.set(place, timers);
+    } catch {
+      /* never let the burst break a settle */
+    }
+  };
   /** Every live session, throttled — called from the reconcile loop. */
   /**
    * A SESSION NOBODY HAS MEASURED YET JUMPS THE SWEEP (2026-08-26).
@@ -2318,7 +2390,66 @@ export function createWorkManager({
           let seenThreadId = null; // codex's conversation id, off thread.started
           let seenClaudeSession = null; // claude's own conversation id, off system.init
           const spawned = []; // this turn's children, for the teardown registry
-          const narrator = makeNarrator(job.sessionId, job.id);
+          /**
+           * THE TURN'S TOOL LOG — the structured relay behind the transcript's
+           * tool cards. Same source as the narrator (the CLI's own tool_use
+           * events), zero inference; scrubbed AT COLLECTION so every copy that
+           * leaves the machine — live beat and settle alike — is already clean.
+           *
+           * Shape rules, applied here because the collector is the one writer:
+           *   · consecutive identical read/grep/glob/bash/task events collapse
+           *     into one row with a count (n);
+           *   · consecutive edits of ONE file merge, summing counts, keeping
+           *     the newest preview;
+           *   · the PLAN is a single event — a new TodoWrite replaces the old
+           *     plan at the current position, so the log shows the latest plan
+           *     where it last changed rather than five stale copies;
+           *   · capped at the newest 60, with the shed counted (`dropped`) —
+           *     scrollback semantics, the same trade the transcript itself
+           *     makes.
+           */
+          const toolLog = { ev: [], dropped: 0 };
+          const scrubEv = (e) => {
+            for (const k of ['p', 'q', 'c']) if (typeof e[k] === 'string') e[k] = envScrub(e[k]);
+            if (Array.isArray(e.dl)) e.dl = e.dl.map((l) => envScrub(l));
+            if (Array.isArray(e.items)) for (const i of e.items) i.x = envScrub(i.x);
+            return e;
+          };
+          const pushToolEvent = (name, input) => {
+            const e = toolEventOf(name, input, dir.wt);
+            if (!e) return;
+            scrubEv(e);
+            if (e.t === 'plan') {
+              const i = toolLog.ev.findIndex((x) => x.t === 'plan');
+              if (i >= 0) toolLog.ev.splice(i, 1);
+              toolLog.ev.push(e);
+            } else {
+              const last = toolLog.ev[toolLog.ev.length - 1];
+              const sameKey =
+                last &&
+                last.t === e.t &&
+                last.p === e.p &&
+                last.q === e.q &&
+                last.c === e.c;
+              if (sameKey && (e.t === 'edit' || e.t === 'write')) {
+                last.n = (last.n ?? 1) + 1;
+                last.a = (last.a ?? 0) + (e.a ?? 0);
+                last.d = (last.d ?? 0) + (e.d ?? 0);
+                if (e.dl) last.dl = e.dl;
+              } else if (sameKey) {
+                last.n = (last.n ?? 1) + 1;
+              } else {
+                toolLog.ev.push(e);
+              }
+            }
+            while (toolLog.ev.length > 60) {
+              toolLog.ev.shift();
+              toolLog.dropped++;
+            }
+          };
+          const narrator = makeNarrator(job.sessionId, job.id, () =>
+            toolLog.ev.length > 0 ? toolLog : undefined
+          );
 
           // THE COMMAND AUDIT — every `$ …` the CLI's stream reports, batched
           // to the server verbatim so an admin can read what actually ran on
@@ -2412,6 +2543,8 @@ export function createWorkManager({
                 narrator.line(a?.label);
                 auditCommand(a);
               },
+              // The structured twin of the line above — see toolLog.
+              onToolEvent: pushToolEvent,
               // What this CLI says it can be asked for by name. Harvested off
               // the init event the stream already carries — no probe, no scan,
               // no extra spawn — and reported on the next roster poll so the
@@ -2572,6 +2705,10 @@ export function createWorkManager({
             // here. Recording the path unconditionally is how a crashed first
             // turn used to brick resume for the session's whole life.
             ...(answer.length > 0 ? { sessionRef: dir.wt } : {}),
+            // The turn's tool log, in final form — the durable copy that lands
+            // on the settled message (the live copy on the record is cleared
+            // at settle). Already scrubbed at collection.
+            ...(toolLog.ev.length > 0 ? { tools: toolLog } : {}),
           });
           if (answer.length > 0) ok(`${c.cyan('tab')} ${c.dim('— replied in the session')}`);
           else warn('session turn produced no output — settled as failed');
@@ -2592,6 +2729,7 @@ export function createWorkManager({
           // awaited: this runs inside the session's chain, and a slow POST
           // would delay the next turn of that tab behind a readout.
           void reportPlaceWorktrees(job.sessionId).catch(() => {});
+          burstListeners(job.sessionId);
         }
       });
     }

package/bin/lib/worktreeDiff.mjs

@@ -169,6 +169,16 @@ export function worktreeDiff(wt, baseRef) {
   } catch {
     return null; // not a worktree (or not readable) — report nothing, not zeros
   }
+  // The commit HEAD names, for the strip's branch chip. Best-effort: an
+  // unborn branch (fresh repo, no commit yet) has a name and no sha, and the
+  // report simply omits the key — absent must never become an empty string,
+  // which would render as a blank chip.
+  let headSha = '';
+  try {
+    headSha = git(['rev-parse', 'HEAD'], wt);
+  } catch {
+    /* unborn HEAD — no sha to report */
+  }
   let base = '';
   try {
     base = git(['merge-base', 'HEAD', baseRef], wt);
@@ -289,6 +299,7 @@ export function worktreeDiff(wt, baseRef) {
   // pathological commit subject — would 400 every session's readout at once.
   return {
     branch: branch.slice(0, 200),
+    ...(headSha ? { headSha: headSha.slice(0, 64) } : {}),
     path: wt,
     ahead,
     behind,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.73.0",
+  "version": "0.74.0",
   "description": "Run your own coding CLIs as build agents for Flowviant — 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": {