flowviant 0.21.0 → 0.23.0

package/bin/lib/claude.mjs

@@ -235,10 +235,15 @@ export function humanizeToolUse(name, input = {}, cwd = '') {
   }
 }
 
-// Parse ONE line of `--output-format stream-json` NDJSON. Pulls assistant text
-// into `out` (so sentinel detection still works) and turns each tool_use into a
-// streamed activity line. A line that isn't JSON (a stray warning) is treated as
-// raw text so nothing is lost.
+// Collapse whitespace + clip so a narration/thinking snippet is one tidy feed line.
+const oneLine = (s, n = 160) => String(s).replace(/\s+/g, ' ').trim().slice(0, n);
+
+// Parse ONE line of `--output-format stream-json` NDJSON into feed activities.
+// Surfaces the WHOLE turn — thinking, narration, AND every tool — so neither the
+// daemon console nor the app cover goes dark while Claude reasons (Opus thinks in
+// bursts before/between tools; emitting only tools left long silent gaps).
+// Assistant text is also folded into `out` so the WIKI_DONE/REGROUND_DONE
+// sentinels still match. A non-JSON line (a stray warning) is kept as raw text.
 function handleStreamLine(line, { cwd, emit, onActivity, appendText }) {
   let ev;
   try {
@@ -248,15 +253,22 @@ function handleStreamLine(line, { cwd, emit, onActivity, appendText }) {
     emit(line + '\n');
     return;
   }
+  const push = (a) => {
+    if (!a || !a.label) return;
+    emit(a.label + '\n');
+    onActivity?.(a);
+  };
   if (ev.type === 'assistant' && Array.isArray(ev.message?.content)) {
     for (const b of ev.message.content) {
-      if (b.type === 'text' && b.text) appendText(b.text + '\n');
-      else if (b.type === 'tool_use') {
-        const a = humanizeToolUse(b.name, b.input || {}, cwd);
-        if (a) {
-          emit(a.label + '\n');
-          onActivity?.(a);
-        }
+      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…' });
+      } else if (b.type === 'text' && b.text?.trim()) {
+        appendText(b.text + '\n');
+        push({ kind: 'say', label: oneLine(b.text) });
+      } else if (b.type === 'tool_use') {
+        push(humanizeToolUse(b.name, b.input || {}, cwd));
       }
     }
   } else if (ev.type === 'result' && typeof ev.result === 'string') {

package/bin/lib/config.mjs

@@ -4,7 +4,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
-export const VERSION = '0.21.0';
+export const VERSION = '0.23.0';
 
 // Credential stored by `flowviant login` (device auth) — the no-token,
 // no-env-var path. An explicit --fleet flag or FLOWVIANT_FLEET env still wins.

package/bin/lib/fleet.mjs

@@ -426,7 +426,7 @@ export async function runFleetDaemon() {
   let lastProgressAt = 0;
   const postWikiProgress = async (body, force = false) => {
     const now = Date.now();
-    if (!force && now - lastProgressAt < 1000) return;
+    if (!force && now - lastProgressAt < 600) return;
     lastProgressAt = now;
     try {
       await fetch(WIKI_PROGRESS_URL, {
@@ -486,25 +486,46 @@ export async function runFleetDaemon() {
         }
         const task = wikiQueue.shift();
         const { dir, path: mcpConfig } = mcpConfigFor(token, mcpUrl);
-        // Live progress for this turn: count the files Claude reads, flip to the
-        // "writing" phase once it starts emitting nodes, and stream each action
-        // to the app (throttled). elapsedSec is on the daemon's own clock.
+        // Live progress for this turn: a rolling FEED of everything Claude does
+        // (thinking, narration, reads, node writes), the file count, and the
+        // phase — streamed to the app (throttled; each frame carries the whole
+        // recent tail so a dropped POST loses nothing). elapsedSec is the
+        // daemon's own clock.
         const mode = task.type === 'sweep' ? 'sweep' : 'reground';
         const startedAt = Date.now();
         let filesRead = 0;
         let phase = 'reading';
+        const feed = [];
+        const frame = (extra) => ({
+          mode,
+          phase,
+          activity: feed[feed.length - 1] ?? '',
+          recent: feed.slice(-24),
+          filesRead,
+          elapsedSec: Math.round((Date.now() - startedAt) / 1000),
+          ...extra,
+        });
         const onActivity = (a) => {
           if (a.kind === 'read') filesRead++;
           if (a.kind === 'write') phase = 'writing';
-          void postWikiProgress({
-            mode,
-            phase,
-            activity: a.label,
-            filesRead,
-            elapsedSec: Math.round((Date.now() - startedAt) / 1000),
-          });
+          // Collapse runs of bare "thinking…" so the feed doesn't fill with it.
+          if (!(a.label === 'thinking…' && feed[feed.length - 1] === 'thinking…')) {
+            feed.push(a.label);
+            if (feed.length > 48) feed.shift();
+          }
+          void postWikiProgress(frame());
         };
+        // Heartbeat: re-send the current frame every 5s even with no new stream
+        // event, so the app's freshness window never lapses during a long
+        // thinking block or slow tool (which emit nothing until they finish) —
+        // otherwise the cover would flap back to the empty state mid-sweep.
+        let heartbeat = null;
         try {
+          // Immediate frame so the cover shows the daemon feed right away (the
+          // "reading your code" phase), not a static message, while Claude warms up.
+          feed.push('starting…');
+          await postWikiProgress(frame(), true);
+          heartbeat = setInterval(() => void postWikiProgress(frame(), true), 5000);
           if (!existsSync(wikiWt)) {
             try {
               git(['worktree', 'add', '--detach', wikiWt, baseRef], repoRoot);
@@ -565,19 +586,10 @@ export async function runFleetDaemon() {
         } catch (e) {
           warn(`wiki ${task.type} failed: ${e.message}`);
         } finally {
+          if (heartbeat) clearInterval(heartbeat);
           // Terminal frame so the app cover clears promptly (don't wait for the
           // freshness window to lapse). force-sent past the throttle.
-          await postWikiProgress(
-            {
-              mode,
-              phase,
-              activity: '',
-              filesRead,
-              elapsedSec: Math.round((Date.now() - startedAt) / 1000),
-              done: true,
-            },
-            true
-          );
+          await postWikiProgress(frame({ done: true }), true);
           rmSync(dir, { recursive: true, force: true });
         }
       }
@@ -621,6 +633,14 @@ export async function runFleetDaemon() {
     if (!connected) {
       connected = true;
       ok('Connected to Flowviant — watching your roster.');
+      // Name the scoped project so a mismatch (this daemon serves project A, but
+      // you're viewing project B's wiki) is obvious instead of a silent no-op.
+      if (roster.project) {
+        note(
+          `${c.cyan('project')} · ${c.bold(roster.project.name)} ${c.dim(`(${roster.project.id})`)}`
+        );
+        note(c.dim('  wiki + agents stream to THIS project — view its Code canvas in Flowviant.'));
+      }
     }
     if (roster.mcpUrl) mcpUrl = roster.mcpUrl;
     if (roster.leaseTtlSeconds) leaseTtlSeconds = roster.leaseTtlSeconds;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Run your own Claude Code as headless build agents for Flowviant — on your own credentials. Claims dispatched work, opens PRs, captures review evidence, and routes questions back to you.",
   "type": "module",
   "bin": {