trantor 0.17.22 → 0.17.23

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + context-handoff for independent AI coding agents (Claude, Codex, Gemini, …)",
-    "version": "0.17.22"
+    "version": "0.17.23"
   },
   "plugins": [
     {
       "name": "trantor",
       "source": "./",
       "description": "The hub-world for AI agent crews. Say \"fire up the crew\" and Claude becomes the architect: a plan-aware Advisor routes the work (solo / cheap inline calls / live crew of Codex, Gemini, Kimi & DeepSeek in their own terminal windows), a Kanban/flow command center with a testing gate tracks it, and an economics brain (Scrooge) keeps the receipts. Includes the relay MCP, a SessionStart auto-discovery hook, and a PreCompact context-handoff so a fresh session can take over a full window instead of compacting.",
-      "version": "0.17.22",
+      "version": "0.17.23",
       "author": {
         "name": "Sasha Bogojevic"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.22",
+  "version": "0.17.23",
   "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/baton.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+// `trantor handoff` — one-command manual baton (auto-summary variant). Discovers the current session's
+// transcript, writes a whole-session handoff (auto-summary + verbatim in-flight tail), opens a fresh
+// self-announcing session, and closes THIS window once it takes over. Run from inside the session you
+// want to hand off. (The richer MODEL-authored handoff is the /trantor:handoff skill.)
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { resolveProject } from "../lib/project.mjs";
+import { writeHandoff, spawnBaton } from "../hooks/lib/handoff.mjs";
+
+const cwd = process.cwd();
+const project = resolveProject(cwd);
+
+// The active session's transcript = newest *.jsonl directly in this project's Claude dir
+// (~/.claude/projects/<cwd-with-slashes-as-dashes>/), excluding the subagents/ subtree.
+function findTranscript() {
+  const dashed = cwd.replace(/\//g, "-");
+  const base = join(homedir(), ".claude", "projects");
+  let best = "", bestM = 0;
+  let dirs = []; try { dirs = readdirSync(base).filter(d => d === dashed || d.endsWith(dashed)); } catch {}
+  for (const d of dirs) {
+    let ents = []; try { ents = readdirSync(join(base, d)); } catch {}
+    for (const f of ents) {
+      if (!f.endsWith(".jsonl")) continue;
+      try { const m = statSync(join(base, d, f)).mtimeMs; if (m > bestM) { best = join(base, d, f); bestM = m; } } catch {}
+    }
+  }
+  return best;
+}
+
+const transcript = findTranscript();
+const { file } = writeHandoff({ projectDir: cwd, sessionId: "", transcript, trigger: "manual-cli" });
+console.log(`📋 handoff saved for ${project}: ${file}`);
+const { spawned, armed, windowId } = spawnBaton({ projectDir: cwd, handoffFile: file });
+console.log(spawned
+  ? `🔄 baton: a fresh session is opening (it'll recap the handoff)${armed ? ` — this window (${windowId}) closes once it takes over` : " — couldn't detect this window; close it yourself once the new one is up"}`
+  : `handoff saved, but couldn't spawn a fresh session (non-macOS or spawn disabled) — open a new session here to take over`);

package/bin/cli.mjs

@@ -27,6 +27,7 @@ switch (cmd) {
   case "watch":   run("bin/relay-watch.mjs"); break;
   case "catchup": run("bin/catchup.mjs"); break;
   case "backfill": run("bin/git-backfill.mjs"); break;
+  case "handoff": run("bin/baton.mjs"); break;
   case "ui": {
     let url = "http://127.0.0.1:4477";
     try { url = JSON.parse(readFileSync(join(process.env.HOME || "", ".agent-bus", "config.json"), "utf8")).url || url; } catch {}
@@ -48,6 +49,7 @@ switch (cmd) {
   trantor ui          open the live dashboard (board + flow views)
   trantor catchup     "where are we?" — the continuous board + git, with a synthesized brief
   trantor backfill    card past GIT work onto the board (solo commits that were never carded) — [--since "14 days ago"] [--dry-run]
+  trantor handoff     finish this session NOW: write a handoff, open a fresh session that takes over, and close this one (manual baton)
   trantor advise      ask the Advisor directly (JSON on stdin; --demo to see it)
   trantor hub         run the hub in the foreground (setup installs it as a service instead)
   trantor watch       live bus feed in the terminal

package/bin/write-handoff.mjs

@@ -1,17 +1,29 @@
 #!/usr/bin/env node
-import { writeFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+// Save a model-authored handoff (piped on stdin) for this project; the next session auto-loads it.
+// With --baton: ALSO open a fresh self-announcing session and close THIS window once it takes over
+// (the one-command manual baton behind /trantor:handoff). Without it: just write the file (legacy).
+import { writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join, basename } from "node:path";
 import { homedir, hostname } from "node:os";
 import { execSync } from "node:child_process";
+import { spawnBaton } from "../hooks/lib/handoff.mjs";
+
+const baton = process.argv.includes("--baton");
 const project = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 const name = basename(project);
 let summary = ""; process.stdin.setEncoding("utf8");
 for await (const c of process.stdin) summary += c;
 const dir = join(homedir(), ".agent-bus", "handoffs");
 if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-const stamp = (() => { try { return execSync("date +%s",{encoding:"utf8"}).trim(); } catch { return String(process.pid); } })();
-let git=""; try { git = execSync("git -C "+JSON.stringify(project)+" status --short 2>/dev/null | head -30",{encoding:"utf8"}).trim(); } catch {}
-const rec = { id:`${name}-${stamp}`, project, projectName:name, machine:hostname(), trigger:"manual-skill", stamp:Number(stamp)||0, summary:summary.trim()||"(empty)", gitStatus:git, consumed:false };
+const stamp = (() => { try { return execSync("date +%s", { encoding: "utf8" }).trim(); } catch { return String(process.pid); } })();
+let git = ""; try { git = execSync("git -C " + JSON.stringify(project) + " status --short 2>/dev/null | head -30", { encoding: "utf8" }).trim(); } catch {}
+const rec = { id: `${name}-${stamp}`, project, projectName: name, machine: hostname(), trigger: baton ? "manual-baton" : "manual-skill", stamp: Number(stamp) || 0, summary: summary.trim() || "(empty)", gitStatus: git, consumed: false };
 const file = join(dir, `${rec.id}.json`);
-writeFileSync(file, JSON.stringify(rec,null,2));
+writeFileSync(file, JSON.stringify(rec, null, 2));
 console.log(`handoff saved: ${file}`);
+
+if (baton) {
+  const { spawned, armed, windowId } = spawnBaton({ projectDir: project, handoffFile: file });
+  if (spawned) console.log(`baton: fresh session opening (self-recapping)${armed ? ` — this window (${windowId}) closes once it takes over` : " — original window left open (couldn't detect it)"}`);
+  else console.log(`baton: could not spawn a fresh session (non-macOS or spawn disabled) — handoff saved, open a new session manually`);
+}

package/hooks/lib/handoff.mjs

@@ -274,3 +274,41 @@ export function maybeSpawn(projectDir, conf = readConfig()) {
     return true;
   } catch (e) { process.stderr.write(`[trantor] maybeSpawn error: ${e?.message}\n`); return false; }
 }
+
+// The self-announcing fresh session command (single-quoted so it survives osascript→shell un-escaped).
+export const RECAP_CMD = "claude 'Recap the handoff you just took over — what was the previous session doing, and where do we continue? Then wait for me.'";
+
+// Spawn a fresh self-announcing session WITHOUT the dialog (manual handoff — the user already decided).
+export function spawnFresh(projectDir) {
+  try {
+    if (process.platform !== "darwin" || process.env.TRANTOR_NO_HANDOFF_SPAWN === "1") return false;
+    const script = join(HERE, "..", "..", "bin", "open-session.sh");
+    if (!existsSync(script)) return false;
+    const child = spawn("/bin/bash", [script, projectDir, RECAP_CMD], { detached: true, stdio: "ignore" });
+    child.unref();
+    return true;
+  } catch { return false; }
+}
+
+// Terminal.app's front window (id + tty) — the fallback when there's no controlling tty (a manual
+// handoff runs through the headless Bash tool). The session you're looking at when you invoke it.
+export function frontTerminalWindow() {
+  if (process.platform !== "darwin") return { id: "", tty: "" };
+  try {
+    const out = execSync(`osascript -e ${JSON.stringify(`tell application "Terminal" to return (id of front window as string) & "|" & (tty of selected tab of front window)`)}`,
+      { encoding: "utf8", timeout: 3000 }).trim();
+    const [id, tty] = out.split("|"); return { id: id || "", tty: tty || "" };
+  } catch { return { id: "", tty: "" }; }
+}
+
+// MANUAL one-command baton: spawn the fresh session (no dialog) + arm the close of THIS window once the
+// fresh one consumes the handoff. Window detection: controlling tty first (if invoked with one), else
+// Terminal's front window. Returns { spawned, armed }.
+export function spawnBaton({ projectDir, handoffFile, conf = readConfig() }) {
+  const spawned = spawnFresh(projectDir);
+  if (!spawned) return { spawned: false, armed: false };
+  let tty = controllingTty(), windowId = tty ? terminalWindowForTty(tty) : "";
+  if (!windowId) { const f = frontTerminalWindow(); windowId = f.id; tty = f.tty; }
+  const armed = windowId ? armBatonClose(handoffFile, windowId, tty, conf) : false;
+  return { spawned, armed, windowId };
+}

package/package.json

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

package/skills/handoff/SKILL.md

@@ -1,9 +1,10 @@
 ---
 name: handoff
 description: |
-  Write a rich handoff for the CURRENT session so a fresh Claude Code session can take over
-  with a full new context window (instead of compacting). Use proactively when context is
-  getting full, or before ending, to pass the baton cleanly. Trigger: /trantor:handoff
+  Finish the CURRENT session in one move: write a rich model-authored handoff, open a fresh
+  full-window session that takes over (it auto-recaps the handoff), and close this one once the
+  fresh session has it — a clean baton pass, one session at a time. Use when you want to wrap up
+  and continue fresh on demand (not just at the compaction threshold). Trigger: /trantor:handoff
 user-invocable: true
 ---
 
@@ -23,14 +24,17 @@ re-deriving context, and save it so the next session in this project auto-loads
    - **KEY FILES & LOCATIONS** — exact paths, commands, URLs, IDs the successor needs
    - **GOTCHAS** — anything that will bite if forgotten
 
-2. Save it by piping the markdown to the helper:
+2. Save it AND pass the baton in one shot — pipe the markdown to the helper with `--baton`:
    ```bash
-   cat << 'HANDOFF' | node "$(dirname "$(command -v claude)")/../<plugin>/bin/write-handoff.mjs"
+   cat << 'HANDOFF' | node "${CLAUDE_PLUGIN_ROOT}/bin/write-handoff.mjs" --baton
    <your handoff markdown>
    HANDOFF
    ```
-   (Or call the plugin's `bin/write-handoff.mjs` directly via its `${CLAUDE_PLUGIN_ROOT}`.)
+   `--baton` writes the handoff, opens a FRESH session that takes over (it auto-recaps the handoff
+   on open), and closes THIS Terminal window once the fresh session has consumed it — a true baton
+   pass, one session at a time. (Omit `--baton` to only write the handoff without spawning/closing.)
+   It's safe: the original window is closed ONLY after the fresh session confirms it took over, and
+   never if the fresh session fails to start.
 
-3. Tell the user: open a fresh terminal + `claude` in this same project directory — the
-   SessionStart hook will detect the handoff and the new session takes over with a full window.
-   (The PreCompact hook also writes one automatically at the compaction threshold.)
+3. Tell the user briefly: "Handoff written — a fresh session is opening and will recap it; this
+   window closes once it takes over." Then stop (the baton will close this session shortly).