flowviant 0.86.0 → 0.87.0

package/bin/lib/agentPlan.mjs

@@ -108,9 +108,27 @@ export function parseProposal(text) {
       ...(Number.isFinite(g.pointsBudget) && g.pointsBudget > 0
         ? { pointsBudget: Math.min(Math.round(g.pointsBudget), 100_000) }
         : {}),
-      ...(Array.isArray(g.waitsOn)
-        ? { waitsOn: g.waitsOn.filter((w) => typeof w === 'string' && w).slice(0, 20) }
-        : {}),
+      // NO `waitsOn`, AND ITS ABSENCE IS THE FEATURE (2026-09-16).
+      //
+      // The planner's schema used to carry it — tempIds of agents that had to
+      // MERGE first — and the owner deleted the idea: "whats the point of
+      // dividing up the agents if one of the agents rely on waiting for one to
+      // finish? if thats the case have it be in the same agent." An agent
+      // already works its cards in order, so a chain split across two agents
+      // buys a second worktree, a second branch and a second review and then
+      // idles one of them; the only thing a split buys is SIMULTANEOUS work.
+      // SYSTEM_PLAN no longer mentions the key at all.
+      //
+      // So a model that emits it anyway is answering a schema it was not given
+      // — an older prompt cached in a resumed conversation, or invention — and
+      // reading it would create a silently-waiting agent through the exact door
+      // the prompt just closed. DROPPED, not REFUSED: this file's own law is
+      // lenient packaging, strict shape, and a stray key is packaging. The
+      // proposal is otherwise good work the operator already paid for.
+      //
+      // The SERVER still accepts and honours `waitsOn` on the wire — 0.86.0
+      // daemons are still proposing it and existing agents still carry it. This
+      // is the end of PROPOSING one, not the end of reading one.
       ...(typeof g.intoAgentId === 'string' && g.intoAgentId
         ? { intoAgentId: g.intoAgentId.slice(0, 64) }
         : {}),

package/bin/lib/claude.mjs

@@ -13,7 +13,7 @@
 
 import { spawn } from 'node:child_process';
 import { SAFE } from './config.mjs';
-import { runtimeById, humanizeClaudeTool } from './runtimes.mjs';
+import { runtimeById, humanizeClaudeTool, THINK_MARKER } from './runtimes.mjs';
 
 // Every prompt/kickoff constant lives in prompts.mjs and is re-exported here:
 // a dozen call sites import them from claude.mjs, and none of them care where
@@ -197,12 +197,39 @@ function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText
   if (ev.type === 'assistant' && Array.isArray(ev.message?.content)) {
     for (const b of ev.message.content) {
       if (b.type === 'thinking' || b.type === 'redacted_thinking') {
-        // The `thinking` text is usually redacted (signature only), so emit a
-        // marker — enough to show Claude is actively reasoning, not hung.
-        push({ kind: 'think', label: b.thinking ? `thinking: ${oneLine(b.thinking)}` : 'thinking…' });
+        /**
+         * NO THINKING TEXT ARRIVES TODAY, AND THAT IS MEASURED (2026-09-16).
+         *
+         * This used to say the text is "usually redacted", which was a guess
+         * doing the work of a fact. The fact: across three real transcripts, 93
+         * thinking blocks, EVERY ONE of them carried an empty `thinking` — and
+         * a live probe with MAX_THINKING_TOKENS set and
+         * `--include-partial-messages` on returned an empty `thinking_delta`
+         * and a complete block of length zero (signature only). So the CLI
+         * emits the FACT that it reasoned and not a word of the reasoning, and
+         * "show the full thinking" cannot be conjured from this stream.
+         *
+         * THE BRANCH BELOW EXISTS ANYWAY, and deliberately. The shape is the
+         * whole point: when text is present it rides `full` UNCLIPPED, so the
+         * day a CLI release starts emitting it, the trace carries the thought
+         * whole with no daemon change and no version floor — the report's own
+         * presence is the capability. Until then every block takes the marker
+         * arm, and `trace.mjs` collapses a run of identical markers so the
+         * absence reads as one quiet step rather than forty.
+         */
+        push(
+          b.thinking
+            ? { kind: 'think', label: `thinking: ${oneLine(b.thinking)}`, full: b.thinking }
+            : { kind: 'think', label: THINK_MARKER }
+        );
       } else if (b.type === 'text' && b.text?.trim()) {
         if (!answerFromResult) appendText(b.text + '\n');
-        push({ kind: 'say', label: oneLine(b.text) });
+        // `label` for the console and the pulse — one collapsed 160-char line,
+        // byte-identical to what it has always printed. `full` for the trace:
+        // a `say` is the agent NARRATING, several sentences at a time, and the
+        // clip at 160 was landing mid-sentence on the one thing a person opens
+        // the page to read.
+        push({ kind: 'say', label: oneLine(b.text), full: 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

package/bin/lib/fleet.mjs

@@ -82,6 +82,7 @@ import {
   probeSkillsOnce,
   recordSkills,
   RUNTIMES,
+  THINK_MARKER,
 } from './runtimes.mjs';
 import { createWorkManager } from './work.mjs';
 import { scanLocalSessions, ourConversationIds } from './localSessions.mjs';
@@ -1598,7 +1599,13 @@ export async function runFleetDaemon() {
             pagesSeen.add(a.path || a.label);
           }
           // Collapse runs of bare "thinking…" so the feed doesn't fill with it.
-          if (!(a.label === 'thinking…' && feed[feed.length - 1] === 'thinking…')) {
+          // Keyed on the SHARED constant (runtimes.mjs), not on the literal: the
+          // labels being compared here are the ones claude.mjs now builds from
+          // that constant, so a reworded marker would leave this comparison
+          // matching nothing and the 48-slot feed filling with the repeat — the
+          // exact noise this line exists to stop, and silent, because a collapse
+          // that stops collapsing fails no test.
+          if (!(a.label === THINK_MARKER && feed[feed.length - 1] === THINK_MARKER)) {
             feed.push(a.label);
             if (feed.length > 48) feed.shift();
           }

package/bin/lib/prompts.mjs

@@ -588,6 +588,35 @@ export const REGROUND_KICKOFF = ({ sha, title, files, vaultDir, predictedPages =
  * TOUCHED. Everything else — how long something will take, who should own it,
  * whether it is a good idea — is not a question a planner can answer from a
  * repository, and asking for it produces confident invention.
+ *
+ * ── THERE IS NO WAY TO SAY "THIS ONE WAITS" (2026-09-16) ──
+ *
+ * The answer schema used to carry `waitsOn`, a list of tempIds an agent had to
+ * see MERGE before it could start, and the owner deleted the idea outright:
+ *
+ *   "for the planning agent, whats the point of dividing up the agents if one
+ *    of the agents rely on waiting for one to finish? if thats the case have it
+ *    be in the same agent. the point of having it divide into various agent is
+ *    so that its capable of parallel and simultaneous work."
+ *
+ * That is not a preference about a field, it is what an agent IS. An agent is
+ * one CLI in one worktree working its cards IN ORDER — ordering is the thing it
+ * already does, for free, with no branch to merge in between. So a planner that
+ * splits a chain across two agents has bought nothing and paid twice: a second
+ * worktree, a second branch, a second review, and a second agent sitting idle
+ * until the first one lands. The ONLY thing a split buys is two CLIs typing at
+ * the same time, and work that waits cannot do that by definition.
+ *
+ * So the vocabulary is gone rather than discouraged. A rule the model can still
+ * express a violation of is a rule it will sometimes express a violation of;
+ * removing the key removes the move. Rule 1 below carries the reasoning in the
+ * planner's own terms, and `agentPlan.mjs` drops the key if a model on an older
+ * prompt sends it anyway.
+ *
+ * WHAT DID NOT CHANGE, on purpose: the SERVER still accepts `waitsOn` on the
+ * wire and still honours it on stored proposals, because 0.86.0 daemons are
+ * still running and agents created under the old prompt still exist. This is a
+ * change to what is PROPOSED, not to what can be read.
  */
 export const SYSTEM_PLAN = `You are the human's own Claude, planning a batch of work in their repository.
 
@@ -602,8 +631,13 @@ as a single reviewable branch.
 THE RULES THAT MATTER:
 
 1. SEQUENTIAL WORK BELONGS IN ONE AGENT. If B needs A's code to exist, put them
-   in the same agent, A first. Splitting a chain across agents means the second
-   one waits for the first to MERGE before it can even start.
+   in the same agent, A first — an agent works its cards in the order you give,
+   so ordering is free and costs no merge in between. THE ONLY REASON TO SPLIT
+   IS WORK THAT CAN RUN AT THE SAME TIME. There is no way to say that one agent
+   waits for another, and that is deliberate: an agent that has to wait is a
+   split done wrong. Splitting a chain buys a second worktree, a second branch
+   and a second review, and the second agent sits idle until the first one
+   merges — slower than one agent doing both in order.
 
 2. SPLIT ONLY WHAT CAN GENUINELY RUN AT THE SAME TIME. Two agents editing the
    same files land two branches that conflict, and somebody resolves it by hand.
@@ -641,7 +675,6 @@ after it. Wrap it in a \`\`\`json fence:
       "name": "auth",
       "taskIds": ["<card id>", "<card id>"],
       "pointsBudget": 8,
-      "waitsOn": [],
       "intoAgentId": null
     }
   ]
@@ -649,7 +682,7 @@ after it. Wrap it in a \`\`\`json fence:
 \`\`\`
 
 Every selected card id must appear EXACTLY ONCE across all agents. Use the ids
-exactly as given. "waitsOn" holds tempIds of agents that must MERGE first.`;
+exactly as given.`;
 
 /**
  * The planner's turn.

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

package/bin/lib/work.mjs

@@ -4888,7 +4888,16 @@ export function createWorkManager({
             // seconds. Two channels, one stream, and the drop-sampler stays a
             // drop-sampler — buffering the pulse would make a stale line look
             // fresh, which is the one thing it exists to answer.
-            if (!doubledKinds || !doubledKinds.has(a.kind)) trace.prose(a.kind, line);
+            //
+            // …AND THE TRACE TAKES THE WHOLE LINE. `label` is a 160-char
+            // console readout; `full` is what the CLI actually said, when the
+            // parser had more than the label could hold (see runtimes.mjs).
+            // The fallback is not a degradation — it is what every activity
+            // without a fuller form carries, and what an entire pre-0.87.0
+            // daemon carried for all of them. The PULSE below is deliberately
+            // still `line`: it is one overwritten line on a board, and a
+            // paragraph there would be a paragraph nobody can read.
+            if (!doubledKinds || !doubledKinds.has(a.kind)) trace.prose(a.kind, a.full ?? line);
             const now = Date.now();
             if (now - (lastAgentBeat.get(agentId) ?? 0) < 2_000) return;
             lastAgentBeat.set(agentId, now);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.86.0",
+  "version": "0.87.0",
   "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": {