flowviant 0.86.0 → 0.88.0

package/bin/lib/runtimes.mjs

@@ -46,6 +46,41 @@ import { SAFE, MODEL, USER_AGENT } from './config.mjs';
 const oneLine = (s, n = 140) =>
   String(s ?? '').replace(/\s+/g, ' ').trim().slice(0, n);
 
+/**
+ * `label` IS THE READOUT; `full` IS THE RELAY (2026-09-16) — the convention
+ * every prose activity in this daemon follows, stated once here because three
+ * parsers produce one and three consumers read them.
+ *
+ * `label` is one collapsed, clamped line, because its first two consumers are a
+ * terminal console and a one-line pulse that is overwritten every two seconds,
+ * and neither can show a paragraph. The turn TRACE is a third consumer with the
+ * opposite need: it is scrollback, and clipping a sentence at 140 characters
+ * there is the product summarizing its own agent.
+ *
+ * So a prose activity may ALSO carry `full`: the text EXACTLY as the CLI
+ * emitted it, uncollapsed and unclipped. Nothing derives it and nothing but the
+ * trace reads it — `label` is untouched, so the console and the pulse are
+ * byte-identical to before. Absent means there was no fuller text than the
+ * label (a tool line, a bare thinking marker), and the trace falls back to the
+ * label — which is what every pre-0.87.0 daemon does for everything.
+ *
+ * THE MARKER BELOW IS THE label-ONLY CASE, and one definition with four
+ * readers: claude.mjs writes it, this file's codex parser falls back to it, and
+ * TWO collapses key on it — `trace.mjs` for the turn trace, `fleet.mjs` for the
+ * wiki sweep's feed. A collapse keyed on a string typed out four times would
+ * silently stop collapsing the first time somebody reworded one of them, and a
+ * collapse that stops collapsing fails no test — it just fills a feed.
+ *
+ * It exists at all because the CLIs do not hand over the thinking itself:
+ * measured 2026-09-16 across three real transcripts, 93 thinking blocks, every
+ * one of them empty (signature only), and a live probe with MAX_THINKING_TOKENS
+ * and `--include-partial-messages` returned an empty `thinking_delta` and a
+ * zero-length complete block. So the marker is the honest whole of what is
+ * known — "it is reasoning, not hung" — and the day text does arrive it rides
+ * `full` and this marker is simply not used.
+ */
+export const THINK_MARKER = 'thinking…';
+
 const shortPath = (p, cwd) => {
   const s = String(p ?? '');
   return cwd && s.startsWith(cwd) ? s.slice(cwd.length).replace(/^\//, '') : s;
@@ -239,10 +274,22 @@ export const CLAUDE_TOOL_PROSE_KINDS = new Set([
  */
 function humanizeCodexItem(item = {}, cwd = '') {
   switch (item.item_type ?? item.type) {
-    case 'agent_message':
-      return { kind: 'say', label: oneLine(item.text ?? item.message) };
-    case 'reasoning':
-      return { kind: 'think', label: oneLine(item.text) || 'thinking…' };
+    // `full` rides beside the label wherever the item carries more than the
+    // label can hold — see the `label`/`full` note above. Codex is the runtime
+    // that actually SENDS reasoning text today, so its `think` is the one place
+    // in this daemon where a real thought reaches the trace whole.
+    case 'agent_message': {
+      const text = String(item.text ?? item.message ?? '');
+      return { kind: 'say', label: oneLine(text), ...(text ? { full: text } : {}) };
+    }
+    case 'reasoning': {
+      const text = String(item.text ?? '');
+      return {
+        kind: 'think',
+        label: oneLine(text) || THINK_MARKER,
+        ...(text.trim() ? { full: text } : {}),
+      };
+    }
     case 'command_execution':
       return {
         kind: 'bash',
@@ -301,11 +348,28 @@ function parseCodexLine(line, cwd) {
           : '';
       return { activity, text };
     }
-    case 'turn.failed':
+    case 'turn.failed': {
+      // An error is prose too, and the sentence that explains a failed turn is
+      // routinely longer than a 140-char label — a stack-shaped message loses
+      // its cause exactly where somebody is reading to find it.
+      //
+      // THE LABEL KEEPS ITS OWN `??`, not `msg || …`, and the difference is one
+      // input: an EXPLICITLY EMPTY message. `??` lets `''` through as an empty
+      // label, which every consumer swallows (`if (!label)`); `||` would print
+      // "turn failed" and fire a pulse where this daemon printed nothing. That
+      // may well be the better readout, but it is a change to the console and
+      // the pulse, and `full` shipped on the promise that neither moved — so it
+      // is argued for on its own day, not smuggled in beside a relay field.
+      const msg = String(ev.error?.message ?? '');
       return {
-        activity: { kind: 'error', label: oneLine(ev.error?.message ?? 'turn failed') },
+        activity: {
+          kind: 'error',
+          label: oneLine(ev.error?.message ?? 'turn failed'),
+          ...(msg.trim() ? { full: msg } : {}),
+        },
         text: '',
       };
+    }
     // A bare `error` event — the shape an auth failure arrives in ("401
     // Unauthorized: Missing bearer…", observed against 0.147.0 with no
     // credentials). It used to fall through to `default` and be dropped, which
@@ -314,11 +378,19 @@ function parseCodexLine(line, cwd) {
     // gave up rather than that the CLI is not signed in. The message goes into
     // `text` so it reaches the operator's console AND the usage-limit
     // classifier, which reads exactly this stream.
-    case 'error':
+    case 'error': {
+      // Same split as the arm above: `??` for the label (untouched behaviour),
+      // `msg` for the relay field only.
+      const msg = String(ev.message ?? '');
       return {
-        activity: { kind: 'error', label: oneLine(ev.message ?? 'error') },
+        activity: {
+          kind: 'error',
+          label: oneLine(ev.message ?? 'error'),
+          ...(msg.trim() ? { full: msg } : {}),
+        },
         text: `${ev.message ?? ''}\n`,
       };
+    }
     default:
       return null; // turn.started / item.started / item.updated
   }
@@ -376,7 +448,14 @@ function parseAgyLine(line, cwd) {
     const ti = su.tool_info;
     if (!ti) return null;
     const err = ti.error?.message;
-    if (err) return { activity: { kind: 'error', label: oneLine(err) }, text: '' };
+    // Same rule as codex's error lines: the label is the console's, `full` is
+    // the trace's, and a tool error's message is exactly the kind of sentence a
+    // 140-char clamp cuts the cause out of.
+    if (err)
+      return {
+        activity: { kind: 'error', label: oneLine(err), full: String(err) },
+        text: '',
+      };
     // Each tool is reported twice — once ACTIVE, once DONE — so only the
     // terminal state emits, otherwise every action appears in the thread twice.
     if (su.state && su.state !== 'DONE') return null;
@@ -387,7 +466,9 @@ function parseAgyLine(line, cwd) {
     // The final answer is the ONLY sentinel-bearing text: agy has no incremental
     // assistant-message event, so a turn's whole verdict arrives here at once.
     return {
-      activity: r.error ? { kind: 'error', label: oneLine(r.error) } : null,
+      activity: r.error
+        ? { kind: 'error', label: oneLine(r.error), full: String(r.error) }
+        : null,
       text: `${r.response ?? ''}${r.error ? `\n${r.error}` : ''}\n`,
     };
   }

package/bin/lib/trace.mjs

@@ -54,6 +54,8 @@
  * tail of a trace, never the settle behind it.
  */
 
+import { THINK_MARKER } from './runtimes.mjs';
+
 /** One batch every two seconds — the discipline the tab's narrator keeps, for
  *  the same reason: a turn emits hundreds of entries and nobody is reading them
  *  faster than that. */
@@ -64,9 +66,22 @@ export const TRACE_BATCH = 40;
  *  scrollback, and the newest steps are the ones somebody watching wants. The
  *  drop is not silent — see the seq rule above. */
 export const TRACE_BUFFER = 120;
-/** Longest prose entry. The server clamps to the same number; doing it here too
- *  means a pathological line never becomes the POST. */
-export const TRACE_PROSE_CAP = 300;
+/**
+ * Longest prose entry. The server clamps to the same number
+ * (`agentTrace.ts.TRACE_PROSE_CAP`); doing it here too means a pathological line
+ * never becomes the POST. The two must move together — daemon at or below the
+ * server's, or the server silently does the cutting and this file's caps stop
+ * describing what ships.
+ *
+ * 300 UNTIL 2026-09-16, when it was the thing clipping sentences. A trace entry
+ * used to be the humanized 160-char label the console prints, so a 300 cap could
+ * not bite; it now carries the FULL text of what the CLI said or thought, and at
+ * 300 a paragraph of narration was cut mid-sentence. The real bound is the
+ * TURN's (400 entries / 96KB server-side, oldest shed with the count said out
+ * loud) — a long thought spends budget older steps would have held, and an
+ * admitted shed beats a silent clip.
+ */
+export const TRACE_PROSE_CAP = 4_000;
 
 /**
  * ONE ATTEMPT AT ONE TURN, named.
@@ -93,6 +108,11 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
    *  server's business: it rebases each run onto its own high-water mark. */
   const queue = [];
   let base = 0;
+  /** The last entry this relay ACCEPTED, kept across flushes and across a shed
+   *  buffer — `queue[queue.length - 1]` is not the same thing, because a flush
+   *  empties the queue and a batch boundary is not a change in the stream. Read
+   *  by the bare-marker collapse in `prose()` and nothing else. */
+  let lastEntry = null;
   let dirty = false;
   let timer = null;
   let stopped = false;
@@ -111,6 +131,7 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
 
   const push = (entry) => {
     if (stopped || !entry) return;
+    lastEntry = entry;
     queue.push(entry);
     while (queue.length > TRACE_BUFFER) {
       queue.shift();
@@ -157,17 +178,59 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
   };
 
   return {
-    /** A prose line from the stream. `kind` is the daemon's activity vocabulary
-     *  (runtimes.mjs); anything that is not thinking or the model speaking is a
-     *  `note` — the honest bucket for a codex error line or an agy tool name,
-     *  rather than a wire value invented per runtime. */
+    /**
+     * A prose line from the stream. `kind` is the daemon's activity vocabulary
+     * (runtimes.mjs); anything that is not thinking or the model speaking is a
+     * `note` — the honest bucket for a codex error line or an agy tool name,
+     * rather than a wire value invented per runtime.
+     *
+     * THE NEWLINES SURVIVE (2026-09-16). This used to be `\s+ → ' '`, which was
+     * right while an entry WAS a one-line label and wrong the moment the caller
+     * started handing over the whole of what the CLI said: a model writes in
+     * paragraphs and lists, and flattening them here is the relay deciding how
+     * the agent's own words should be shaped. So only HORIZONTAL runs collapse,
+     * and a wall of blank lines becomes one — that second rule is not cosmetic,
+     * it stops padding eating the cap that the real sentences need.
+     *
+     * The scrub still runs over the WHOLE text, before the cap: this is the
+     * CLI's own stdout, and a secret in a thought must not ride further than it
+     * did when a thought was 300 characters.
+     */
     prose(kind, text) {
       const t = scrub(String(text ?? ''))
-        .replace(/\s+/g, ' ')
+        // One line ending, whatever the CLI printed.
+        .replace(/\r\n?/g, '\n')
+        // Spaces and tabs collapse; `\n` is deliberately excluded from the class.
+        .replace(/[^\S\n]+/g, ' ')
+        // Three or more breaks in a row — two or more blank lines — become one.
+        .replace(/\n{3,}/g, '\n\n')
         .trim()
         .slice(0, TRACE_PROSE_CAP);
       if (!t) return;
-      push({ k: kind === 'think' ? 'think' : kind === 'say' ? 'say' : 'note', t });
+      const k = kind === 'think' ? 'think' : kind === 'say' ? 'say' : 'note';
+      /**
+       * A RUN OF BARE "thinking…" IS ONE STEP, not forty.
+       *
+       * Claude emits a thinking block per burst and (measured 2026-09-16, three
+       * real transcripts: 93 blocks, all of them empty) carries no text in any
+       * of them — so the trace filled with the identical marker repeated, which
+       * is noise standing exactly where the thought would have been. The wiki
+       * feed collapses the same run for the same reason (fleet.mjs: "Collapse
+       * runs of bare 'thinking…' so the feed doesn't fill with it").
+       *
+       * ONLY THE BARE MARKER, and that is the whole safety of it: a think WITH
+       * text is never equal to it, so no real thought is ever eaten — the day
+       * the CLI starts emitting thinking text, every one of those blocks lands
+       * whole beside the others.
+       *
+       * A collapsed marker is NOT a drop: it never becomes an entry, so it
+       * never takes a seq, exactly like the empty line above it. The "N earlier
+       * steps are not shown" count stays a count of steps that existed.
+       */
+      if (k === 'think' && t === THINK_MARKER && lastEntry?.k === 'think' && lastEntry.t === t) {
+        return;
+      }
+      push({ k, t });
     },
     /** One structured tool event, exactly as `toolEventOf` built it. A tool this
      *  builder does not know returns null there and nothing is pushed here — a