flowviant 0.72.0 → 0.74.0

package/bin/cli.mjs

@@ -244,7 +244,7 @@ if (process.argv[2] === 'env') {
 // two TTYs and cannot be asked anything — the first read raises SIGTTIN and the
 // kernel STOPS the process, which is why 0.55.2's timeout did not save it (a
 // stopped process runs no timers). See tty.mjs.
-const { canPrompt, askWithTimeout } = await import('./lib/tty.mjs');
+const { canPrompt, askWithTimeout, selectMenu, menuSupported } = await import('./lib/tty.mjs');
 const interactive = canPrompt() && process.env.FLOWVIANT_REEXEC !== '1';
 
 /** How long the one-time binding confirm waits before serving unbound. A person
@@ -285,6 +285,8 @@ if (!FLEET_TOKEN) {
   }
   if (CREDENTIAL.choices?.length && interactive) {
     const creds = await import('./lib/credentials.mjs');
+    const { originSlug } = await import('./lib/git.mjs');
+    const { basename } = await import('node:path');
     const { choices, repoRoot } = CREDENTIAL;
     console.log(
       CREDENTIAL.reason === 'outside-repo'
@@ -293,27 +295,78 @@ if (!FLEET_TOKEN) {
           ? `More than one connected project names this repo (${repoRoot}) — pick which one this daemon serves:`
           : `This repo (${repoRoot}) is not connected to any project yet. Connected on this machine:`
     );
-    console.log(listLines(choices, creds));
-    console.log(`  ${choices.length + 1}. connect ${repoRoot ? 'this repo' : 'a repo'} to a different project (flowviant login)`);
+
+    const loginLabel = `connect ${repoRoot ? 'this repo' : 'a repo'} to a different project (flowviant login)`;
+    // WHICH ONE LOOKS RIGHT — a pre-selection, never an auto-serve. The resolver
+    // refuses to serve a project the repo PATH did not name (the skadooble law);
+    // this only decides which row the cursor starts on, using the repo's folder
+    // name and its github repo-name against the stored project names. A unique
+    // match becomes ONE keypress; a wrong guess costs nothing, because the human
+    // still confirms. `multiple-bound` gets no hint — every choice already names
+    // this repo, so nothing distinguishes them.
+    const slug = repoRoot ? originSlug(repoRoot) : null;
+    const likely =
+      CREDENTIAL.reason === 'multiple-bound'
+        ? -1
+        : creds.likelyChoiceIndex(choices, {
+            repoBasename: repoRoot ? basename(repoRoot) : null,
+            repoSlugName: slug ? slug.split('/')[1] : null,
+          });
+
     // Bounded like the confirm below, and for the same reason — but silence
     // means something DIFFERENT here and the difference is load-bearing. There
     // is a real ambiguity to resolve; serving a guess is the skadooble bug.
     // So no answer REFUSES, which is exactly what this branch already does
     // headless, and the message says how to answer without being present.
-    const raw = await askWithTimeout(
-      `Which project should this daemon serve? [1-${choices.length + 1}] `,
-      PICK_TIMEOUT_MS
-    );
-    if (raw === null) {
-      console.error(
-        `\nno answer in ${Math.round(PICK_TIMEOUT_MS / 1000)}s — nothing started. ` +
-          `Name one with \`--project <name|id>\`, or run \`flowviant\` here in the foreground and pick.`
+    let chosen = null; // 0-based into [...choices, login]
+    if (menuSupported()) {
+      const rowLabel = (e) =>
+        creds.projectLabel(e) + (e.repoRoot ? `  — connected for ${e.repoRoot}` : '  — not tied to a repo yet');
+      const options = [...choices.map(rowLabel), loginLabel];
+      // Say WHY the cursor starts where it does — "intuitive" made visible.
+      if (likely >= 0) options[likely] += '   ← looks like this repo';
+      const res = await selectMenu({
+        options,
+        defaultIndex: likely >= 0 ? likely : 0,
+        timeoutMs: PICK_TIMEOUT_MS,
+      });
+      if (res.timedOut) {
+        console.error(
+          `\nno answer in ${Math.round(PICK_TIMEOUT_MS / 1000)}s — nothing started. ` +
+            `Name one with \`--project <name|id>\`, or run \`flowviant\` here in the foreground and pick.`
+        );
+        process.exit(1);
+      }
+      if (res.cancelled) {
+        console.error('nothing chosen — nothing started.');
+        process.exit(1);
+      }
+      if (!res.unsupported) chosen = res.index;
+    }
+    if (chosen === null) {
+      // Numeric fallback — a pipe, or a terminal without raw mode. Empty Enter
+      // takes the likely default when there is one, so it is one keystroke here
+      // too.
+      console.log(listLines(choices, creds));
+      console.log(`  ${choices.length + 1}. ${loginLabel}`);
+      const hint = likely >= 0 ? ` (enter for ${creds.projectLabel(choices[likely])})` : '';
+      const raw = await askWithTimeout(
+        `Which project should this daemon serve? [1-${choices.length + 1}]${hint} `,
+        PICK_TIMEOUT_MS
       );
-      process.exit(1);
+      if (raw === null) {
+        console.error(
+          `\nno answer in ${Math.round(PICK_TIMEOUT_MS / 1000)}s — nothing started. ` +
+            `Name one with \`--project <name|id>\`, or run \`flowviant\` here in the foreground and pick.`
+        );
+        process.exit(1);
+      }
+      const n = raw === '' && likely >= 0 ? likely + 1 : Number.parseInt(raw, 10);
+      chosen = Number.isInteger(n) ? n - 1 : -1;
     }
-    const n = Number.parseInt(raw, 10);
-    if (n === choices.length + 1) await reexecAfterLogin();
-    const picked = Number.isInteger(n) ? choices[n - 1] : undefined;
+
+    if (chosen === choices.length) await reexecAfterLogin();
+    const picked = chosen >= 0 ? choices[chosen] : undefined;
     if (!picked) {
       console.error('nothing chosen — nothing started.');
       process.exit(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/credentials.mjs

@@ -136,6 +136,40 @@ export function projectLabel(e) {
   return e?.name ?? (e?.projectId ? `project ${e.projectId.slice(0, 8)}…` : 'an unnamed project');
 }
 
+/** Collapse a name or slug for loose comparison: "My Project", "my-project"
+ *  and "myproject" all become "myproject". */
+function normalizeName(s) {
+  return String(s ?? '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, '');
+}
+
+/**
+ * WHICH stored project most likely goes with this repo — a HINT for the
+ * picker's default, and DELIBERATELY not a licence to serve it. `resolveStored
+ * Credential` matches by repo PATH and refuses to guess past that, because
+ * serving a project the path did not name is the "it said skadooble in my
+ * calendar repo" surprise this whole file exists to prevent. A name that
+ * matches the repo's folder or its github repo-name is softer evidence — good
+ * enough to put the cursor on that row so the answer is one keypress, never
+ * good enough to skip the human. Two names can collide (a project "api" and a
+ * repo "api"), which is exactly why this only pre-selects.
+ *
+ * Returns the index of a UNIQUE match, or -1 when nothing matches or more than
+ * one does — an ambiguous hint is not a hint, and a default that is as likely
+ * wrong as right is worse than starting at the top.
+ */
+export function likelyChoiceIndex(choices, { repoBasename, repoSlugName } = {}) {
+  const wants = new Set([normalizeName(repoBasename), normalizeName(repoSlugName)].filter(Boolean));
+  if (wants.size === 0) return -1;
+  const hits = [];
+  choices.forEach((e, i) => {
+    const n = normalizeName(e?.name);
+    if (n && wants.has(n)) hits.push(i);
+  });
+  return hits.length === 1 ? hits[0] : -1;
+}
+
 function mutate(fn) {
   const f = readFile() ?? {};
   if (!f.projects || typeof f.projects !== 'object') f.projects = {};

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/tty.mjs

@@ -109,3 +109,126 @@ export async function askWithTimeout(query, timeoutMs) {
     process.off('SIGTTOU', noop);
   }
 }
+
+/**
+ * Can we draw an arrow-navigable menu? Raw mode is what turns ↑/↓ into
+ * keystrokes we receive one at a time; without `setRawMode` (a pipe, a
+ * terminal that refuses raw input) there is nothing to drive, and the caller
+ * falls back to the numeric prompt rather than drawing a menu nobody can move.
+ * `canPrompt()` still gates whether we ask AT ALL — this only decides HOW.
+ */
+export function menuSupported() {
+  return Boolean(
+    process.stdin.isTTY && process.stdout.isTTY && typeof process.stdin.setRawMode === 'function'
+  );
+}
+
+/**
+ * The menu's key handling, PURE so it can be tested without a terminal. Given a
+ * keypress and the current cursor, returns exactly one intent:
+ *   { index }   move the highlight (arrows wrap; k/j vim-style; g/G ends)
+ *   { choose }  take a row (Enter takes the highlight; 1–9 jump-and-take)
+ *   { cancel }  Esc, q, or Ctrl-C — nothing chosen
+ *   null        a key we ignore
+ * A number past the end is ignored, not clamped: pressing 9 in a 3-row list
+ * must not silently select row 3.
+ */
+export function menuKey(key, { index, count }) {
+  if (key === '\x03' || key === '\x1b' || key === 'q' || key === 'Q') return { cancel: true };
+  if (key === '\r' || key === '\n') return { choose: index };
+  if (key === '\x1b[A' || key === 'k') return { index: (index - 1 + count) % count };
+  if (key === '\x1b[B' || key === 'j') return { index: (index + 1) % count };
+  if (key === '\x1b[H' || key === 'g') return { index: 0 };
+  if (key === '\x1b[F' || key === 'G') return { index: count - 1 };
+  if (/^[1-9]$/.test(key)) {
+    const n = Number(key) - 1;
+    return n < count ? { choose: n } : null;
+  }
+  return null;
+}
+
+const MENU_FOOTER = '↑/↓ move · enter select · 1–9 jump · esc cancel';
+
+/**
+ * An arrow-navigable picker for the start path. Resolves one of:
+ *   { index }        the row taken
+ *   { cancelled }    Esc/q/Ctrl-C
+ *   { timedOut }     nobody drove it within timeoutMs
+ *   { unsupported }  no raw mode — the caller uses the numeric prompt instead
+ *
+ * Held to this file's one law — no start-path prompt may hang the daemon — the
+ * same way `askWithTimeout` is: it keeps the timeout, installs the
+ * SIGTTIN/SIGTTOU no-ops that keep that timer alive, restores the terminal in
+ * every exit, and refuses (returns `unsupported`) rather than half-drawing when
+ * raw mode is not really there. The caller still gates on `canPrompt()` before
+ * ever reaching here.
+ */
+export async function selectMenu({ options, defaultIndex = 0, timeoutMs }) {
+  if (!menuSupported()) return { unsupported: true };
+  const stdin = process.stdin;
+  const out = process.stdout;
+  const count = options.length;
+  if (count === 0) return { unsupported: true };
+  let index = Math.min(Math.max(defaultIndex | 0, 0), count - 1);
+
+  const width = Math.max(24, (out.columns || 80) - 2);
+  const clip = (s) => (s.length > width ? s.slice(0, width - 1) + '…' : s);
+  const frame = () =>
+    options
+      .map((o, i) => (i === index ? `\x1b[7m> ${clip(o)}\x1b[0m` : `  ${clip(o)}`))
+      .join('\n') +
+    '\n' +
+    `\x1b[2m  ${MENU_FOOTER}\x1b[0m`;
+  const lineCount = count + 1; // rows + footer
+
+  let rendered = false;
+  const draw = () => {
+    if (rendered) out.write(`\x1b[${lineCount}A`); // back to the top of our block
+    out.write('\r\x1b[0J'); // clear from here to the end of the screen
+    out.write(frame() + '\n');
+    rendered = true;
+  };
+
+  const noop = () => {};
+  return await new Promise((resolve) => {
+    let done = false;
+    const finish = (result) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      stdin.removeListener('data', onData);
+      try {
+        stdin.setRawMode(false);
+      } catch {
+        /* already restored / gone */
+      }
+      stdin.pause();
+      process.off('SIGTTIN', noop);
+      process.off('SIGTTOU', noop);
+      out.write('\x1b[?25h'); // show the cursor again
+      resolve(result);
+    };
+    const onData = (buf) => {
+      const action = menuKey(buf.toString('utf8'), { index, count });
+      if (!action) return;
+      if (action.cancel) return finish({ cancelled: true });
+      if (action.choose !== undefined) return finish({ index: action.choose });
+      if (action.index !== undefined) {
+        index = action.index;
+        draw();
+      }
+    };
+    process.on('SIGTTIN', noop);
+    process.on('SIGTTOU', noop);
+    const timer = setTimeout(() => finish({ timedOut: true }), timeoutMs);
+    try {
+      stdin.setRawMode(true);
+    } catch {
+      return finish({ unsupported: true });
+    }
+    stdin.resume();
+    out.write('\x1b[?25l'); // hide the cursor while we own the block
+    draw();
+    stdin.on('data', onData);
+  });
+}

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.72.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": {