trantor 0.18.114 → 0.18.116

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.114",
+  "version": "0.18.116",
   "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/stage.mjs

@@ -3,6 +3,15 @@ import { setTimeout } from "node:timers/promises";
 import { loadOrCreate } from "../../lib/identity.mjs";
 import { ensureEnrolled } from "../../lib/enroll.mjs";
 import { sfetchJson } from "../../lib/signed-fetch.mjs";
+import { personaName } from "../../lib/persona.mjs";
+
+export async function unregisterSwapStage(hub, project, session) {
+  const identity = loadOrCreate(session, "agent");
+  const response = await sfetchJson(`${hub}/unregister`, {
+    identity, payload: { session, project }, signal: AbortSignal.timeout(8000),
+  });
+  if (!response.ok) throw new Error(`replacement deregistration failed: ${response.status}`);
+}
 
 // A replacement registers before it touches the old runner's worktree or queue.
 export async function awaitSwapRelease(env = process.env) {
@@ -25,4 +34,8 @@ export async function awaitSwapRelease(env = process.env) {
   }
   const handoff = JSON.parse(readFileSync(`${stage}.release`, "utf8"));
   if (handoff.agent !== env.CREW_SWAP_AGENT) throw new Error("swap release names a different seat");
+  const persona = personaName(handoff.persona);
+  if (env.CREW_PERSONA && env.CREW_PERSONA !== persona) throw new Error("swap release names a different persona");
+  env.CREW_PERSONA = persona;
+  await unregisterSwapStage(env.RELAY_URL, env.RELAY_PROJECT, session);
 }

package/bin/crew/state.mjs

@@ -3,6 +3,7 @@ import { dirname, join } from "node:path";
 import { seatProcesses, signalProcesses } from "./processes.mjs";
 import { call, listPids, run } from "./core.mjs";
 import { hostId } from "../../lib/project.mjs";
