flowviant 0.76.0 → 0.77.2

package/bin/lib/work.mjs

@@ -2275,6 +2275,36 @@ export function createWorkManager({
     for (const id of ids) {
       if (live.has(id)) continue;
       if (peers.has(id)) continue; // another daemon's tab — not ours to retire
+      /**
+       * A HARD STOP REACHES THE CLI HERE, and this is the whole of it.
+       *
+       * `stopAgent` marked the agent abandoned in D1 and nothing on the wire
+       * told the machine, so the CLI went on working, editing the worktree and
+       * spending the operator's quota — while the confirm dialog said the agent
+       * was stopped. It also never got cleaned up, because the check below
+       * skips any place whose lock is held and a running turn holds it: a
+       * stopped agent mid-turn kept its directory forever.
+       *
+       * No new wire field and no version floor: an abandoned agent simply drops
+       * out of `activeWorkSessions` (that list is built from LIVE statuses), so
+       * the server ALREADY says everything needed. Absence means "nothing here
+       * is live any more", and the honest response to that is to stop what we
+       * are running in it and then take the directory.
+       *
+       * SIGTERM the CHILD, never its group — the rule teardown keeps, so an
+       * unattended sweep cannot take the driver's dev server with it. The lock
+       * is released when the child exits, so the removal happens on the next
+       * pass rather than this one.
+       */
+      const running = agentChildren.get(id);
+      if (running) {
+        try {
+          running.kill('SIGTERM');
+        } catch {
+          /* already gone */
+        }
+        agentChildren.delete(id);
+      }
       // Asked of the PLACE, not the session: the lock is keyed by directory,
       // and a session sharing one with a busy peer is not ours to retire
       // either — its worktree is the peer's working directory.
@@ -3604,6 +3634,15 @@ export function createWorkManager({
   // do is run a CLI twice in one worktree, which is what this in-flight set and
   // the place lock prevent — the same discipline `processWorkTurns` keeps.
   const agentTurns = new Set(); // turn ids in flight on this tick
+  /**
+   * The CLI a live agent turn is running in, by PLACE.
+   *
+   * `workChildren` is keyed by the child itself, which answers "kill everything
+   * at teardown" and cannot answer "kill THIS agent's". Keyed by place rather
+   * than by agent id because the one consumer — the retire sweep — walks
+   * directory names, and those are places.
+   */
+  const agentChildren = new Map(); // placeId -> child process
 
   /** Returns the server's reply, because it carries ONE instruction the machine
    *  can act on immediately: `review: true` means the agent's queue just
@@ -3712,6 +3751,31 @@ export function createWorkManager({
       await postAgentTurn({ turnId, outcome: 'nothing' });
       return;
     }
+    /**
+     * A TASK TURN WITH NO CARD IS REFUSED, NOT IMPROVISED.
+     *
+     * The kickoff below branches on `job.kind === 'task' && job.task` and falls
+     * through to the HUMAN kickoff otherwise — and a task turn's body is empty
+     * by design, because the daemon composes the prompt from the card's own
+     * spec. So a card deleted while its agent held it spawned a real CLI on a
+     * prompt whose entire content was "a member of this project said: (nothing).
+     * Carry on, and end with the JSON object." Nothing on either side refused
+     * it, and an ordinary gesture reached it: the board's Delete.
+     *
+     * The server now declines to hand out such a job at all. This is the
+     * backstop, and it is worth having on its own: it costs one comparison and
+     * it is the layer that cannot be skipped by a server on an older deploy.
+     * `nothing` is the honest outcome — the agent goes to Stuck saying the turn
+     * produced nothing, which is exactly what happened.
+     */
+    if (job.kind === 'task' && !job.task) {
+      await postAgentTurn({
+        turnId,
+        outcome: 'nothing',
+        answer: 'the card this turn was for no longer exists',
+      });
+      return;
+    }
 
     await inPlace(place, false, async () => {
       const dir = placeWtFor(place);
@@ -3722,10 +3786,31 @@ export function createWorkManager({
         return;
       }
       const wt = dir.wt;
+      /**
+       * NEITHER OF THESE MAY THROW. `git()` throws on a non-zero exit, and both
+       * of these exit non-zero in states a real worktree reaches: `symbolic-ref`
+       * on a DETACHED HEAD (an agent that ran `git checkout <sha>`, a rebase
+       * left half-done), and `rev-parse HEAD` on a branch with no commits yet.
+       * An escape here happens BEFORE any settle, so the turn stays pending
+       * until the six-hour expiry while the agent sits in Working with nothing
+       * behind it — the wedge this whole lane exists to avoid.
+       *
+       * `runAgentMerge` learned this two commits ago and says so in its own
+       * comment; this is the same call, in the same file, left unguarded. Both
+       * facts are OPTIONAL to a turn — they describe the branch, they do not
+       * gate the work — so failing to read them costs a null, not the turn.
+       */
+      const readGit = (args) => {
+        try {
+          return (git(args, wt) || '').trim() || null;
+        } catch {
+          return null;
+        }
+      };
       // WHERE THE BRANCH WAS BEFORE THIS TURN, so the commits reported are the
       // ones this turn actually made.
-      const before = (git(['rev-parse', 'HEAD'], wt) || '').trim() || null;
-      const branch = (git(['symbolic-ref', '--quiet', '--short', 'HEAD'], wt) || '').trim() || null;
+      const before = readGit(['rev-parse', 'HEAD']);
+      const branch = readGit(['symbolic-ref', '--quiet', '--short', 'HEAD']);
 
       const rt = job.runtime || 'claude';
       if (!canRun(RUNTIMES[rt], 'build')) {
@@ -3797,10 +3882,15 @@ export function createWorkManager({
             child = ch;
             workChildren.set(ch, null);
             noteSessionGroup(agentId, ch.pid);
+            // Keyed by PLACE, because the retire sweep iterates directory names
+            // and a place id IS one. It is what lets a hard stop actually reach
+            // the CLI — see `retireWorkSessions`.
+            agentChildren.set(place, ch);
           },
         });
       } finally {
         if (child) workChildren.delete(child);
+        if (agentChildren.get(place) === child) agentChildren.delete(place);
         if (ranMarker) {
           try {
             writeFileSync(ranMarker, '1');
@@ -4163,6 +4253,125 @@ export function createWorkManager({
         await postAgentMerge({ agentId, ok: true, sha: tip || undefined });
         return;
       }
+      /**
+       * THIS PROJECT MERGES THROUGH A PULL REQUEST.
+       *
+       * PR mode existed for sessions and was simply not honoured for agents:
+       * nothing read the project's merge mode on this path and the direct
+       * merge below ran unconditionally. On the repos PR mode exists FOR —
+       * branch protection refuses a direct push of a merge commit — every
+       * agent approval failed at the push and came back to review carrying
+       * git's refusal, forever.
+       *
+       * PUSH, CREATE, MERGE, in that order, and each step's reasoning is the
+       * session PR job's: push first because GitHub merges the REMOTE tip;
+       * `--fill` titles from the branch's own commits so nothing is invented;
+       * `--merge` and never squash, because the cards' receipts are commit
+       * shas and a squash rewrites them off base, orphaning every receipt and
+       * blinding the landed observer's trailer read. Adopt only an OPEN PR:
+       * gh's branch finder falls back to the most recent merged one, and
+       * adopting a dead PR would report success over work that never moves.
+       */
+      if (job.prMode) {
+        try {
+          // EVERY `gh` CALL IS TIMED OUT. `execFileSync` blocks the daemon's
+          // whole event loop, and this one runs INSIDE the place writer lock —
+          // so a `gh` that hangs (an expired token prompting, a network black
+          // hole, a hung credential helper) stops every turn on the machine,
+          // not merely this merge, and holds the lock while it does.
+          execFileSync('gh', ['auth', 'status'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 20_000,
+          });
+        } catch (e) {
+          await postAgentMerge({
+            agentId,
+            ok: false,
+            detail:
+              e?.code === 'ENOENT'
+                ? 'this project merges through pull requests, and the GitHub CLI (gh) is not installed on this machine'
+                : `this project merges through pull requests, and gh is not signed in here: ${ghFirstLine(e)}`,
+          });
+          return;
+        }
+        const prBase = baseBranchName(baseRef());
+        if (branch === prBase) {
+          await postAgentMerge({
+            agentId,
+            ok: false,
+            detail: `this agent is on the base branch (${prBase}) — there is nothing to open a pull request from`,
+          });
+          return;
+        }
+        try {
+          git(['push', '-u', 'origin', branch], wt);
+        } catch (e) {
+          // SCRUBBED. Every other failure on this path relays `gh`'s own words,
+          // but a push writes the REMOTE URL to stderr and a remote can carry a
+          // token in its userinfo — so this one line is the only place on the
+          // agent merge path that can leak a credential into a stored,
+          // team-visible `mergeError`.
+          await postAgentMerge({ agentId, ok: false, detail: envScrub(ghFirstLine(e)) });
+          return;
+        }
+        let prUrl = null;
+        try {
+          const j = JSON.parse(
+            execFileSync('gh', ['pr', 'view', branch, '--json', 'url,state'], {
+              cwd: repoRoot,
+              stdio: ['ignore', 'pipe', 'pipe'],
+              timeout: 30_000,
+            }).toString()
+          );
+          if (j?.state === 'OPEN' && typeof j?.url === 'string') prUrl = j.url.trim();
+        } catch {
+          /* no PR for this branch at all — created below */
+        }
+        if (!prUrl) {
+          try {
+            const out = execFileSync(
+              'gh',
+              // baseBranchName, not baseRef: gh 422s on a remote-tracking name.
+              ['pr', 'create', '--head', branch, '--base', prBase, '--fill'],
+              { cwd: repoRoot, stdio: ['ignore', 'pipe', 'pipe'], timeout: 60_000 }
+            )
+              .toString()
+              .trim();
+            prUrl = out.split('\n').filter(Boolean).pop() ?? null;
+          } catch (e) {
+            await postAgentMerge({ agentId, ok: false, detail: ghFirstLine(e) });
+            return;
+          }
+        }
+        try {
+          execFileSync('gh', ['pr', 'merge', branch, '--merge'], {
+            cwd: repoRoot,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 120_000,
+          });
+        } catch (e) {
+          const line = ghFirstLine(e);
+          // Already merged is a SUCCESS: a re-offered job, or somebody merged
+          // it in the browser. The observer closes the cards either way.
+          if (!/already merged/i.test(line)) {
+            await postAgentMerge({
+              agentId,
+              ok: false,
+              detail:
+                prUrl && PR_URL_RE.test(prUrl) ? `${line} — the pull request is at ${prUrl}` : line,
+            });
+            return;
+          }
+        }
+        // THE TIP, not a merge commit: the merge commit was made on GitHub and
+        // this machine has not fetched it. It identifies the state we asked to
+        // be merged, which is what the receipt is for — the cards themselves
+        // close when the landed observer sees the commits arrive on base.
+        await postAgentMerge({ agentId, ok: true, sha: tip });
+        onRepoChanged();
+        landed.observe();
+        return;
+      }
       try {
         shipMergeOutward({
           tip,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.76.0",
+  "version": "0.77.2",
   "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": {
@@ -40,4 +40,4 @@
   "bugs": {
     "url": "https://github.com/flowviant/cli/issues"
   }
-}
+}