trantor 0.18.54 → 0.18.55

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.54",
+  "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/bin/crew/herdr.mjs

@@ -48,8 +48,7 @@ export function paneAlive(ctx, pane) {
 }
 
 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);
   const preferred = matches.filter(pane => (pane.cwd || "") === preferredCwd);
   const ordered = [...preferred, ...matches.filter(pane => !preferred.includes(pane))];
@@ -86,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);
@@ -108,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);

package/bin/crew/open.mjs

@@ -210,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);
 }

package/bin/crew-runner.mjs

@@ -498,7 +498,10 @@ async function notifyAssigners(pairs, text) {
     // right one instead of guessing from timing.
     const payload = { from: SESSION, to: f, text: text.slice(0, 280), project: PROJ, kind: "receipt" };
     if (id) payload.re = id;
-    await api("/send", payload).catch(() => {});
+    const ack = await api("/send", payload).catch(() => ({}));
+    // #7288: remember the id, so a reply threaded onto THIS outcome can later be told apart from a
+    // work order that merely rides `re`.
+    if (Number(ack?.id) > 0) sentOutcomes.add(Number(ack.id));
   }
   if (seen.size) log(`reported outcome to ${[...seen].join(", ")}`);
 }
@@ -908,11 +911,20 @@ function composedTurn({ base = "", wakeText = "", ctxText = "", againText = "",
 const RECEIPT_MARKER = "✅ done on";
 const CARD_REF_RE = /#\d{1,7}(?!\d)/;
 
+// Outcome ids this seat SENT (notifyAssigners records them): a reply threaded onto one of these is
+// about our own outcome, not a new contract.
+const sentOutcomes = new Set();
+
 // Runner-authored metadata is bus state, not work. Typed messages are authoritative; `re` and the
 // stable text marker keep a mixed-version crew safe while older runners are still on the bus.
 function isReceipt(message) {
   const text = String(message?.text || "").trimStart();
-  return message?.kind === "receipt" || Number(message?.re) > 0 || text.startsWith(RECEIPT_MARKER);
+  if (message?.kind === "receipt" || text.startsWith(RECEIPT_MARKER)) return true;
+  // #7288: `re` alone is NOT a receipt — senders are told to thread EVERY reply, so a corrected
+  // contract riding `re` must wake. A reply is a receipt only when it threads an outcome THIS seat
+  // sent and its own text carries no work (an ack/closure, #7079).
+  if (!(Number(message?.re) > 0)) return false;
+  return sentOutcomes.has(Number(message.re)) && !carriesWork(text) && !isContract(message);
 }
 
 function isStatusBroadcast(message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.54",
+  "version": "0.18.55",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"