trantor 0.17.60 → 0.17.62

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.60",
+  "version": "0.17.62",
   "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

@@ -51,7 +51,7 @@ heartbeats, inbox delivery, handoff/baton pass, sub-agent cards):
        "relay": {
          "command": "node",
          "args": ["<absolute-path-to-trantor>/mcp.mjs"],
-         "env": { "RELAY_URL": "http://127.0.0.1:4477", "RELAY_AGENT": "kimi" },
+         "env": { "RELAY_URL": "http://127.0.0.1:4477", "RELAY_AGENT": "kimi-orch" },
          "startupTimeoutMs": 15000,
          "toolTimeoutMs": 150000
        }
@@ -68,6 +68,11 @@ runs your live checkout, so the relay server itself never goes stale. Invoke the
 `/skill:crew`, `/skill:handoff`, `/skill:research`. Set `TRANTOR_DEBUG_HOOKS=1` on the `kimi`
 process to dump raw hook payloads to `~/.agent-bus/kimi-hook-debug.jsonl`.
 
+The orchestrator's bus identity is `kimi-orch:<project>` — deliberately distinct from `kimi:<project>`,
+which belongs to a kimi CREW SEAT (`trantor up kimi`). Same doctrine as the openrouter seat label:
+one bus peer per role, so an orchestrator and its own kimi seat never share a heartbeat, inbox, or
+card attribution.
+
 That's it. (Prefer source? `git clone https://github.com/sashabogi/trantor && cd trantor &&
 npm install && bash deploy/setup.sh` — identical result.)
 

package/bin/app.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// trantor app — install/update the Trantor DESKTOP APP (Tauri) from GitHub Releases.
+//
+// The npm package deliberately does NOT ship desktop/ (a 6MB DMG has no business in node_modules);
+// the app travels as a GitHub Release asset instead. This command is the whole distribution story
+// for a teammate: `npm i -g trantor && trantor app install` → latest DMG lands in /Applications.
+//
+//   trantor app            status: installed version vs latest release
+//   trantor app install    download the latest release DMG and install to /Applications
+//   trantor app update     same as install (re-pulls whatever is latest)
+//
+// Release side (maintainer): build the DMG (cd desktop && npm run tauri build), then
+//   gh release create app-v<ver> desktop/src-tauri/target/release/bundle/dmg/Trantor_<ver>_aarch64.dmg
+// Any release whose assets include a Trantor_*.dmg is an app release; the newest one wins, so app
+// releases interleave freely with code (npm) releases.
+import { execFileSync } from "node:child_process";
+import { createWriteStream, existsSync, rmSync } from "node:fs";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const REPO = "sashabogi/trantor";
+const APP = "/Applications/Trantor.app";
+const ARCH_TAG = process.arch === "arm64" ? "aarch64" : "x64";
+const cmd = process.argv[2] || "status";
+
+if (process.platform !== "darwin") { console.error("trantor app: the desktop app is macOS-only for now"); process.exit(1); }
+if (!["status", "install", "update"].includes(cmd)) {
+  console.error("usage: trantor app [status|install|update]"); process.exit(1);
+}
+
+function sh(file, args) { return execFileSync(file, args, { encoding: "utf8" }); }
+
+function installedVersion() {
+  try { return sh("plutil", ["-extract", "CFBundleShortVersionString", "raw", join(APP, "Contents/Info.plist")]).trim(); }
+  catch { return ""; }
+}
+
+// Newest release carrying a Trantor DMG for this arch (falls back to any Trantor DMG — old
+// releases may predate multi-arch naming). GITHUB_TOKEN is honored but not required (public repo).
+async function latestAppRelease() {
+  const headers = { accept: "application/vnd.github+json", "user-agent": "trantor-app" };
+  if (process.env.GITHUB_TOKEN) headers.authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+  const r = await fetch(`https://api.github.com/repos/${REPO}/releases?per_page=30`, { headers, signal: AbortSignal.timeout(15000) });
+  if (!r.ok) throw new Error(`GitHub API ${r.status} — ${(await r.text()).slice(0, 200)}`);
+  const isDmg = a => /^Trantor[_-].*\.dmg$/.test(a.name);
+  for (const rel of await r.json()) {
+    const assets = (rel.assets || []).filter(isDmg);
+    if (!assets.length) continue;
+    const asset = assets.find(a => a.name.includes(`_${ARCH_TAG}`)) || assets[0];
+    if (!asset.name.includes(`_${ARCH_TAG}`)) console.error(`⚠ no ${ARCH_TAG} build in ${rel.tag_name} — using ${asset.name} (may not run on this Mac)`);
+    const version = (asset.name.match(/[_-]([0-9]+(?:\.[0-9]+)*)[_-]/) || [])[1] || rel.tag_name.replace(/^app-v?|^v/, "");
+    return { tag: rel.tag_name, version, asset };
+  }
+  throw new Error("no release with a Trantor DMG asset found");
+}
+
+const rel = await latestAppRelease().catch(e => { console.error(`trantor app: ${e.message}`); process.exit(1); });
+const have = installedVersion();
+
+if (cmd === "status") {
+  console.log(`installed: ${have ? `${have} (${APP})` : "not installed"}`);
+  console.log(`latest:    ${rel.version} (${rel.tag} · ${rel.asset.name})`);
+  console.log(have === rel.version ? "up to date." : `run \`trantor app install\` to get ${rel.version}.`);
+  process.exit(0);
+}
+
+console.log(`↓ ${rel.asset.name} (${(rel.asset.size / 1e6).toFixed(1)}MB) from ${rel.tag}…`);
+const dmg = join(tmpdir(), rel.asset.name);
+const dl = await fetch(rel.asset.browser_download_url, { headers: { "user-agent": "trantor-app" }, signal: AbortSignal.timeout(300000) });
+if (!dl.ok || !dl.body) { console.error(`download failed: HTTP ${dl.status}`); process.exit(1); }
+await pipeline(Readable.fromWeb(dl.body), createWriteStream(dmg));
+
+let mount = "";
+try {
+  // -nobrowse keeps the volume out of Finder; mount point is the last tab-field of the last line.
+  const out = sh("hdiutil", ["attach", "-nobrowse", "-readonly", dmg]);
+  mount = (out.trim().split("\n").pop() || "").split("\t").pop().trim();
+  const src = join(mount, "Trantor.app");
+  if (!mount.startsWith("/Volumes/") || !existsSync(src)) throw new Error(`unexpected DMG layout (mount: ${mount || "none"})`);
+  if (existsSync(APP)) { console.log(`replacing ${APP} (was ${have || "unknown"})`); rmSync(APP, { recursive: true, force: true }); }
+  sh("ditto", [src, APP]);
+  // The download carries quarantine; the user explicitly asked for this install — clear it so
+  // Gatekeeper doesn't refuse the unsigned build on first launch.
+  try { sh("xattr", ["-dr", "com.apple.quarantine", APP]); } catch {}
+  console.log(`✓ Trantor.app ${installedVersion() || rel.version} installed → ${APP}`);
+} catch (e) {
+  console.error(`install failed: ${e.message}`); process.exitCode = 1;
+} finally {
+  if (mount) try { sh("hdiutil", ["detach", mount, "-quiet"]); } catch {}
+  try { rmSync(dmg, { force: true }); } catch {}
+}

