flowviant 0.73.0 → 0.74.1

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,118 @@ 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
   }
 }
 
+/** Count '\n' without materializing a split — a Write's content can be a
+ *  multi-MB generated file, and `split('\n')` re-allocates all of it as line
+ *  strings on the synchronous stream path the narrator and wake socket share.
+ *  Numbers cannot leak, so counting runs on the RAW string. */
+export function countLines(s) {
+  const str = String(s ?? '');
+  if (!str) return 0;
+  let n = 1;
+  let i = -1;
+  while ((i = str.indexOf('\n', i + 1)) !== -1) n++;
+  return n;
+}
+
+/** How much raw string the scrubber sees before any cap is applied. A secret
+ *  can only surface in the first ~capped chars of a field; giving the scrub a
+ *  window this much larger means a secret would have to be longer than the
+ *  window minus the cap to straddle out of it — no real credential is. */
+const SCRUB_WINDOW = 8_192;
+
+/**
+ * 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
+ *
+ * SCRUB BEFORE CAP — the order is load-bearing (review, 2026-09-01). The
+ * caller passes its `envScrub`; every string is scrubbed over a bounded
+ * window FIRST and capped LAST, because the reverse order had two failures:
+ * a secret straddling the cap boundary was cut into a prefix the
+ * exact-substring scrub could no longer match (a partial credential on the
+ * wire), and a scrub REPLACEMENT that grew a string past the cap tripped the
+ * server's field limits. `scrub` defaults to identity so this stays testable
+ * without a vault.
+ */
+export function toolEventOf(name, input = {}, cwd = '', scrub = (s) => s) {
+  // Window → scrub → cap. The window bounds what a multi-MB input costs; the
+  // cap is applied AFTER the scrub so a replacement cannot overflow it.
+  const clean = (v, cap) => scrub(String(v ?? '').slice(0, SCRUB_WINDOW)).slice(0, cap);
+  const rel = (p) => clean(shortPath(p, cwd), 300);
+  // The first k lines of a side, from a scrubbed bounded prefix — never a
+  // full split of the raw string.
+  const firstLines = (s, k) =>
+    scrub(String(s ?? '').slice(0, SCRUB_WINDOW)).split('\n', k).slice(0, k);
+  switch (name) {
+    case 'Read':
+      return { t: 'read', p: rel(input.file_path) };
+    case 'Write':
+      return { t: 'write', p: rel(input.file_path), a: countLines(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 = [
+        ...firstLines(oldS, 2).map((l) => `- ${l}`),
+        ...firstLines(newS, 3).map((l) => `+ ${l}`),
+      ].map((l) => l.slice(0, 160));
+      return { t: 'edit', p: rel(input.file_path), a: countLines(newS), d: countLines(oldS), dl };
+    }
+    case 'Grep':
+      return {
+        t: 'grep',
+        q: clean(input.pattern, 200),
+        ...(input.path ? { p: rel(input.path) } : {}),
+      };
+    case 'Glob':
+      return { t: 'glob', q: clean(input.pattern, 200) };
+    case 'Bash':
+      return { t: 'bash', c: clean(input.command, 200) };
+    case 'Task':
+      return { t: 'task', q: clean(input.description, 200) };
+    case 'TodoWrite': {
+      const todos = Array.isArray(input.todos) ? input.todos.slice(0, 20) : [];
+      const items = todos
+        .map((td) => ({
+          x: clean(td?.content, 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,70 @@ 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 NON-PLAN rows, with the shed counted
+           *     call-for-call (`dropped += n`) — scrollback semantics, the
+           *     same trade the transcript itself makes; the plan is exempt,
+           *     because it is current state rather than scrollback.
+           */
+          const toolLog = { ev: [], dropped: 0 };
+          const pushToolEvent = (name, input) => {
+            // envScrub rides INTO the builder, which scrubs over a bounded
+            // window BEFORE its caps — scrubbing after the cut both leaked a
+            // boundary-straddling secret's prefix and grew a capped field
+            // past the server's limits (review, 2026-09-01).
+            const e = toolEventOf(name, input, dir.wt, envScrub);
+            if (!e) return;
+            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);
+              }
+            }
+            // The cap evicts the oldest NON-plan row: the plan is current
+            // state, not scrollback — the one card the fold keeps out — and a
+            // shed collapsed row counts its repeats, so "N steps" never
+            // understates what the cut removed.
+            while (toolLog.ev.length > 60) {
+              const i = toolLog.ev.findIndex((x) => x.t !== 'plan');
+              if (i < 0) break; // only the plan left; it stays
+              const [shed] = toolLog.ev.splice(i, 1);
+              toolLog.dropped = Math.min(1_000_000, toolLog.dropped + (shed?.n ?? 1));
+            }
+          };
+          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 +2547,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
@@ -2539,6 +2676,9 @@ export function createWorkManager({
             await settleWorkTurn(job.id, {
               ok: false,
               answer: "Couldn't resume the terminal session — it may have been removed.",
+              // Whatever it DID before coming back empty is exactly the
+              // question a failed turn's log answers.
+              ...(toolLog.ev.length > 0 ? { tools: toolLog } : {}),
             });
             warn('adopt turn produced no output — settled as failed');
             return;
@@ -2572,6 +2712,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');
@@ -2582,6 +2726,9 @@ export function createWorkManager({
             // routinely quotes command output, and command output can quote a
             // synced secret.
             answer: envScrub(String(e?.message ?? 'the session turn failed')).slice(0, 2000),
+            // "What did it do before it failed" is exactly the question a
+            // crashed turn's log answers — same spread as the main settle.
+            ...(toolLog.ev.length > 0 ? { tools: toolLog } : {}),
           });
           warn(`session turn failed: ${e?.message ?? e}`);
         } finally {
@@ -2592,6 +2739,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,7 +1,7 @@
 {
   "name": "flowviant",
-  "version": "0.73.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.",
+  "version": "0.74.1",
+  "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": {
     "flowviant": "bin/cli.mjs"
@@ -40,4 +40,4 @@
   "bugs": {
     "url": "https://github.com/flowviant/cli/issues"
   }
-}
+}