flowviant 0.62.0 → 0.63.1

package/bin/lib/devResolve.mjs

@@ -115,7 +115,7 @@ export function pickCommand(text) {
  * the caller's only job with a failure is to relay it, and an exception at this
  * boundary would strand the row.
  */
-export async function resolveDevCommandOnMachine({ cwd, model, log }) {
+export async function resolveDevCommandOnMachine({ cwd, model, log, onActivity }) {
   let sessionId = null;
   let timer;
   try {
@@ -127,6 +127,18 @@ export async function resolveDevCommandOnMachine({ cwd, model, log }) {
         answerFromResult: true,
         model,
         label: 'dev',
+        /**
+         * THE TURN'S OWN HUMANIZED TAIL, forwarded so a browser can watch it.
+         *
+         * This is the only feature in the product where a Claude does work
+         * nobody can see — no transcript, by design — and the driver's answer
+         * to that is the right one: "we could have it stream the output for
+         * transparency on the menu." So the same `read …` / `+ npm install …`
+         * lines a tab relays are forwarded here. It is the CLI's own stdout
+         * humanized, never an inference about it, which is the standing rule
+         * for every activity readout in this product.
+         */
+        onActivity,
         onInit: (i) => {
           if (i?.sessionId) sessionId = i.sessionId;
         },

package/bin/lib/work.mjs

@@ -112,6 +112,7 @@ export function createWorkManager({ repoRoot, baseDir, baseRef, getMcpUrl, getLe
   const DEV_RUN_CLAIM_URL = FLEET_URL.replace(/\/agents\/?$/, '/dev-run-claim');
   const DEV_RUN_DONE_URL = FLEET_URL.replace(/\/agents\/?$/, '/dev-run-done');
   const DEV_RUN_RESOLVED_URL = FLEET_URL.replace(/\/agents\/?$/, '/dev-run-resolved');
+  const DEV_RUN_PROGRESS_URL = FLEET_URL.replace(/\/agents\/?$/, '/dev-run-progress');
   const SESSION_COMMANDS_URL = FLEET_URL.replace(/\/agents\/?$/, '/session-commands');
   const ATTACHMENT_URL = FLEET_URL.replace(/\/agents\/?$/, '/attachment');
   const workAnswering = new Set(); // turn ids currently queued/running here
@@ -784,6 +785,65 @@ export function createWorkManager({ repoRoot, baseDir, baseRef, getMcpUrl, getLe
    * a second implementation of that policy inside the one component a deploy
    * cannot upgrade is exactly the drift this product keeps closing.
    */
+  /**
+   * THE RESOLVE TURN'S OUTPUT, streamed while it happens.
+   *
+   * A headless turn is the one place in this product where a Claude works and
+   * nobody can see it — deliberately, since it must not reach the transcript —
+   * and the answer to that is transparency rather than a promise: "we could
+   * have it stream the output for transparency on the menu."
+   *
+   * THROTTLED, and the tail is BOUNDED at the machine. This is a per-line hook
+   * on a turn that may run for minutes; posting each line would be hundreds of
+   * requests, and sending the whole transcript would grow without limit. Same
+   * shape as the session activity relay, for the same reasons.
+   */
+  const devProgress = new Map(); // sessionId → { lines, at, timer }
+  const DEV_PROGRESS_MS = 2_000;
+  const DEV_PROGRESS_LINES = 40;
+
+  const flushDevProgress = async (sessionId) => {
+    const st = devProgress.get(sessionId);
+    if (!st || !st.lines.length) return;
+    st.at = Date.now();
+    const logTail = st.lines.join('\n').slice(-4000);
+    try {
+      await fetch(DEV_RUN_PROGRESS_URL, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${FLEET_TOKEN}`,
+          'User-Agent': USER_AGENT,
+          'Content-Type': 'application/json',
+        },
+        signal: AbortSignal.timeout(15_000),
+        body: JSON.stringify({ sessionId, instance: DAEMON_INSTANCE, logTail }),
+      });
+    } catch {
+      /* progress is best-effort — the row's own state is the truth */
+    }
+  };
+
+  const noteDevProgress = (sessionId, label) => {
+    if (!label) return;
+    const st = devProgress.get(sessionId) ?? { lines: [], at: 0, timer: null };
+    st.lines.push(String(label).slice(0, 300));
+    if (st.lines.length > DEV_PROGRESS_LINES) st.lines.splice(0, st.lines.length - DEV_PROGRESS_LINES);
+    devProgress.set(sessionId, st);
+    // Leading-edge post, then a trailing one — so the FIRST line appears at
+    // once (an empty panel for two seconds reads as nothing happening) and the
+    // last line is never left unsent.
+    if (Date.now() - st.at > DEV_PROGRESS_MS) {
+      void flushDevProgress(sessionId);
+      return;
+    }
+    if (st.timer) return;
+    st.timer = setTimeout(() => {
+      st.timer = null;
+      void flushDevProgress(sessionId);
+    }, DEV_PROGRESS_MS);
+    st.timer.unref?.();
+  };
+
   const postDevResolved = async (body) => {
     try {
       await fetch(DEV_RUN_RESOLVED_URL, {
@@ -847,12 +907,27 @@ export function createWorkManager({ repoRoot, baseDir, baseRef, getMcpUrl, getLe
        * long as the server lived.
        */
       if (job?.action === 'resolve') {
-        if (liveDevRuns.has(sessionId)) continue;
-        if (devRunClaiming.has(sessionId)) continue;
+        /**
+         * EVERY SKIP SAYS SO. These were silent `continue`s, and that cost real
+         * time: a request sat unclaimed and the only sentence anyone got was
+         * "the machine did not pick this up — it may be offline", which was
+         * false — the machine was polling throughout. A job dropped without a
+         * trace in the row OR the log is undiagnosable from either end, so the
+         * skips are narrated even though they are all legitimate states.
+         */
+        if (liveDevRuns.has(sessionId)) {
+          note(`dev ${sessionId.slice(0, 8)}: already serving this tab — ignoring the request`);
+          continue;
+        }
+        if (devRunClaiming.has(sessionId)) continue; // in flight this tick; not news
         devRunClaiming.add(sessionId);
         void (async () => {
           try {
-            if (!(await claimDevRun(sessionId))) return; // somebody else has it
+            if (!(await claimDevRun(sessionId))) {
+              note(`dev ${sessionId.slice(0, 8)}: another process holds this request`);
+              return;
+            }
+            note(`dev ${sessionId.slice(0, 8)}: working out how to start this project…`);
             const wt = placeDir(sessionId);
             const out = await chainFor(placeOf(sessionId), () =>
               resolveDevCommandOnMachine({
@@ -865,6 +940,8 @@ export function createWorkManager({ repoRoot, baseDir, baseRef, getMcpUrl, getLe
                 log: (m) => note(`${sessionId.slice(0, 8)}: ${m}`),
               })
             );
+            // The last lines, before the row leaves the resolving state.
+            await flushDevProgress(sessionId);
             await postDevResolved({
               sessionId,
               command: out?.command ?? null,
@@ -877,6 +954,9 @@ export function createWorkManager({ repoRoot, baseDir, baseRef, getMcpUrl, getLe
               error: `the machine could not run that turn: ${e?.message ?? 'unknown error'}`,
             });
           } finally {
+            const st = devProgress.get(sessionId);
+            if (st?.timer) clearTimeout(st.timer);
+            devProgress.delete(sessionId);
             devRunClaiming.delete(sessionId);
           }
         })();
@@ -898,14 +978,21 @@ export function createWorkManager({ repoRoot, baseDir, baseRef, getMcpUrl, getLe
         continue;
       }
       // Already serving this tab. Re-starting would kill a server somebody is
-      // looking at right now.
-      if (liveDevRuns.has(sessionId)) continue;
-      if (devRunClaiming.has(sessionId)) continue;
+      // looking at right now. Narrated for the same reason the resolve branch
+      // is: a silent skip is invisible from the browser AND from the machine.
+      if (liveDevRuns.has(sessionId)) {
+        note(`dev ${sessionId.slice(0, 8)}: already serving this tab — ignoring the request`);
+        continue;
+      }
+      if (devRunClaiming.has(sessionId)) continue; // in flight this tick; not news
       devRunClaiming.add(sessionId);
 
       void (async () => {
         try {
-          if (!(await claimDevRun(sessionId))) return; // somebody else has it
+          if (!(await claimDevRun(sessionId))) {
+            note(`dev ${sessionId.slice(0, 8)}: another process holds this request`);
+            return;
+          }
           const wt = placeDir(sessionId);
           const r = await startDevServer({
             sessionId,

package/package.json

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