flowviant 0.71.0 → 0.71.1

package/bin/lib/work.mjs

@@ -41,7 +41,7 @@ import {
 import { git, gitRaw, splitNul, baseBranchName, isSafePathSegment } from './git.mjs';
 import { listenersIn, measureListeners, listenersSupported } from './listeners.mjs';
 import { measureProcesses, liveGroups, processesSupported } from './processes.mjs';
-import { mutateRegistry, readRegistry } from './procRegistry.mjs';
+import { mutateRegistry, processAlive, readRegistry } from './procRegistry.mjs';
 import { createPlaceLock } from './placeLock.mjs';
 import { sweepMergedBranch } from './shipSweep.mjs';
 import { mergeOutward as shipMergeOutward } from './shipMerge.mjs';
@@ -1070,6 +1070,30 @@ export function createWorkManager({ repoRoot, baseDir, getBaseRef, getMcpUrl, ge
     return false;
   };
 
+  /**
+   * How long to watch for the process to actually go before answering.
+   *
+   * SIGTERM is a REQUEST, not an event: a dev server traps it and tears down
+   * its children, which takes a beat. Answering the instant the signal returns
+   * would report "signalled" over a process that is about to die, and the
+   * surface would then offer Force stop on something already on its way out.
+   *
+   * Four seconds is long enough for the ordinary teardown and short enough that
+   * a person is still looking at the row. Past it the honest answer is that the
+   * signal landed and the thing is still there — which is a real state, and the
+   * one where escalating actually means something.
+   */
+  const KILL_GRACE_MS = 4000;
+
+  const waitForExit = async (pid) => {
+    const until = Date.now() + KILL_GRACE_MS;
+    while (Date.now() < until) {
+      if (!processAlive(pid)) return true;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    return !processAlive(pid);
+  };
+
   const runKill = async (job) => {
     const id = String(job.id);
     const sessionId = String(job.sessionId || '');
@@ -1083,20 +1107,57 @@ export function createWorkManager({ repoRoot, baseDir, getBaseRef, getMcpUrl, ge
     if (!killTargetOk(sessionId, pid)) {
       // Not a lie and not a failure: the process is genuinely no longer one of
       // this tab's, which is the common case when somebody clicks a row that
-      // has since exited. The asker gets that sentence rather than a spinner.
+      // has since exited. The asker gets that sentence rather than a spinner —
+      // and the RE-MEASURE below is what takes the stale row off their screen,
+      // since a row you can click for something already gone is the readout
+      // being behind, not the person being wrong.
       await postKill({ id, outcome: 'not_found' });
+      await remeasureAfterKill(sessionId);
       return;
     }
     if (!(await claimKill(id))) return;
     try {
       process.kill(pid, signal);
-      await postKill({ id, outcome: 'signalled', signal });
+      // WHAT HAPPENED, not what we did. "We sent a signal" is a fact about us;
+      // "it stopped" is a fact about the machine, and the machine is standing
+      // right here able to check. Reporting the weaker word would also make the
+      // Force stop offer wrong for the whole window, since escalating only
+      // means something while the process is genuinely still there.
+      const gone = await waitForExit(pid);
+      await postKill({ id, outcome: gone ? 'stopped' : 'signalled', signal });
     } catch (e) {
       // EPERM is the daemon-on-its-own-user posture doing exactly what it is
       // for. Report it as its own word: "we may not" and "it was gone" are
       // different sentences and the surface says which.
       await postKill({ id, outcome: e?.code === 'ESRCH' ? 'not_found' : 'error', detail: String(e?.code || e) });
     }
+    await remeasureAfterKill(sessionId);
+  };
+
+  /**
+   * THE LIST THE PERSON IS LOOKING AT WAS MEASURED BEFORE ANY OF THIS.
+   *
+   * Without this the row survives the thing it describes: the panel renders the
+   * last sweep's `listening`, the sweep is on a SIXTY-SECOND beat, and the
+   * reported outcome sits next to a port row still claiming to be live. The
+   * first person to use it said exactly that — "i clicked stop on the listening
+   * but its still running… then it finally disappears".
+   *
+   * The rule it was missing is one this file already keeps everywhere else: an
+   * action that changes what the machine would measure must cause a new
+   * measurement. A turn settling does it; a kill did not. `reportSessionWorktree`
+   * is the un-throttled per-session path built for precisely this and it was
+   * being called from exactly one place.
+   *
+   * Never awaited by the caller's answer path: the outcome is posted first, so
+   * a slow re-measure can delay the list but never the sentence.
+   */
+  const remeasureAfterKill = async (sessionId) => {
+    try {
+      await reportSessionWorktree(sessionId);
+    } catch {
+      /* the 60s sweep still carries it — this only makes it prompt */
+    }
   };
 
   const processKillJobs = (jobs) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.71.0",
+  "version": "0.71.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": {