trantor 0.17.7 → 0.17.9

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.7"
+    "version": "0.17.9"
   },
   "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.7",
+      "version": "0.17.9",
       "author": {
         "name": "Sasha Bogojevic"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.7",
+  "version": "0.17.9",
   "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/hooks/hooks.json

@@ -1,11 +1,12 @@
 {
-  "description": "trantor — auto-register each session + inject live roster (SessionStart); heartbeat presence on every tool call so live sessions stay green and recover after sleep (PostToolUse); write a handoff before compaction (PreCompact)",
+  "description": "trantor — auto-register each session + inject live roster (SessionStart); heartbeat presence on every tool call + mirror the session's TodoWrite list onto the board as cards (PostToolUse); write a handoff before compaction (PreCompact)",
   "hooks": {
     "SessionStart": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/sessionstart.mjs" } ] }
     ],
     "PostToolUse": [
-      { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/heartbeat.mjs" } ] }
+      { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/heartbeat.mjs" } ] },
+      { "matcher": "TodoWrite", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/todo-sync.mjs" } ] }
     ],
     "PreCompact": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/precompact.mjs" } ] }

package/hooks/todo-sync.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+// trantor PostToolUse(TodoWrite) — mirror the session's todo list onto its project board as cards,
+// so SOLO work (no crew fired up) shows up live and accrues timeline history. The hub reconciles by
+// todo text (pending/in_progress/completed -> todo/doing/done). Fail-silent by contract: a bad hub,
+// a home-dir session, or any error must never block or break the tool flow.
+import { readFileSync, existsSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir, hostname } from "node:os";
+
+function relayUrl() {
+  if (process.env.RELAY_URL) return process.env.RELAY_URL;
+  try {
+    const cfg = join(homedir(), ".agent-bus", "config.json");
+    if (existsSync(cfg)) { const u = JSON.parse(readFileSync(cfg, "utf8")).url; if (u) return u; }
+  } catch {}
+  return "http://127.0.0.1:4477";
+}
+function readStdin() {
+  return new Promise(res => { let d = ""; process.stdin.setEncoding("utf8");
+    process.stdin.on("data", c => (d += c)); process.stdin.on("end", () => res(d));
+    setTimeout(() => res(d), 200); });
+}
+
+async function main() {
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  // Mirror sessionstart/heartbeat: home-directory sessions aren't project work — don't card them
+  // (would spawn a phantom "<username>" board). Opt in with RELAY_SESSION/RELAY_PROJECT.
+  if (!process.env.RELAY_SESSION && !process.env.RELAY_PROJECT && projectDir === homedir()) return;
+
+  let input = {};
+  try { input = JSON.parse((await readStdin()) || "{}"); } catch { return; }
+  if (input.tool_name && input.tool_name !== "TodoWrite") return;   // the matcher should scope us, but be safe
+  const todos = input.tool_input?.todos;
+  if (!Array.isArray(todos) || !todos.length) return;
+
+  // Identity EXACTLY as mcp.mjs/heartbeat resolve it, so we card the same peer the relay registered.
+  const project = process.env.RELAY_PROJECT || basename(projectDir);
+  const session = process.env.RELAY_SESSION
+    || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${project}` : `${hostname()}:${project}`);
+
+  try {
+    await fetch(`${relayUrl()}/todos`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ session, project, by: session, todos: todos.map(t => ({ content: t.content, status: t.status })) }),
+      signal: AbortSignal.timeout(1500),
+    });
+  } catch {}
+}
+
+// Never block or break the tool flow: swallow everything, always exit clean.
+main().catch(() => {}).finally(() => process.exit(0));

package/hub.mjs

@@ -50,11 +50,11 @@ function scanTelemetry() {
 
 // peers: { session: { lastSeen, status, project } } ; tasks: kanban cards
 // projectMeta: { project: { brief, by, updated } } — the "what & why" blurb per project
-let state = { messages: [], peers: {}, seq: 0, tasks: [], taskSeq: 0, projectMeta: {}, lessons: [], cardEvents: [] };
+let state = { messages: [], peers: {}, seq: 0, tasks: [], taskSeq: 0, projectMeta: {}, lessons: [], cardEvents: [], cardEventsBackfilled: false };
 try {
   if (existsSync(DATA)) {
     const loaded = JSON.parse(readFileSync(DATA, "utf8"));
-    state = { messages: loaded.messages || [], peers: {}, seq: loaded.seq || 0, tasks: loaded.tasks || [], taskSeq: loaded.taskSeq || 0, projectMeta: loaded.projectMeta || {}, lessons: loaded.lessons || [], cardEvents: Array.isArray(loaded.cardEvents) ? loaded.cardEvents : [] };
+    state = { messages: loaded.messages || [], peers: {}, seq: loaded.seq || 0, tasks: loaded.tasks || [], taskSeq: loaded.taskSeq || 0, projectMeta: loaded.projectMeta || {}, lessons: loaded.lessons || [], cardEvents: Array.isArray(loaded.cardEvents) ? loaded.cardEvents : [], cardEventsBackfilled: !!loaded.cardEventsBackfilled };
     for (const [s, v] of Object.entries(loaded.peers || {})) // migrate old numeric form
       state.peers[s] = typeof v === "number" ? { lastSeen: v, status: "", project: "" } : { lastSeen: v.lastSeen || 0, status: v.status || "", project: v.project || "" };
   }
@@ -62,6 +62,28 @@ try {
 let dirty = false;
 const persist = () => { if (dirty) { try { writeFileSync(DATA, JSON.stringify(state)); dirty = false; } catch {} } };
 setInterval(persist, 1000).unref?.();
+// One-time backfill: reconstruct the cardEvents history log from each card's authoritative per-card
+// `history` trail, so projects that existed BEFORE the cardEvents log show their FULL past in the
+// TIMELINE view (not just events from now on). Guarded by a flag so it runs once where cardEvents
+// persists; in team mode cardEvents is in-memory, so this re-derives from the persisted task.history
+// on every boot — which is exactly right.
+function backfillCardEvents() {
+  if (state.cardEventsBackfilled && state.cardEvents.length) return;
+  const events = [];
+  for (const t of (state.tasks || [])) for (const h of (t.history || [])) {
+    events.push({ ts: h.ts || 0, type: h.from ? "moved" : "created", taskId: t.id, project: t.project,
+      title: t.title, from: h.from || null, to: h.to || null, by: h.by || "",
+      difficulty: t.difficulty || null, assignee: t.assignee || null });
+  }
+  if (events.length) {
+    events.sort((a, b) => (a.ts || 0) - (b.ts || 0));
+    if (events.length > 5000) events.splice(0, events.length - 5000);
+    events.forEach((e, i) => { e.id = i + 1; });
+    state.cardEvents = events; dirty = true;
+  }
+  state.cardEventsBackfilled = true; dirty = true;
+}
+backfillCardEvents();
 function prunePeers() {
   const cutoff = now() - PEER_TTL_MS;
   let removed = false;
@@ -167,6 +189,44 @@ const server = http.createServer(async (req, res) => {
       appendCardEvent(eventType, t, b.by, eventFrom, eventTo);
       t.updated = now(); dirty = true; return json(res, 200, { ok: true, task: t });
     }
+    // Mirror a session's TodoWrite list onto its board as cards, so SOLO work (no crew) shows up live
+    // and accrues timeline history. pending/in_progress/completed -> todo/doing/done. Reconciled by
+    // todo text per session: present todos create/update; a vanished todo's card is deleted UNLESS it
+    // was already done (accomplished work stays in the DONE column). Posted by hooks/todo-sync.mjs.
+    if (req.method === "POST" && P === "/todos") {
+      const b = await body(req);
+      const session = String(b.session || b.by || "").slice(0, 120);
+      const project = String(b.project || "").slice(0, 80);
+      if (!session || !project) return json(res, 400, { error: "session and project required" });
+      touch(session, undefined, project);
+      const ST = { pending: "todo", in_progress: "doing", completed: "done" };
+      const todos = Array.isArray(b.todos) ? b.todos : [];
+      const mine = state.tasks.filter(t => t.source === "todo" && t.assignee === session && t.project === project);
+      const seen = new Set();
+      for (const todo of todos) {
+        const key = String(todo?.content || "").trim().slice(0, 200);
+        if (!key) continue;
+        seen.add(key);
+        const want = ST[todo.status] || "todo";
+        let t = mine.find(c => c.todoKey === key);
+        if (!t) {
+          t = { id: ++state.taskSeq, project, title: key, assignee: session, status: want, difficulty: "", model: "",
+            deps: [], by: session, ts: now(), updated: now(), source: "todo", todoKey: key,
+            history: [{ to: want, by: session, ts: now() }] };
+          state.tasks.push(t); appendCardEvent("created", t, session, null, want); dirty = true;
+        } else if (t.status !== want) {
+          (t.history ||= []).push({ from: t.status, to: want, by: session, ts: now() });
+          if (t.history.length > 40) t.history.splice(0, 10);
+          appendCardEvent("moved", t, session, t.status, want); t.status = want; t.updated = now(); dirty = true;
+        }
+      }
+      for (const t of mine) {
+        if (seen.has(t.todoKey) || t.status === "done") continue;   // keep accomplished work on the board
+        state.tasks = state.tasks.filter(x => x.id !== t.id); appendCardEvent("deleted", t, session, null, null); dirty = true;
+      }
+      if (state.tasks.length > 2000) state.tasks.splice(0, state.tasks.length - 2000);
+      return json(res, 200, { ok: true, count: todos.length });
+    }
     if (req.method === "GET" && P === "/tasks") {
       const proj = q.project; const ts = proj ? state.tasks.filter(t => t.project === proj) : state.tasks;
       return json(res, 200, { tasks: ts });

package/package.json

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