package/bin/cli.mjs

@@ -25,6 +25,7 @@ switch (cmd) {
   case "up":      process.argv.splice(2, 1); spawn("/bin/bash", [join(ROOT, "bin/crew.sh"), "up", ...args], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
   case "down":    spawn("/bin/bash", [join(ROOT, "bin/crew.sh"), "down", ...args], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
   case "swap":    spawn("/bin/bash", [join(ROOT, "bin/crew.sh"), "swap", ...args], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
+  case "prune":   spawn("/bin/bash", [join(ROOT, "bin/crew.sh"), "prune", ...args], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
   case "hub": {
     const sub = args[0];
     // Per-project hub routing (TDD §12.1): a project lives on exactly ONE hub; codependent
@@ -71,6 +72,7 @@ switch (cmd) {
   case "policy": run("bin/policy.mjs"); break;
   case "inbox": run("bin/inbox.mjs"); break;
   case "duty": run("bin/duty.mjs"); break;
+  case "app": run("bin/app.mjs"); break;
   case "identity": {
     const { load, publicView, generate, keyPath } = await import(join(ROOT, "lib/identity.mjs"));
     const sub = args[0], name = args[1] || "human";
@@ -152,7 +154,9 @@ switch (cmd) {
   trantor models      browse live models behind each seat + the router's pick per difficulty
   trantor up …        spawn a crew here:   trantor up codex kimi deepseek:deepseek glm:zai-coding-plan
   trantor down        tear the crew down (kills processes, closes windows, no dialogs)
+  trantor prune       drop dead crew-window tracking rows (ghost workspaces/panes) without spawning anything
   trantor ui          open the live dashboard (board + flow views)
+  trantor app         the DESKTOP app: status | install | update — pulls the latest DMG from GitHub Releases
   trantor catchup     "where are we?" — the continuous board + git, with a synthesized brief
   trantor agents      what this session's sub-agents did (task · returned? · files written · survived on disk) — [<sessionId>] [--json]
   trantor gates       verification gates: "must verify before shipping" claims that survive handoffs — [--all] [--json]
@@ -167,6 +171,7 @@ switch (cmd) {
   trantor watch       live bus feed in the terminal
   trantor inbox       THIS session's unread bus messages, signed (works under enforce) — [--all] [--consume] [--json]
   trantor policy      the autonomy ladder: show | set <project> <1-4> | link <a> <b> --reason "<why>"
+  trantor duty        the always-on fleet duty agent: up | down | status — hub-escalated triage so you are not the switchboard
 
 Claude Code plugin (the orchestrator side):
   claude plugin marketplace add sashabogi/trantor && claude plugin install trantor

package/bin/crew.sh

@@ -125,6 +125,36 @@ end tell
 OSA
 }
 
+# surgical STATE row removal: drop every row matching PROJECT+KIND (+AGENT/+HANDLE when given).
+# Empty $3/$4 = wildcard. Callers beware: uses _parse_row, which clobbers the RP/RK/RA/RH globals.
+_state_drop() {   # $1=project $2=kind $3=agent(''=any) $4=handle(''=any)
+  [ "$DRY" = "1" ] && return 0
+  [ -f "$STATE" ] || return 0
+  local tmp="$STATE.tmp" line
+  : > "$tmp"
+  while IFS= read -r line; do
+    [ -n "$line" ] || continue
+    _parse_row "$line"
+    if [ "$RP" = "$1" ] && [ "$RK" = "$2" ] && { [ -z "$3" ] || [ "$RA" = "$3" ]; } && { [ -z "$4" ] || [ "$RH" = "$4" ]; }; then continue; fi
+    printf '%s\t%s\t%s\t%s\n' "$RP" "$RK" "$RA" "$RH" >> "$tmp"
+  done < "$STATE"
+  mv "$tmp" "$STATE"; [ -s "$STATE" ] || rm -f "$STATE"
+}
+
+# Belt-and-suspenders on seat teardown: closing the pane/window SHOULD take the runner with it, but a
+# STALE handle (the 2026-07-30 duplicate-row incident) closes nothing while teardown thinks it's done —
+# the runner survives invisible, still long-polling the inbox. So teardown also kills the seat's
+# processes directly: the per-seat launcher shell, and the runner via the same ANCHORED pattern
+# doctrine as reap_seat (…/<project>$ — a sibling project can never match). CREW_NO_PROC_KILL=1 is the
+# test-suite escape hatch: the suite seeds real project names, and a live crew must survive `npm test`.
+_kill_seat_procs() {   # $1=project $2=agent
+  [ "${CREW_NO_PROC_KILL:-0}" = "1" ] && return 0
+  [ -n "$1" ] && [ -n "$2" ] || return 0
+  local pid
+  for pid in $(pgrep -f "seats/$1-$2\.sh" 2>/dev/null); do run "kill -9 $pid 2>/dev/null"; done
+  for pid in $(pgrep -f "crew-runner\.mjs $2 .*/$1"'$' 2>/dev/null); do run "kill -9 $pid 2>/dev/null"; done
+}
+
 # ── down: PROJECT-SCOPED teardown (never touches another project's crew) ─────────────────────────────
 usage_down() {
   cat <<EOF
@@ -187,6 +217,7 @@ down() {
         fi ;;
       win|attach) { [ "${#AGENTS[@]}" -gt 0 ] && [ "$K2" = "attach" ]; } && continue; _kill_win "$H2" ;;
     esac
+    case "$K2" in cmuxws|attach) : ;; *) _kill_seat_procs "$P2" "$A2" ;; esac
   done
 
   # rewrite STATE minus the rows we tore down (leaves OTHER projects' rows intact)
@@ -205,13 +236,26 @@ down() {
   echo "— crew torn down ($SCOPE_DESC)"
 }
 [ "$CMD" = "down" ] && { down "$@"; exit $?; }
-case "$CMD" in up|swap) ;; *) echo "usage: crew.sh up <agent...> | crew.sh swap <old> <new[:provider[/model]]> | crew.sh down [<agent>...] [--all --yes]"; exit 1 ;; esac
+case "$CMD" in up|swap|prune) ;; *) echo "usage: crew.sh up <agent...> | crew.sh swap <old> <new[:provider[/model]]> | crew.sh down [<agent>...] [--all --yes] | crew.sh prune"; exit 1 ;; esac
 
 # self-heal: drop STATE rows whose Terminal window is already gone (dead crews from past sessions), so the
-# file doesn't accumulate ghosts across ups. tmux rows are validated by their session existing.
+# file doesn't accumulate ghosts across ups. tmux rows are validated by their session existing; cmux rows
+# by the workspace/surface uuid still existing on the control socket. Socket off (or an empty/unparsable
+# workspace list) ⇒ cmux rows are KEPT — we can't prove death, and they self-heal next time it answers.
 prune_dead_state() {
   [ -f "$STATE" ] || return 0
   [ "$DRY" = "1" ] && return 0
+  local CLIVE=""
+  if _cmux_ok; then
+    local wids wid
+    wids="$(_cmux workspace list --id-format both --json 2>/dev/null | node -e 'let d="";process.stdin.on("data",c=>d+=c).on("end",()=>{try{const o=JSON.parse(d.slice(d.search(/[\[{]/)));const a=Array.isArray(o)?o:(o.workspaces||[]);console.log(a.map(x=>x.id).filter(Boolean).join(" "))}catch(e){}})')"
+    if [ -n "$wids" ]; then
+      CLIVE="$wids"
+      for wid in $wids; do
+        CLIVE="$CLIVE $(_cmux list-pane-surfaces --workspace "$wid" --id-format uuids --json 2>/dev/null | node -e 'let d="";process.stdin.on("data",c=>d+=c).on("end",()=>{try{const o=JSON.parse(d.slice(d.search(/[\[{]/)));const a=o.surfaces||o.panes||o;console.log((Array.isArray(a)?a:[]).map(s=>s.id||s.surface_id).filter(Boolean).join(" "))}catch(e){}})')"
+      done
+    fi
+  fi
   local tmp="$STATE.tmp" line alive
   : > "$tmp"
   while IFS= read -r line; do
@@ -222,11 +266,15 @@ prune_dead_state() {
       [ -n "$(osascript -e "tell application \"Terminal\" to get id of (first window whose id is $RH)" 2>/dev/null)" ] || alive=0
     elif [ "$RK" = "tmux" ]; then
       tmux has-session -t "trantor:$RP" 2>/dev/null || alive=0
+    elif [ "$RK" = "cmuxws" ] || [ "$RK" = "cmux" ]; then
+      if [ -n "$CLIVE" ]; then case " $CLIVE " in *" $RH "*) : ;; *) alive=0 ;; esac; fi
     fi
     [ "$alive" = "1" ] && printf '%s\t%s\t%s\t%s\n' "$RP" "$RK" "$RA" "$RH" >> "$tmp"
   done < "$STATE"
   mv "$tmp" "$STATE"; [ -s "$STATE" ] || rm -f "$STATE"
 }
+# `crew.sh prune` — run the self-heal on demand (ops: clean ghost rows without spawning anything).
+[ "$CMD" = "prune" ] && { prune_dead_state; echo "— pruned dead crew rows ($STATE) —"; exit 0; }
 
 # --task/--difficulty drive LAZY live-model selection for provider-only specs (agent:provider).
 TASK="code"; DIFF="medium"; _ARGS=()
@@ -395,17 +443,86 @@ spawn_cmux() {   # $@ = specs
     echo "  ~/.config/cmux/cmux.json (cmux auto-reloads). —"
     spawn_cmux_applescript "$@"; return
   fi
+  # ── replace, never stack (workspace edition, 2026-08-07) ──────────────────────────────────────────
+  # Every `up` used to create a brand-new workspace — no awareness of a crew already on screen — so
+  # repeated ups (and the bus-verify RETRY path, which re-enters spawn_crew) stacked dead
+  # trantor:<proj> tabs in the sidebar. Observed six deep on crebral-health. Now the NEWEST tracked
+  # workspace for this project is REUSED: each spec becomes a fresh pane inside it, replacing any old
+  # pane for the same agent; older stacked workspaces are closed. Rows are read even in DRY mode
+  # (read-only) so tests can seed a board.
+  local REUSE_WS="" line w
+  local stale_ws=()
+  if [ -f "$STATE" ]; then
+    while IFS= read -r line; do
+      [ -n "$line" ] || continue
+      _parse_row "$line"
+      { [ "$RP" = "$PROJ" ] && [ "$RK" = "cmuxws" ]; } || continue
+      [ -n "$REUSE_WS" ] && stale_ws+=("$REUSE_WS")
+      REUSE_WS="$RH"
+    done < "$STATE"
+  fi
+  if [ "${#stale_ws[@]}" -gt 0 ]; then
+    for w in "${stale_ws[@]}"; do
+      echo "  → closing stale stacked crew workspace for $PROJ ($w)"
+      _cmux_close_tab "$w"; _state_drop "$PROJ" "cmuxws" "" "$w"
+    done
+    prune_dead_state    # the closed workspaces' seat rows just died with them
+  fi
+  # Untracked strays: LIVE workspaces named trantor:<proj> that STATE doesn't know (rows lost, or a
+  # pre-fix pileup). Adopt one as the reuse target if we have none; close the rest.
+  if [ "$DRY" != "1" ]; then
+    local named nid
+    named="$(_cmux workspace list --id-format both --json 2>/dev/null | WSNAME="trantor:$PROJ" node -e 'let d="";process.stdin.on("data",c=>d+=c).on("end",()=>{try{const o=JSON.parse(d.slice(d.search(/[\[{]/)));const a=Array.isArray(o)?o:(o.workspaces||[]);console.log(a.filter(x=>x.custom_title===process.env.WSNAME||x.name===process.env.WSNAME).map(x=>x.id).filter(Boolean).join(" "))}catch(e){}})')"
+    for nid in $named; do
+      [ "$nid" = "$REUSE_WS" ] && continue
+      [ -f "$STATE" ] && grep -qF "$nid" "$STATE" && continue     # tracked → handled above
+      if [ -z "$REUSE_WS" ]; then
+        echo "  → adopting existing untracked crew workspace for $PROJ ($nid)"
+        REUSE_WS="$nid"; record_state "$PROJ" "cmuxws" "__ws__" "$nid"
+      else
+        echo "  → closing stray crew workspace for $PROJ ($nid)"
+        _cmux_close_tab "$nid"
+      fi
+    done
+  fi
   # Grid tiling: COLS = ceil(sqrt(N)) → 2 seats side-by-side, 4 = 2×2, 6 = 3×2. Row 0 is built with
   # RIGHT splits off the previous column; each later row splits DOWN from the pane directly above it.
   # Every split TARGETS a recorded surface id (--surface) — never "whatever pane happens to be focused",
-  # which is what produced the old staircase layout.
+  # which is what produced the old staircase layout. (In REUSE mode a replaced seat splits off its OWN
+  # old pane — keeping its spot — and added seats split right off the previous new pane; the fresh-grid
+  # math only applies to a fresh workspace.)
   local N=$# COLS=1; while [ $(( COLS * COLS )) -lt "$N" ]; do COLS=$(( COLS + 1 )); done
   local SPEC wsid="" surf="" i=0
   local surfs=()
+  [ -n "$REUSE_WS" ] && wsid="$REUSE_WS"
   for SPEC in "$@"; do
     resolve_spec "$SPEC"
     local cmd launcher; cmd="$(RUN_CMD)"; launcher="$(_seat_launcher "$AGENT" "$cmd")"
-    if [ "$i" = "0" ]; then
+    if [ -n "$REUSE_WS" ]; then
+      # replace-in-place: split the fresh pane FIRST (targeting the agent's old pane when tracked),
+      # then close the old pane — split-first so the workspace can never hit zero surfaces mid-swap.
+      local OLD_SURF=""
+      if [ -f "$STATE" ]; then
+        while IFS= read -r line; do
+          [ -n "$line" ] || continue
+          _parse_row "$line"
+          [ "$RP" = "$PROJ" ] && [ "$RK" = "cmux" ] && [ "$RA" = "$AGENT" ] && OLD_SURF="$RH"
+        done < "$STATE"
+      fi
+      if [ "$DRY" = "1" ]; then
+        echo "[dry] cmux: reuse workspace $wsid — new-split for $AGENT${OLD_SURF:+ (replacing $OLD_SURF)}"
+        surf="%DRYT$i"
+        [ -n "$OLD_SURF" ] && _cmux_close_term "$OLD_SURF"
+      else
+        local tflag=()
+        if [ -n "$OLD_SURF" ]; then tflag=(--surface "$OLD_SURF")
+        elif [ "$i" -gt 0 ] && [ -n "${surfs[$(( i - 1 ))]}" ]; then tflag=(--surface "${surfs[$(( i - 1 ))]}"); fi
+        surf="$(_cmux new-split right --workspace "$wsid" ${tflag[@]+"${tflag[@]}"} --id-format uuids --json 2>/dev/null | _cmux_surf_json)"
+        [ -n "$surf" ] || surf="$(_cmux new-split right --workspace "$wsid" --id-format uuids --json 2>/dev/null | _cmux_surf_json)"
+        [ -n "$surf" ] && { _cmux send --surface "$surf" "bash $launcher" >/dev/null 2>&1; _cmux send-key --surface "$surf" enter >/dev/null 2>&1; }
+        if [ -n "$OLD_SURF" ]; then _cmux_close_term "$OLD_SURF"; _state_drop "$PROJ" "cmux" "$AGENT" ""; fi
+      fi
+    elif [ "$i" = "0" ]; then
       if [ "$DRY" = "1" ]; then
         echo "[dry] cmux: new-workspace (cwd $DIR) --command 'bash $launcher' → rename 'trantor:$PROJ'"
         wsid="%DRYWS"; surf="%DRYT0"
@@ -444,10 +561,54 @@ spawn_cmux_applescript() {   # $@ = specs
   local N=$# COLS=1; while [ $(( COLS * COLS )) -lt "$N" ]; do COLS=$(( COLS + 1 )); done
   local SPEC tabid="" termid="" i=0
   local terms=()
+  # replace, never stack — AppleScript edition. No socket ⇒ no liveness list, so the newest tracked
+  # tab is validated by asking cmux for it directly; a dead tracked tab is dropped, older stacked
+  # tabs are closed. Reuse then rides the normal split path (i>0) from the first seat.
+  local line t REUSE_TAB=""
+  local stale_tabs=()
+  if [ -f "$STATE" ]; then
+    while IFS= read -r line; do
+      [ -n "$line" ] || continue
+      _parse_row "$line"
+      { [ "$RP" = "$PROJ" ] && [ "$RK" = "cmuxws" ]; } || continue
+      [ -n "$REUSE_TAB" ] && stale_tabs+=("$REUSE_TAB")
+      REUSE_TAB="$RH"
+    done < "$STATE"
+  fi
+  if [ "${#stale_tabs[@]}" -gt 0 ]; then
+    for t in "${stale_tabs[@]}"; do
+      echo "  → closing stale stacked crew workspace for $PROJ ($t)"
+      _cmux_close_tab "$t"; _state_drop "$PROJ" "cmuxws" "" "$t"
+    done
+  fi
+  if [ -n "$REUSE_TAB" ] && [ "$DRY" != "1" ]; then
+    local ok; ok="$(osascript 2>/dev/null <<OSA
+tell application "cmux"
+  repeat with w in windows
+    repeat with tt in tabs of w
+      if (id of tt) is "$REUSE_TAB" then return "OK"
+    end repeat
+  end repeat
+  return "ERR"
+end tell
+OSA
+)"
+    [ "$ok" = "OK" ] || { _state_drop "$PROJ" "cmuxws" "" "$REUSE_TAB"; _state_drop "$PROJ" "cmux" "" ""; REUSE_TAB=""; }
+  fi
+  [ -n "$REUSE_TAB" ] && { tabid="$REUSE_TAB"; echo "  → reusing existing crew workspace for $PROJ ($tabid)"; }
   for SPEC in "$@"; do
     resolve_spec "$SPEC"
     local cmd launcher; cmd="$(RUN_CMD)"; launcher="$(_seat_launcher "$AGENT" "$cmd")"
-    if [ "$i" = "0" ]; then
+    # In REUSE mode, replace-in-place: split off the agent's old terminal when tracked, close it after.
+    local OLD_SURF=""
+    if [ -n "$REUSE_TAB" ] && [ -f "$STATE" ]; then
+      while IFS= read -r line; do
+        [ -n "$line" ] || continue
+        _parse_row "$line"
+        [ "$RP" = "$PROJ" ] && [ "$RK" = "cmux" ] && [ "$RA" = "$AGENT" ] && OLD_SURF="$RH"
+      done < "$STATE"
+    fi
+    if [ -z "$tabid" ] && [ "$i" = "0" ]; then
       if [ "$DRY" = "1" ]; then
         echo "[dry] cmux(AppleScript): new tab (trantor:$PROJ) + run 'bash $launcher'"; tabid="%DRYTAB"; termid="%DRYT0"
       else
@@ -470,11 +631,15 @@ OSA
       fi
       record_state "$PROJ" "cmuxws" "__ws__" "$tabid"
     else
-      local dir target
-      if [ $(( i / COLS )) = "0" ]; then dir="right"; target="${terms[$(( i - 1 ))]}"
-      else dir="down"; target="${terms[$(( i - COLS ))]}"; fi
+      local dir target=""
+      if [ -n "$OLD_SURF" ]; then dir="right"; target="$OLD_SURF"          # replace-in-place: keep the seat's spot
+      elif [ "$i" -gt 0 ]; then
+        if [ $(( i / COLS )) = "0" ]; then dir="right"; target="${terms[$(( i - 1 ))]}"
+        else dir="down"; target="${terms[$(( i - COLS ))]}"; fi
+      else dir="right"; fi                                                 # reuse mode, first seat, nothing tracked → focused terminal
       if [ "$DRY" = "1" ]; then
         echo "[dry] cmux(AppleScript): split $dir from ${target:-<focused>} + run 'bash $launcher'"; termid="%DRYT$i"
+        [ -n "$OLD_SURF" ] && _cmux_close_term "$OLD_SURF"
       else
         termid="$(osascript 2>/dev/null <<OSA
 tell application "cmux"
@@ -497,6 +662,7 @@ tell application "cmux"
 end tell
 OSA
 )"
+        [ -n "$OLD_SURF" ] && [ -n "$termid" ] && [ "$termid" != "ERR" ] && { _cmux_close_term "$OLD_SURF"; _state_drop "$PROJ" "cmux" "$AGENT" ""; }
       fi
     fi
     terms+=("$termid")

package/package.json

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