trantor 0.18.53 → 0.18.55

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.53",
+  "version": "0.18.55",
   "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + crew orchestration for independent AI coding agents (Claude, Codex, Gemini, Kimi, DeepSeek)",
   "mcpServers": {
     "relay": {

package/README.md

@@ -368,6 +368,8 @@ Waking works the same way from the other end: hover a sleeping project in the ap
 **Wake** hosts its session as an in-app pane — `trantor open` under the hood, opened in the
 project's own checkout wherever it is called from, handoff-beats-resume, and the same kickoff
 prompt so the woken session catches up (handoff, board, memory) and recaps on its own.
+A reboot can leave herdr with a pane in its layout and no terminal behind it; `trantor open`,
+the app's Resume and `trantor prune` all treat such a pane as dead and host a fresh one.
 
 Why crews never exhaust the orchestrator: bus messages are **by reference** (~70 tokens),
 work products stay in each agent's own context — the orchestrator burns at coordination

package/bin/crew/herdr.mjs

@@ -37,11 +37,26 @@ export function splitPane(ctx, pane, direction, cwd = "", execute = herdrCall) {
   return parsed?.result?.pane?.pane_id || "";
 }
 
+// A pane herdr LISTS is not always a pane herdr can RUN (#7247: a restart kept w2:p8 in the
+// layout, so list/get/rename answered, while read/process-info/run said pane_not_found). Rename
+// is a layout question; process-info is the terminal question, and only a terminal hosts a session.
+export function paneAlive(ctx, pane) {
+  if (!pane) return false;
+  const result = herdrCall(ctx, ["pane", "process-info", "--pane", pane]);
+  const parsed = parseJsonOutput(result.stdout);
+  return Boolean(result.ok && parsed && !parsed.error && parsed.result?.process_info);
+}
+
 export function workspacePane(ctx, workspace, preferredCwd) {
-  const parsed = parseJsonOutput(herdrCall(ctx, ["pane", "list"]).stdout);
-  const panes = Array.isArray(parsed) ? parsed : parsed?.panes || parsed?.result?.panes || [];
+  const panes = listPanes(ctx);
   const matches = panes.filter(pane => (pane.workspace_id || pane.workspace || "") === workspace);
-  return matches.find(pane => (pane.cwd || "") === preferredCwd)?.pane_id || matches[0]?.pane_id || matches[0]?.id || "";
+  const preferred = matches.filter(pane => (pane.cwd || "") === preferredCwd);
+  const ordered = [...preferred, ...matches.filter(pane => !preferred.includes(pane))];
+  for (const pane of ordered) {
+    const id = pane.pane_id || pane.id || "";
+    if (id && paneAlive(ctx, id)) return id;
+  }
+  return "";
 }
 
 export function closeWorkspace(ctx, id) {
@@ -70,13 +85,47 @@ function runSeat(ctx, pane, agent, command) {
 }
 
 function trackedWorkspace(ctx) {
-  const ids = readRows(ctx).filter(row => row.project === ctx.project && row.kind === "herdrws").map(row => row.handle);
+  // #7285: duplicate rows of ONE workspace must dedupe — a takeover used to append a second row of
+  // the live workspace, and slice(0,-1) then handed that live workspace to the stale list.
+  const ids = [];
+  for (const id of readRows(ctx).filter(row => row.project === ctx.project && row.kind === "herdrws").map(row => row.handle)) {
+    const at = ids.indexOf(id);
+    if (at >= 0) ids.splice(at, 1);
+    ids.push(id);
+  }
   return { reuse: ids.at(-1) || "", stale: ids.slice(0, -1) };
 }
 
+function listPanes(ctx) {
+  const parsed = parseJsonOutput(herdrCall(ctx, ["pane", "list"]).stdout);
+  return Array.isArray(parsed) ? parsed : parsed?.panes || parsed?.result?.panes || [];
+}
+
+// #7285: the workspaces hosting THIS project's tracked orchestrator pane. Herdr pane ids embed
+// their workspace (#7247 forensics: 'w2:p4Y' lived in w2), so the handle prefix names the home
+// without a round trip; when herdr answers, the pane list is a second opinion (stub ids carry no
+// prefix). Closing such a workspace kills the orchestrator's shell.
+function orchPaneWorkspaces(ctx) {
+  const handles = readRows(ctx).filter(row => row.project === ctx.project && row.kind === "orch").map(row => row.handle);
+  if (!handles.length) return new Set();
+  const spaces = new Set(handles.map(handle => handle.split(":")[0]).filter(Boolean));
+  if (ctx.dry) return spaces;
+  const tracked = new Set(handles);
+  for (const pane of listPanes(ctx)) {
+    if (!tracked.has(pane.pane_id || pane.id || "")) continue;
+    const space = pane.workspace_id || pane.workspace || "";
+    if (space) spaces.add(space);
+  }
+  return spaces;
+}
+
 function prepareWorkspace(ctx, prune) {
   const tracked = trackedWorkspace(ctx);
+  const orchSpaces = orchPaneWorkspaces(ctx);
   for (const id of tracked.stale) {
+    // #7285: never close reuse itself, nor a workspace hosting the tracked orch pane — `up` once
+    // killed its own orchestrator that way. The row stays: the workspace is still live.
+    if (id === tracked.reuse || orchSpaces.has(id)) continue;
     console.log(`  → closing stale stacked crew workspace for ${ctx.project} (${id})`);
     closeWorkspace(ctx, id);
     dropState(ctx, ctx.project, "herdrws", "", id);
@@ -92,6 +141,12 @@ function prepareWorkspace(ctx, prune) {
       console.log(`  → adopting existing untracked crew workspace for ${ctx.project} (${id})`);
       reuse = id;
       recordState(ctx, ctx.project, "herdrws", "__ws__", id);
+    } else if (orchSpaces.has(id)) {
+      // #7285: a labeled workspace hosting the tracked orch pane is the orchestrator's home, not a
+      // stray — adopt it, never close it (the #7285 rule extends past the stale loop).
+      console.log(`  → adopting the crew workspace hosting the tracked orchestrator for ${ctx.project} (${id})`);
+      reuse = id;
+      recordState(ctx, ctx.project, "herdrws", "__ws__", id);
     } else {
       console.log(`  → closing stray crew workspace for ${ctx.project} (${id})`);
       closeWorkspace(ctx, id);
@@ -179,5 +234,6 @@ export function createHerdrAdapter(ctx) {
     closeWorkspace: id => closeWorkspace(ctx, id),
     closePane: id => closePane(ctx, id),
     liveWorkspaces: () => workspaceList(ctx),
+    paneAlive: pane => paneAlive(ctx, pane),
   };
 }

package/bin/crew/open.mjs

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { spawn, execSync } from "node:child_process";
 import { call, parseJsonOutput } from "./core.mjs";
-import { createWorkspace, herdrCall, reportAgent, splitPane, workspaceList, workspacePane } from "./herdr.mjs";
+import { createWorkspace, herdrCall, paneAlive, reportAgent, splitPane, workspaceList, workspacePane } from "./herdr.mjs";
 import { dropState, readRows, recordState } from "./state.mjs";
 import { resolveOrchestratorDir } from "./worktrees.mjs";
 
@@ -103,6 +103,14 @@ function tracked(ctx, live) {
 function reattach(ctx, workspace, pane, id) {
   if (!pane) return false;
   if (ctx.dry) { console.log(`herdr:${workspace || "%DRYWS"}/${pane}`); return true; }
+  // Two probes, because herdr answers them from different places: a pane a restart left in the
+  // layout without a terminal still answers rename, and only process-info says it cannot host
+  // anything. Either way the row is dead and the open path hosts a fresh pane.
+  if (!paneAlive(ctx, pane)) {
+    dropState(ctx, ctx.project, "orch");
+    console.error(`— tracked orchestrator pane ${pane} has no terminal behind it (herdr restarted without it): hosting a fresh pane —`);
+    return false;
+  }
   const renamed = herdrCall(ctx, ["pane", "rename", pane, `orchestrator · ${ctx.project}`]);
   if (!renamed.ok) { dropState(ctx, ctx.project, "orch"); return false; }
   if (!paneHasAgent(ctx, pane)) {
@@ -166,11 +174,10 @@ export function maybeBuildGraft(dir) {
       const cur = existsSync(gi) ? readFileSync(gi, "utf8") : "";
       if (!/^graft\/?$/m.test(cur)) writeFileSync(gi, cur + (cur && !cur.endsWith("\n") ? "\n" : "") + "graft/\n");
     } catch {}
-    // The build is backgrounded, so we cannot gate the pane on its exit code — but a failure has to
-    // land SOMEWHERE. It used to go to stdio:"ignore", which meant a graft whose native parsers were
-    // never built (npm v12 skips node-gyp by default; see deploy/setup.sh) failed in total silence
-    // while the line below still claimed an index was being built.
-    //
+    // The build is backgrounded, so its exit code cannot gate the pane, but a failure has to land
+    // SOMEWHERE: under stdio:"ignore" a graft without native parsers (see deploy/setup.sh) failed in
+    // silence while the line below still claimed an index was being built.
+
     // The log goes to the OS temp dir rather than the project: nothing to gitignore, nothing to clean
     // up, and no exit handler — after unref() the parent usually dies first, so an on-exit cleanup
     // would be a promise we cannot keep. It is simply overwritten by the next open of this project.
@@ -203,6 +210,9 @@ export function openOrchestrator(ctx, args) {
     const prior = tracked(ctx, live);
     if (reattach(ctx, prior.workspace, prior.pane, id)) return 0;
     const chosen = chooseWorkspace(ctx, live, prior.workspace);
+    // #7285: ONE herdrws row per project — re-record exactly like the orch row below, never append.
+    // The appended duplicate made the next `up` close the "stale" copy of the live workspace.
+    dropState(ctx, ctx.project, "herdrws");
     recordState(ctx, ctx.project, "herdrws", "__ws__", chosen.workspace);
     const pane = hostPane(ctx, chosen, id);
     dropState(ctx, ctx.project, "orch");

package/bin/crew/state.mjs

@@ -27,6 +27,9 @@ export function writeRows(ctx, rows) {
 export function recordState(ctx, project, kind, agent, handle) {
   if (ctx.dry) return;
   const rows = readRows(ctx);
+  // #7285: an exact duplicate carries no new fact, and a doubled herdrws row is how `up` came to
+  // see the live workspace as its own stale copy. One row per fact — refuse the push.
+  if (rows.some(row => row.project === project && row.kind === kind && row.agent === agent && row.handle === handle)) return;
   rows.push({ project, kind, agent, handle });
   writeRows(ctx, rows);
 }
@@ -139,7 +142,13 @@ export function prune(ctx, adapters) {
     if (row.kind === "cmuxws") return !cmuxLive.proven || cmuxLive.ids.has(row.handle);
     if (row.kind === "cmux") return !cmuxLive.proven || cmuxLive.names.has(`trantor:${row.project}`);
     if (row.kind === "herdrws") return !herdrLive.proven || herdrLive.ids.has(row.handle);
-    if (["herdr", "orch"].includes(row.kind)) return !herdrLive.proven || herdrLive.names.has(`trantor:${row.project}`);
+    // Workspace first (the cmux 0.17.61 lesson: pane ids there were not a liveness fact), then
+    // the one per-pane fact herdr does state plainly: a pane whose terminal is gone answers
+    // process-info with pane_not_found. A pane that merely hosts a shell stays.
+    if (["herdr", "orch"].includes(row.kind)) {
+      if (!herdrLive.proven) return true;
+      return herdrLive.names.has(`trantor:${row.project}`) && (!adapters.herdr.paneAlive || adapters.herdr.paneAlive(row.handle));
+    }
     return true;
   });
   writeRows(ctx, kept);