flowviant 0.74.0 → 0.74.1

package/bin/lib/runtimes.mjs

@@ -107,6 +107,25 @@ export function humanizeClaudeTool(name, input = {}, cwd = '') {
   }
 }
 
+/** 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
@@ -121,45 +140,57 @@ export function humanizeClaudeTool(name, input = {}, cwd = '') {
  *   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.
+ * 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 = '') {
-  const rel = (p) => shortPath(p, cwd).slice(0, 300);
-  const lines = (s) => (s ? String(s).split('\n').length : 0);
+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: lines(input.content) };
+      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 = [
-        ...oldS.split('\n').slice(0, 2).map((l) => `- ${l}`),
-        ...newS.split('\n').slice(0, 3).map((l) => `+ ${l}`),
+        ...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: lines(newS), d: lines(oldS), dl };
+      return { t: 'edit', p: rel(input.file_path), a: countLines(newS), d: countLines(oldS), dl };
     }
     case 'Grep':
       return {
         t: 'grep',
-        q: String(input.pattern ?? '').slice(0, 200),
+        q: clean(input.pattern, 200),
         ...(input.path ? { p: rel(input.path) } : {}),
       };
     case 'Glob':
-      return { t: 'glob', q: String(input.pattern ?? '').slice(0, 200) };
+      return { t: 'glob', q: clean(input.pattern, 200) };
     case 'Bash':
-      return { t: 'bash', c: String(input.command ?? '').slice(0, 200) };
+      return { t: 'bash', c: clean(input.command, 200) };
     case 'Task':
-      return { t: 'task', q: String(input.description ?? '').slice(0, 200) };
+      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: String(td?.content ?? '').slice(0, 120),
+          x: clean(td?.content, 120),
           s: td?.status === 'completed' ? 'done' : td?.status === 'in_progress' ? 'active' : 'open',
         }))
         .filter((i) => i.x);

package/bin/lib/work.mjs

@@ -2404,21 +2404,19 @@ export function createWorkManager({
            *   · 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.
+           *   · 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 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);
+            // 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;
-            scrubEv(e);
             if (e.t === 'plan') {
               const i = toolLog.ev.findIndex((x) => x.t === 'plan');
               if (i >= 0) toolLog.ev.splice(i, 1);
@@ -2442,9 +2440,15 @@ export function createWorkManager({
                 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) {
-              toolLog.ev.shift();
-              toolLog.dropped++;
+              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, () =>
@@ -2672,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;
@@ -2719,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 {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "flowviant",
-  "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.",
+  "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"
   }
-}
+}