+import { signedPost } from "../../hooks/lib/api.mjs";
 import { statePathFor as dockerStatePathFor, sweep as dockerSweep } from "../../lib/docker-janitor.mjs";
 
 export function parseRow(line) {
@@ -122,15 +123,22 @@ function closeTmux(ctx, row, perSeat, seen) {
   run(ctx, "tmux", ["kill-session", "-t", session], { rendered: `tmux kill-session -t '${session}' 2>/dev/null` });
 }
 
-export async function down(ctx, args, adapters) {
+async function unregisterSeat(ctx, project, persona) {
+  const path = project === ctx.project ? `${ctx.hub}/unregister` : "/unregister";
+  const response = await signedPost(path, { session: `${persona}:${project}`, project }, { project });
+  if (!response.ok || !response.json?.ok) throw new Error(response.json?.error || response.reason || `hub HTTP ${response.status}`);
+  return response.json;
+}
+
+export async function down(ctx, args, adapters, { unregister = unregisterSeat } = {}) {
   const options = parseDownArgs(ctx, args);
   if (options.help) return 0;
   if (options.error) return 1;
   const rows = readRows(ctx);
-  if (!rows.length) { console.log("no tracked crew windows"); return 0; }
+  if (!rows.length && !options.agents.length) { console.log("no tracked crew windows"); return 0; }
   const scoped = rows.filter(row => (options.all || row.project === ctx.project) && (!options.agents.length || options.agents.includes(row.persona)));
   const scope = options.all ? "all projects" : `project \"${ctx.project}\"`;
-  if (!scoped.length) { console.log(`nothing to tear down for ${scope}`); return 0; }
+  if (!scoped.length && !options.agents.length) { console.log(`nothing to tear down for ${scope}`); return 0; }
   console.log(`— tearing down (${scope}):`);
   for (const row of scoped) if (!["attach", "cmuxws", "herdrws", "orch"].includes(row.kind)) console.log(`  • ${row.project || "<legacy>"} · ${row.persona} (${row.kind})`);
   if (options.all && !options.yes) {
@@ -144,6 +152,21 @@ export async function down(ctx, args, adapters) {
   const kept = rows.filter(row => !removed.has(`${row.project}|${row.kind}|${row.persona}|${row.handle}`) || (orchProjects.has(row.project) && ["herdrws", "cmuxws", "orch"].includes(row.kind)));
   writeRows(ctx, kept);
   const seatRows = scoped.filter(row => !["attach", "cmuxws", "herdrws", "orch"].includes(row.kind));
+  const staleSeats = options.agents.filter(persona => !scoped.some(row => row.persona === persona))
+    .map(persona => ({ project: ctx.project, persona, stale: true }));
+  const seats = new Map([...seatRows, ...staleSeats].map(row => [`${row.project}/${row.persona}`, row]));
+  const failures = [];
+  for (const row of seats.values()) {
+    if (!row.project) continue;
+    if (ctx.dry) { console.log(`[dry] unregister ${row.persona}:${row.project}`); continue; }
+    try {
+      const result = await unregister(ctx, row.project, row.persona);
+      if (row.stale) console.log(result.removed ? `  removed a stale seat row: ${row.persona}:${row.project}` : `  no hub seat row: ${row.persona}:${row.project}`);
+    } catch (error) {
+      failures.push(`${row.persona}:${row.project}: ${error.message}`);
+      console.error(`  ${row.persona}:${row.project}: hub row removal failed: ${error.message}`);
+    }
+  }
   if (!ctx.dry) {
     const logDir = join(dirname(ctx.statePath), "logs");
     mkdirSync(logDir, { recursive: true });
@@ -152,6 +175,10 @@ export async function down(ctx, args, adapters) {
         `${JSON.stringify({ ts: Date.now(), agent: row.persona, project: row.project, stopped: true })}\n`);
     }
   }
+  if (failures.length) {
+    console.log(`— hub row removal incomplete; retry Stop: ${failures.join("; ")}`);
+    return 1;
+  }
   if (options.agents.length) {
     const stopped = [...new Set(seatRows.map(row => row.persona))];
     const remaining = [...new Set(kept.filter(row => row.project === ctx.project &&

package/bin/crew/swap.mjs

@@ -1,5 +1,6 @@
-import { updatePersona } from "../../lib/persona.mjs";
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { unregisterSwapStage } from "./stage.mjs";
+import { allocatePersona, updatePersona } from "../../lib/persona.mjs";
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { setTimeout } from "node:timers/promises";
@@ -85,7 +86,7 @@ async function hubRequest(ctx, path, body) {
   return response.json;
 }
 
-export function swapRuntime(ctx, adapters, spawn) {
+export function swapRuntime(ctx, adapters, spawn, { now = Date.now, pause = setTimeout, requestTimeoutMs = 8000 } = {}) {
   let pids = [];
   let replacementPid;
   return {
@@ -97,14 +98,23 @@ export function swapRuntime(ctx, adapters, spawn) {
       spawn(staged, { ...seat, persona: stage.label });
     },
     async ready(stage) {
-      const deadline = Date.now() + 30000;
+      const deadline = now() + 30000;
       while (!existsSync(`${stage.path}.ready`)) {
-        if (Date.now() > deadline) throw new Error("replacement did not join the bus within 30s; old seat unchanged");
-        await setTimeout(100);
+        if (now() > deadline) throw new Error("replacement did not join the bus within 30s; old seat unchanged");
+        await pause(100);
       }
       const ready = JSON.parse(readFileSync(`${stage.path}.ready`, "utf8"));
-      const response = await signedGet(`${ctx.hub}/peers?project=${encodeURIComponent(ctx.project)}`, { project: ctx.project });
-      if (!response.ok || !response.json?.peers?.some(p => p.session === ready.session)) throw new Error("replacement registration is not visible on the bus");
+      let failure = "status=0 reason=readiness deadline elapsed timedOut=false";
+      let visible = false;
+      while (now() < deadline) {
+        const response = await signedGet(`${ctx.hub}/peers?project=${encodeURIComponent(ctx.project)}`, {
+          project: ctx.project, timeoutMs: Math.min(requestTimeoutMs, deadline - now()),
+        });
+        if (response.ok && response.json?.peers?.some(p => p.session === ready.session)) { visible = true; break; }
+        failure = `status=${response.status} reason=${response.reason || response.json?.error || "replacement absent from roster"} timedOut=${response.timedOut === true}`;
+        await pause(Math.min(100, Math.max(0, deadline - now())));
+      }
+      if (!visible) throw new Error(`replacement registration is not visible on the bus: ${failure}`);
       process.kill(ready.pid, 0);
       replacementPid = ready.pid;
       return ready.session;
@@ -114,10 +124,16 @@ export function swapRuntime(ctx, adapters, spawn) {
     transfer: body => hubRequest(ctx, "/contracts/transfer", body),
     async stop(agent) {
       process.kill(replacementPid, 0);
-      await down(ctx, [agent], adapters);
+      if (await down(ctx, [agent], adapters)) throw new Error("old seat stopped locally but its hub row could not be removed");
       signalProcesses(pids, "SIGKILL");
     },
-    async cancel(stage) { await down(ctx, [stage.label], adapters); },
+    async cancel(stage) {
+      const code = await down(ctx, [stage.label], adapters, { unregister: async () => {
+        await unregisterSwapStage(ctx.hub, ctx.project, `${stage.label}:${ctx.project}`);
+        return { removed: true };
+      } });
+      if (code) throw new Error("replacement hub row could not be removed");
+    },
     release(stage, persona, cursor) {
       writeRows(ctx, readRows(ctx).map(row => row.project === ctx.project && row.persona === stage.label ? { ...row, persona } : row));
       writeFileSync(runnerRecord(ctx, ctx.project, persona), JSON.stringify({ label: stage.label, dir: ctx.dir }));
@@ -132,29 +148,36 @@ export async function performSwap(ctx, options, runtime) {
   let stage, frozen = false, transferred = false;
   try {
     const seat = await runtime.validate(options);
+    const occupied = [options.from, seat.agent, ...readRows(ctx).filter(row => row.project === ctx.project).map(row => row.persona)];
+    const { persona } = allocatePersona({ dir: join(ctx.home, ".agent-bus"), project: ctx.project, agent: seat.agent, model: seat.model, occupied });
+    result.to = persona;
     const label = `${options.agent}-swap-${randomUUID().slice(0, 8)}`;
     mkdirSync(ctx.seatDir, { recursive: true });
-    stage = { label, path: join(ctx.seatDir, label), persona: options.from, agent: seat.agent, model: seat.model };
+    stage = { label, path: join(ctx.seatDir, label), persona, agent: seat.agent, model: seat.model };
     await runtime.start(seat, stage);
     const readySession = await runtime.ready(stage);
     frozen = true;
     await runtime.freeze(options.from);
     const pending = readPending(ctx, options.from);
-    const target = pending;
-    const from = `${options.from}:${ctx.project}`, to = from;
+    const target = readPending(ctx, persona);
+    const from = `${options.from}:${ctx.project}`, to = `${persona}:${ctx.project}`;
     const handoff = await runtime.transfer({ from, to, project: ctx.project, readySession, _op: `swap-${stage.label}`, heldAsk: pending.ask || 0, pendingIds: pending.wake.map(m => m.id) });
     transferred = true;
     result.moved = [...new Set([...pending.wake.map(m => m.id), ...handoff.moved])];
     const wake = new Map([...target.wake, ...pending.wake, ...handoff.messages].map(m => [m.id, { ...m, to }]));
-    savePending(ctx, options.from, { ...target, wake: [...wake.values()], bcast: [...new Map([...target.bcast, ...pending.bcast].map(m => [m.id, m])).values()], ask: handoff.messages.some(m => m.re === pending.ask) ? 0 : pending.ask || target.ask, askTo: pending.askTo || target.askTo });
+    savePending(ctx, persona, { ...target, wake: [...wake.values()], bcast: [...new Map([...target.bcast, ...pending.bcast].map(m => [m.id, m])).values()], seen: [...new Set([...target.seen, ...pending.seen])], ask: handoff.messages.some(m => m.re === pending.ask) ? 0 : pending.ask || target.ask, askTo: pending.askTo || target.askTo });
     await runtime.stop(options.from);
     frozen = false;
-    await runtime.release(stage, options.from, handoff.cursor);
+    await runtime.release(stage, persona, handoff.cursor);
+    if (existsSync(pendingPath(ctx, options.from))) unlinkSync(pendingPath(ctx, options.from));
     return { ...result, ok: true };
   } catch (error) {
     if (!transferred) {
       if (frozen) await runtime.resume();
-      if (stage) await runtime.cancel(stage);
+      if (stage) {
+        try { await runtime.cancel(stage); }
+        catch (cleanupError) { error.message += `; replacement cleanup failed: ${cleanupError.message}`; }
+      }
     }
     result.reason = error.message;
     if (transferred) result.reason += "; handoff recorded on hub; old seat held for recovery";

package/hub/routes/admin.mjs

@@ -36,6 +36,20 @@ export async function routeAdmin({ req, res, q, P, auth, ctx }) {
       }
       return json(res, 200, keyUsageSnapshot(state, now(), ONLINE_MS));
     }
+    if (req.method === "POST" && P === "/unregister") {
+      const b = await body(req);
+      if (!b.session || !b.project) return json(res, 400, { error: "session and project required" });
+      const peer = state.peers[b.session];
+      if (peer && peer.project !== canon(b.project)) return json(res, 403, { error: "peer belongs to a different project" });
+      const self = auth?.identity?.name === b.session && scopeAllows(auth.identity, b.project, "write");
+      const owner = scopeAllows(auth?.identity, b.project, "owner") && (!peer || peer.kind === "agent");
+      if (AUTH_MODE !== "off" && !self && !owner) {
+        return json(res, 403, { error: "only the session itself or a project owner removing an agent can unregister its peer" });
+      }
+      delete state.peers[b.session];
+      markDirty();
+      return json(res, 200, { ok: true, removed: !!peer });
+    }
     if (req.method === "POST" && P === "/register") {
       const b = await body(req);
       const cpg = crossProjectGuard(auth, P, b);

package/package.json

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