@cmgmyr/hive 1.10.0 → 1.10.1

package/claude-plugin/crew/model.mjs

@@ -66,6 +66,7 @@ function workerRow(lane, snapshot, nowMs, memory, nextMemory) {
   else {
     const since = state === "blocked" ? null : w.state_changed_at;
     head.push(`${state} ${duration(w, { label: state, since, lower_bound: false }, nowMs, memory, nextMemory)}`);
+    if (state !== "blocked" && w.activity?.label) head.push(w.activity.label);
   }
   const tail = [ago(w.age_seconds)];
   if (w.commits_ahead !== null && w.commits_ahead !== undefined) tail.push(`+${w.commits_ahead} commits`);

package/dist/build-info.json

@@ -1 +1 @@
-{"version":"1.10.0","sha":"9dd5fee","dirty":false,"build_id":"d7050d60f67cf44e2ca833e2ba422563b4e6b8fbdd68bccd51772e429cac1fa5"}
+{"version":"1.10.1","sha":"47de74a","dirty":false,"build_id":"8d90ac219e940dac865c9770e28e1686dbed96d3d7ec219884aa4b6aa328dab5"}

package/dist/spawn.js

@@ -4,7 +4,7 @@ import { preservedRolloutPath, reapCodexHome } from "./codexHome.js";
 import { getProject } from "./context.js";
 import { dataDir, db } from "./db.js";
 import { loadProjectYml } from "./projectYml.js";
-import { applyLayout, claimInitialWindow, createWindow, DEFAULT_LAYOUT, ensureSession, crossServerRefusal, findProcessesWindow, findProjectWindow, isPaneTarget, panePidForRecord, paneWindow, PROCESSES_LAYOUT, processesPaneTitle, processesWindowName, retainOnExitArgs, rowLive, sessionName, setPaneTitle, makeProcessesWindow, tmux, tmuxSocketPath, untrustedTmuxServer, waitForPaneEstablished, windowLayout, windowOwner, windowTitle, rowOwnership, } from "./tmux.js";
+import { applyLayout, claimInitialWindow, createWindow, DEFAULT_LAYOUT, ensureSession, crossServerRefusal, findProcessesWindow, findProjectWindow, isPaneTarget, paneProcessExited, paneWindow, PROCESSES_LAYOUT, processesPaneTitle, processesWindowName, retainOnExitArgs, rowLive, sessionName, setPaneTitle, setRemainOnExit, makeProcessesWindow, tmux, tmuxSocketPath, untrustedTmuxServer, waitForPaneEstablished, windowLayout, windowOwner, windowTitle, rowOwnership, } from "./tmux.js";
 export function withWindowClaim(claim) {
     if (db.inTransaction) {
         throw new Error("withWindowClaim was called from inside an already-open transaction. better-sqlite3 nests a " +
@@ -56,13 +56,21 @@ function recordPane(agentId, target, socket, pid) {
         .prepare("UPDATE agents SET tmux_target = ?, tmux_socket = ?, pane_pid = ? WHERE id = ? AND status = 'running'")
         .run(target, socket, pid, agentId).changes > 0);
 }
-function readPidOrDiscard(target) {
-    const pid = panePidForRecord(target);
-    if (pid !== "")
+// The creation pid proves the pane existed, not that its process still runs. A retained pane is
+// left to the caller's readiness wait, which reports the exit with its tail.
+function refuseIfExitedImmediately(target, retained) {
+    if (retained || paneProcessExited(target) !== true)
+        return;
+    discardOrphanedPane(target);
+    throw new Error(`The command exited immediately, so its pane ${target} was discarded rather than recorded as running. ` +
+        "Check the command and its arguments, then retry.");
+}
+export function createdPidOrDiscard(target, pid) {
+    if (/^\d+$/.test(pid))
         return pid;
     discardOrphanedPane(target);
-    throw new Error(`tmux did not report a process id for the new pane ${target} (asked twice), so it was discarded rather than ` +
-        "recorded: a row with no pane pid can never be verified as owning its pane. Retry.");
+    throw new Error(`tmux did not report a process id for the new pane ${target} when it created it, so it was discarded rather ` +
+        "than recorded: a row with no pane pid can never be verified as owning its pane. Retry.");
 }
 // Two callers, one meaning: whatever is left in the window re-tiles to the layout it was arranged
 // with. agent_close kills a worker's pane through this; stopProcess (src/processes.ts) is the only
@@ -116,10 +124,11 @@ export function upsertActor(actorId, name, kind) {
     db.prepare(`INSERT INTO actors (id, name, kind) VALUES (?, ?, ?)
      ON CONFLICT(id) DO UPDATE SET name = excluded.name, last_seen_at = datetime('now')`).run(actorId, name, kind);
 }
-function placeAgentPane(session, spec, envFlags, commandString, title) {
+function placeAgentPane(session, spec, envFlags, commandString, title, onRetainArmed = () => { }) {
     let landedInProjectId = null;
     let layoutApplied = false;
     let inProcessesWindow = false;
+    let pid = "";
     const target = withWindowClaim(() => {
         const windowName = spec.placement === "split" ? spec.projectName : title;
         const windowOwnerId = spec.placement === "split" ? spec.projectId : null;
@@ -127,10 +136,14 @@ function placeAgentPane(session, spec, envFlags, commandString, title) {
         if (started.created) {
             // Deliberate for placement "processes" too: this pane IS the new session's initial window, so it
             // takes that window rather than a tile. The caller reports it; `hive hide` moves it in later.
+            pid = started.pid;
             return claimInitialWindow(started, windowName, windowOwnerId).pane;
         }
         const splitInto = (window, layout) => {
-            const pane = tmux("split-window", "-d", "-P", "-F", "#{pane_id}", "-t", window, "-c", spec.cwd, ...envFlags, commandString, ...(spec.retainOnExit ? retainOnExitArgs(window) : []));
+            const [pane, created = ""] = tmux("split-window", "-d", "-P", "-F", "#{pane_id}\t#{pane_pid}", "-t", window, "-c", spec.cwd, ...envFlags, commandString, ...(spec.retainOnExit ? retainOnExitArgs(window) : [])).split("\t");
+            pid = created;
+            if (spec.retainOnExit)
+                onRetainArmed(window);
             applyLayout(window, layout);
             layoutApplied = true;
             return pane;
@@ -143,6 +156,9 @@ function placeAgentPane(session, spec, envFlags, commandString, title) {
             }
             else {
                 const made = createWindow(session, processesWindowName(spec.projectName), spec.cwd, envFlags, commandString, null, true, spec.retainOnExit ?? false);
+                pid = made.pid;
+                if (spec.retainOnExit)
+                    onRetainArmed(made.window);
                 makeProcessesWindow(made.window, spec.projectId);
                 pane = made.pane;
             }
@@ -160,9 +176,13 @@ function placeAgentPane(session, spec, envFlags, commandString, title) {
                 return pane;
             }
         }
-        return createWindow(session, windowName, spec.cwd, envFlags, commandString, windowOwnerId, true, spec.retainOnExit ?? false).pane;
+        const made = createWindow(session, windowName, spec.cwd, envFlags, commandString, windowOwnerId, true, spec.retainOnExit ?? false);
+        pid = made.pid;
+        if (spec.retainOnExit)
+            onRetainArmed(made.window);
+        return made.pane;
     });
-    return { target, landedInProjectId, layoutApplied, inProcessesWindow };
+    return { target, pid, landedInProjectId, layoutApplied, inProcessesWindow };
 }
 export function launchAgent(spec) {
     if (untrustedTmuxServer())
@@ -183,6 +203,7 @@ export function launchAgent(spec) {
     const agentId = Number(info.lastInsertRowid);
     const actorId = `${spec.kind}:${agentId}`;
     let paneUp = false;
+    let retainedWindow = null;
     try {
         const commandString = typeof spec.commandString === "string" ? spec.commandString : spec.commandString({ agentId, actorId });
         db.prepare("UPDATE agents SET actor_id = ?, command = ? WHERE id = ?").run(actorId, commandString, agentId);
@@ -193,16 +214,22 @@ export function launchAgent(spec) {
             : spec.env;
         const envFlags = buildEnvFlags(env);
         const title = windowTitle(spec.projectName, spec.name);
-        const { target, landedInProjectId, layoutApplied, inProcessesWindow } = placeAgentPane(session, spec, envFlags, commandString, title);
-        const pid = readPidOrDiscard(target);
+        const placed = placeAgentPane(session, spec, envFlags, commandString, title, (window) => {
+            retainedWindow = window;
+        });
+        const { target, landedInProjectId, layoutApplied, inProcessesWindow } = placed;
+        const pid = createdPidOrDiscard(target, placed.pid);
+        refuseIfExitedImmediately(target, spec.retainOnExit ?? false);
         paneUp = true;
         if (!recordPane(agentId, target, socket, pid)) {
             discardOrphanedPane(target);
             throw paneRacedRetirement(agentId);
         }
-        return { agentId, actorId, target, landedInProjectId, layoutApplied, inProcessesWindow };
+        return { agentId, actorId, target, landedInProjectId, layoutApplied, inProcessesWindow, retainedWindow };
     }
     catch (e) {
+        if (retainedWindow)
+            setRemainOnExit(retainedWindow, false);
         if (paneUp)
             throw e;
         db.prepare("DELETE FROM agents WHERE id = ?").run(agentId);
@@ -269,8 +296,10 @@ export function resumeAgent(spec) {
         });
         const session = sessionName();
         const title = windowTitle(spec.projectName, spec.name);
-        const { target, landedInProjectId } = placeAgentPane(session, spec, envFlags, spec.commandString, title);
-        const pid = readPidOrDiscard(target);
+        const placed = placeAgentPane(session, spec, envFlags, spec.commandString, title);
+        const { target, landedInProjectId } = placed;
+        const pid = createdPidOrDiscard(target, placed.pid);
+        refuseIfExitedImmediately(target, false);
         paneUp = true;
         if (!recordPane(spec.agentId, target, socket, pid)) {
             discardOrphanedPane(target);

package/dist/tmux.js

@@ -184,16 +184,19 @@ function unsetAtSessionScope(name, envFlags) {
         // HIVE_PROJECT_PATH at session scope, silently, for that session's whole life.
     }
 }
+// The pid is read from the creating call because tmux 3.8 reports an empty #{pane_pid} once a pane's
+// process has exited, so a later list-panes can lose the race against a command that dies at once.
+export const CREATED_PANE_FORMAT = "#{pane_id}\t#{session_name}:#{window_id}\t#{pane_pid}";
 export function ensureSession(name, cwd, initial) {
     if (quietTmux("has-session", "-t", `=${name}`))
         return { created: false };
     if (untrustedTmuxServer())
         throw crossServerRefusal("create a tmux session");
     try {
-        const [pane, window] = tmux("new-session", "-d", "-P", "-F", "#{pane_id}\t#{session_name}:#{window_id}", "-s", name, "-c", cwd, ...(initial && "command" in initial ? [...initial.envFlags, initial.command] : [])).split("\t");
+        const [pane, window, pid = ""] = tmux("new-session", "-d", "-P", "-F", CREATED_PANE_FORMAT, "-s", name, "-c", cwd, ...(initial && "command" in initial ? [...initial.envFlags, initial.command] : [])).split("\t");
         if (initial && "command" in initial)
             unsetAtSessionScope(name, initial.envFlags);
-        return { created: true, pane, window };
+        return { created: true, pane, window, pid };
     }
     catch (e) {
         if (!isDuplicateSession(e))
@@ -360,7 +363,7 @@ export function targetLiveProbe(target) {
         const rows = tmux("list-panes", "-t", target, "-F", "#{pane_id} #{pane_pid}")
             .split("\n")
             .map((line) => line.split(" "));
-        const pid = isPaneTarget(target) ? (rows.find(([id]) => id === target)?.[1] ?? null) : null;
+        const pid = isPaneTarget(target) ? (rows.find(([id]) => id === target)?.[1] || null) : null;
         return { live: true, pid };
     }
     catch (e) {
@@ -700,10 +703,10 @@ export function captureFinalScreen(target, lines) {
     }
 }
 export function createWindow(session, windowName, cwd, envFlags, command, projectId, detach = false, retainOnExit = false) {
-    const created = tmux("new-window", ...(detach ? ["-d"] : []), "-P", "-F", "#{pane_id}\t#{session_name}:#{window_id}", "-t", `=${session}`, "-n", windowName, "-c", cwd, ...envFlags, command, ...(retainOnExit ? retainOnExitArgs(`=${session}:${windowName}`) : []));
-    const [pane, window] = created.split("\t");
+    const created = tmux("new-window", ...(detach ? ["-d"] : []), "-P", "-F", CREATED_PANE_FORMAT, "-t", `=${session}`, "-n", windowName, "-c", cwd, ...envFlags, command, ...(retainOnExit ? retainOnExitArgs(`=${session}:${windowName}`) : []));
+    const [pane, window, pid = ""] = created.split("\t");
     configureHiveWindow(window, true, projectId);
-    return { pane, window };
+    return { pane, window, pid };
 }
 function viewSessionChain(session, view) {
     return [

package/dist/tools/agents.js

@@ -18,7 +18,7 @@ import { agentIdentityEnv, branchAt, closeAgentRow, currentOwnership, discardOrp
 import { COMMAND_KIND, runningCommandRow, stopLine, stopProcess, STOP_REASONS } from "../processes.js";
 import { readContextTokens, readContextFill, resolveTranscriptDir } from "../transcript.js";
 import { leadSessionEnded } from "../leadState.js";
-import { capturePane, captureFinalScreen, DEFAULT_LAYOUT, cancelCopyMode, describePaneChoice, ensureAttached, findUnsafeControlChar, holdsHumanInput, liveTargets, observationFailed, observeRowOwnership, ownershipLiveness, paneCurrentCommand, paneInCopyMode, paneWindow, pollPaneReadiness, rowOwnership, sendText, sessionName, setRemainOnExit, sleep, TEXT_ALLOWED_CONTROL_CHARS, tmux, TmuxTimeoutError, WINDOW_LAYOUTS, } from "../tmux.js";
+import { capturePane, captureFinalScreen, DEFAULT_LAYOUT, cancelCopyMode, describePaneChoice, ensureAttached, findUnsafeControlChar, holdsHumanInput, liveTargets, observationFailed, observeRowOwnership, ownershipLiveness, paneCurrentCommand, paneInCopyMode, pollPaneReadiness, rowOwnership, sendText, sessionName, setRemainOnExit, sleep, TEXT_ALLOWED_CONTROL_CHARS, tmux, TmuxTimeoutError, WINDOW_LAYOUTS, } from "../tmux.js";
 import { agentIdParam, agentNameParam, idParam, projectIdParam } from "./params.js";
 import { deriveProvenance, lastLogEvent, lastPermissionMode, reportsAgentStateLog, } from "../stateProvenance.js";
 const CLOSED_ROW_ORDER = "(parked_at != '') DESC, closed_at DESC, id DESC";
@@ -599,48 +599,48 @@ export function registerAgents(server) {
                 rmSync(codexHomeDir(codexHomeKey), { recursive: true, force: true });
             throw e;
         }
-        const { agentId, actorId, target, landedInProjectId, layoutApplied } = spawned;
-        ensureAttached(sessionName());
+        const { agentId, actorId, target, landedInProjectId, layoutApplied, retainedWindow } = spawned;
         let ready = false;
         let dialogTail;
         let exited = false;
         let exitTail;
-        if (harness.classifiesPaneScreen) {
-            const classifier = harness.paneClassifier;
-            // Captured before anything below can kill the pane: remain-on-exit is a WINDOW option,
-            // and the pane id itself stops being addressable once discardOrphanedPane has run.
-            const windowTarget = paneWindow(target) ?? target;
-            try {
-                const outcome = await pollPaneReadiness(target, PANE_READY_MS, classifier.hasInputBox);
-                if (outcome === "gone") {
-                    // remain-on-exit held the pane so its final screen is still readable; capture it,
-                    // persist it onto the row (the pane below is about to be killed), then release it.
-                    // Never run choiceCheck against a retained-but-dead pane: it is frozen content, not
-                    // a live dialog, and choiceCheck's own capture is tuned to read a live screen.
-                    exited = true;
-                    exitTail = captureFinalScreen(target, 30);
-                    db.prepare("UPDATE agents SET exit_tail = ? WHERE id = ?").run(exitTail, agentId);
-                    discardOrphanedPane(target);
-                }
-                else {
-                    const { awaitingChoice, tail } = classifier.choiceCheck(target);
-                    if (awaitingChoice === true) {
-                        dialogTail = tail;
+        try {
+            ensureAttached(sessionName());
+            if (harness.classifiesPaneScreen) {
+                const classifier = harness.paneClassifier;
+                try {
+                    const outcome = await pollPaneReadiness(target, PANE_READY_MS, classifier.hasInputBox);
+                    if (outcome === "gone") {
+                        // remain-on-exit held the pane so its final screen is still readable; capture it,
+                        // persist it onto the row (the pane below is about to be killed), then release it.
+                        // Never run choiceCheck against a retained-but-dead pane: it is frozen content, not
+                        // a live dialog, and choiceCheck's own capture is tuned to read a live screen.
+                        exited = true;
+                        exitTail = captureFinalScreen(target, 30);
+                        db.prepare("UPDATE agents SET exit_tail = ? WHERE id = ?").run(exitTail, agentId);
+                        discardOrphanedPane(target);
                     }
-                    else if (outcome === "ready") {
-                        ready = true;
+                    else {
+                        const { awaitingChoice, tail } = classifier.choiceCheck(target);
+                        if (awaitingChoice === true) {
+                            dialogTail = tail;
+                        }
+                        else if (outcome === "ready") {
+                            ready = true;
+                        }
                     }
                 }
+                catch {
+                    ready = false;
+                }
             }
-            catch {
-                ready = false;
-            }
-            finally {
-                // Unconditional: every early return, throw, or timeout between arming remain-on-exit
-                // and here must still clear it, or the shared window (the default split placement's)
-                // is left silently retaining every later exit in it, not just this one.
-                setRemainOnExit(windowTarget, false);
-            }
+        }
+        finally {
+            // Unconditional: every early return, throw, or timeout between arming remain-on-exit
+            // and here must still clear it, or the shared window (the default split placement's)
+            // is left silently retaining every later exit in it, not just this one.
+            if (retainedWindow)
+                setRemainOnExit(retainedWindow, false);
         }
         const codexInstructions = codexHomeKey ? codexInstructionsPhrase(codexInstructionLayers) : undefined;
         const receipt = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmgmyr/hive",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "description": "Run a crew of Claude Code and Codex workers from one lead session: visible tmux panes, exact state from hooks, one local SQLite store.",
   "type": "module",
   "bin": {