trantor 0.17.5 → 0.17.7

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.5",
+  "version": "0.17.7",
   "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/doctor.mjs

@@ -19,7 +19,7 @@ let issues = 0;
 
 console.log("TRANTOR DOCTOR\n");
 
-// runtime + hub
+// runtime + hub + client version
 console.log("core");
 Number(process.versions.node.split(".")[0]) >= 18 ? ok(`node ${process.versions.node}`) : warn(`node ${process.versions.node} too old`, "install node >= 18");
 const cfg = read(join(H, ".agent-bus", "config.json")) || {};
@@ -31,6 +31,15 @@ try {
   warn(`hub not reachable at ${HUB}`, `bash ${join(ROOT, "deploy", "setup.sh")}   # installs the always-on service`);
 }
 
+// version — heartbeat/presence support
+const pkg = read(join(ROOT, "package.json"));
+if (pkg?.version) {
+  const min = [0, 17, 0];
+  const cur = pkg.version.split(".").map(Number);
+  const tooOld = cur[0] < min[0] || (cur[0] === min[0] && (cur[1] < min[1] || (cur[1] === min[1] && cur[2] < min[2])));
+  tooOld ? warn(`trantor v${pkg.version} too old — heartbeat/presence requires v0.17.0+`, "npm update -g trantor") : ok(`trantor v${pkg.version}`);
+} else warn("could not read trantor version", "reinstall: npm install -g trantor");
+
 // claude plugin
 console.log("\nclaude (the orchestrator)");
 if (!has("claude")) warn("claude CLI not found", "install Claude Code: https://claude.com/claude-code");

package/hooks/sessionstart.mjs

@@ -69,11 +69,13 @@ try {
     process.stdout.write("{}");
     process.exit(0);
   }
-  const session = process.env.RELAY_SESSION || `${hostname()}:${basename(projectDir)}`;
+  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}`);
   const url = relayUrl();
 
   // register self + post an initial presence status (no LLM turn — instant for others to read)
-  await jpost(`${url}/register`, { session, project: basename(projectDir), status: `active in ${basename(projectDir)}` }).catch(() => {});
+  await jpost(`${url}/register`, { session, project, status: `active in ${project}` }).catch(() => {});
 
   // fetch roster of OTHER online sessions
   let peers = [];

package/hub.mjs

@@ -14,6 +14,9 @@ const HOST = process.env.RELAY_HOST || "127.0.0.1";
 const DATA_DIR = process.env.RELAY_DATA_DIR || join(homedir(), ".agent-bus");
 const DATA = join(DATA_DIR, "bus.json");
 const ONLINE_MS = Number(process.env.RELAY_ONLINE_MS || 5 * 60 * 1000);
+const PEER_TTL_DEFAULT_MS = 21600000; // 6h
+const _peerTtlRaw = Number(process.env.RELAY_PEER_TTL_MS || PEER_TTL_DEFAULT_MS);
+const PEER_TTL_MS = Math.max(Number.isFinite(_peerTtlRaw) ? _peerTtlRaw : PEER_TTL_DEFAULT_MS, ONLINE_MS);
 if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
 
 // Scrooge ledger cache: /economics is polled every ~15s by the dashboard, but the ledger
@@ -47,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: [] };
+let state = { messages: [], peers: {}, seq: 0, tasks: [], taskSeq: 0, projectMeta: {}, lessons: [], cardEvents: [] };
 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 || [] };
+    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 : [] };
     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 || "" };
   }
@@ -59,6 +62,15 @@ try {
 let dirty = false;
 const persist = () => { if (dirty) { try { writeFileSync(DATA, JSON.stringify(state)); dirty = false; } catch {} } };
 setInterval(persist, 1000).unref?.();
+function prunePeers() {
+  const cutoff = now() - PEER_TTL_MS;
+  let removed = false;
+  for (const [session, peer] of Object.entries(state.peers)) {
+    if ((peer.lastSeen || 0) < cutoff) { delete state.peers[session]; removed = true; }
+  }
+  if (removed) dirty = true;
+}
+setInterval(prunePeers, 60000).unref?.();
 
 // dashboard HTML (read once at startup)
 let UI = "";
@@ -93,6 +105,23 @@ function deliverable(m, session) { return (m.to === session || m.to === "all") &
 function pushToStreams(msg) {
   for (const s of streams) if (deliverable(msg, s.session)) { try { s.res.write(`data: ${JSON.stringify(msg)}\n\n`); } catch {} }
 }
+function appendCardEvent(type, task, by, from = null, to = null) {
+  const last = state.cardEvents[state.cardEvents.length - 1];
+  state.cardEvents.push({
+    id: (last?.id || 0) + 1,
+    ts: now(),
+    type,
+    taskId: task.id,
+    project: task.project,
+    title: task.title,
+    from,
+    to,
+    by: by || "",
+    difficulty: task.difficulty || null,
+    assignee: task.assignee || null,
+  });
+  if (state.cardEvents.length > 5000) state.cardEvents.splice(0, state.cardEvents.length - 5000);
+}
 
 const server = http.createServer(async (req, res) => {
   const u = new URL(req.url, "http://x"); const q = Object.fromEntries(u.searchParams); const P = u.pathname;
@@ -100,6 +129,7 @@ const server = http.createServer(async (req, res) => {
     if (req.method === "POST" && P === "/register") { const b = await body(req); touch(b.session, b.status, b.project); return json(res, 200, { ok: true, session: b.session, peers: Object.keys(state.peers) }); }
     if (req.method === "POST" && P === "/status") { const b = await body(req); touch(b.session, b.status ?? "", b.project); return json(res, 200, { ok: true }); }
     if (req.method === "GET" && P === "/peers") {
+      prunePeers();
       const cutoff = now() - ONLINE_MS;
       return json(res, 200, { peers: Object.entries(state.peers).map(([s, v]) => ({ session: s, lastSeen: v.lastSeen, online: v.lastSeen > cutoff, status: v.status || "", health: healthOf(v.status), project: v.project || "" })) });
     }
@@ -115,12 +145,15 @@ const server = http.createServer(async (req, res) => {
         by: b.by || "", ts: now(), updated: now(),
         history: [{ to: st0, by: b.by || "", ts: now() }] };
       state.tasks.push(t); if (state.tasks.length > 2000) state.tasks.splice(0, 500);
+      appendCardEvent("created", t, b.by, null, st0);
       dirty = true; return json(res, 200, { ok: true, task: t });
     }
     if (req.method === "POST" && P === "/task/update") {    // move/edit a card
       const b = await body(req); const t = state.tasks.find(x => x.id === Number(b.id));
       if (!t) return json(res, 404, { error: "no such task" });
+      let eventType = "updated", eventFrom = null, eventTo = null;
       if (b.status && ["todo","doing","testing","failed","done","blocked"].includes(b.status) && b.status !== t.status) {
+        eventType = "moved"; eventFrom = t.status; eventTo = b.status;
         (t.history ||= []).push({ from: t.status, to: b.status, by: b.by || "", ts: now() });
         if (t.history.length > 40) t.history.splice(0, 10);
         t.status = b.status;
@@ -130,13 +163,20 @@ const server = http.createServer(async (req, res) => {
       if (Array.isArray(b.deps)) t.deps = [...new Set(b.deps.map(Number).filter(n => Number.isInteger(n) && n > 0 && n !== t.id))].slice(0, 20);
       if (b.assignee !== undefined) t.assignee = b.assignee;
       if (b.title !== undefined) t.title = String(b.title).slice(0,200);
-      if (b.delete) state.tasks = state.tasks.filter(x => x.id !== t.id);
+      if (b.delete) { eventType = "deleted"; eventFrom = null; eventTo = null; state.tasks = state.tasks.filter(x => x.id !== t.id); }
+      appendCardEvent(eventType, t, b.by, eventFrom, eventTo);
       t.updated = now(); dirty = true; return json(res, 200, { ok: true, task: t });
     }
     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 });
     }
+    if (req.method === "GET" && P === "/history") {
+      const requestedLimit = Number(q.limit || 200);
+      const limit = Math.min(Math.max(Number.isFinite(requestedLimit) ? requestedLimit : 200, 0), 1000);
+      const events = (q.project ? state.cardEvents.filter(e => e.project === q.project) : state.cardEvents).slice(-limit);
+      return json(res, 200, { events });
+    }
     if (req.method === "POST" && P === "/project") {        // set a project's brief (what & why)
       const b = await body(req); const k = String(b.project || "").slice(0, 80);
       if (!k) return json(res, 400, { error: "project required" });
@@ -158,6 +198,7 @@ const server = http.createServer(async (req, res) => {
       return json(res, 200, { ok: true, project: k, removed: { tasks: nt - state.tasks.length, peers: np - Object.keys(state.peers).length, messages: nm - state.messages.length } });
     }
     if (req.method === "GET" && P === "/projects") {        // project-grouped view
+      prunePeers();
       const cutoff = now() - ONLINE_MS; const byProj = {};
       const proj = p => p || "(unassigned)";
       const mk = k => (byProj[k] ||= { project: k, brief: (state.projectMeta[k]?.brief) || "", agents: [], tasks: { todo:0,doing:0,testing:0,failed:0,done:0,blocked:0 }, doingTitles: [], lastActivity: 0 });
@@ -250,7 +291,8 @@ const server = http.createServer(async (req, res) => {
       // ts must not throw (new Date(NaN).toISOString() does) and 500 the whole endpoint — return null
       // and let callers skip that day-bucket.
       const dayOf = ts => { const n = Number(ts); if (!n) return null; const d = new Date(n > 2e10 ? n : n * 1000); return Number.isNaN(d.getTime()) ? null : d.toISOString().slice(0, 10); };
-      const out = { totals: {}, lessons: { global: [], byAgent: {}, byProject: {}, projects: [] }, agents: [], models: [] };
+      const ALL = "*";   // the cross-project ("All projects") bucket
+      const out = { totals: {}, lessons: { global: [], byAgent: {}, byProject: {}, projects: [] }, agents: [], agentsByProject: {}, models: [], modelsByProject: {} };
 
       // relay lessons → global / by-agent / by-project (project derived from the recorder's session id)
       const projSet = new Set();
@@ -259,55 +301,76 @@ const server = http.createServer(async (req, res) => {
         if (l.scope === "global") out.lessons.global.push(rec); else (out.lessons.byAgent[l.scope] ||= []).push(rec);
         if (rec.project) { (out.lessons.byProject[rec.project] ||= []).push(rec); projSet.add(rec.project); }
       }
-      out.lessons.projects = [...projSet].sort();
 
-      // per-LLM reliability from turn telemetry: turns, failures (exit!=0), daily fail-rate series
+      // per-LLM reliability from turn telemetry, bucketed BY PROJECT (+ a global ALL bucket) so the
+      // sidebar's project filter scopes the charts. Each turn carries its own project.
       const turns = scanTelemetry();
-      const byAgent = {}; let totalTurns = 0, totalFails = 0; const modelsSeen = new Set();
-      for (const t of turns) {
-        const a = (byAgent[t.agent] ||= { agent: t.agent, turns: 0, failures: 0, models: new Set(), lastFailure: null, days: {} });
-        a.turns++; totalTurns++;
-        if (t.model) { a.models.add(t.model); if (t.model !== "default") modelsSeen.add(t.model); }
+      const relAgg = {};       // scope -> agent -> {turns,failures,models:Set,lastFailure,days}
+      const scopeModels = {};  // scope -> Set(model used)
+      let totalTurns = 0, totalFails = 0;
+      const bumpRel = (scope, t) => {
+        const a = ((relAgg[scope] ||= {})[t.agent] ||= { agent: t.agent, turns: 0, failures: 0, models: new Set(), lastFailure: null, days: {} });
+        a.turns++;
+        if (t.model) { a.models.add(t.model); if (t.model !== "default") (scopeModels[scope] ||= new Set()).add(t.model); }
         const dk = dayOf(t.ts); const d = dk ? (a.days[dk] ||= { turns: 0, failures: 0 }) : null; if (d) d.turns++;
-        if (t.exit && t.exit !== 0) { a.failures++; totalFails++; if (d) d.failures++; if (!a.lastFailure || t.ts > a.lastFailure.ts) a.lastFailure = { ts: t.ts, exit: t.exit, project: t.project || "" }; }
+        if (t.exit && t.exit !== 0) { a.failures++; if (d) d.failures++; if (!a.lastFailure || t.ts > a.lastFailure.ts) a.lastFailure = { ts: t.ts, exit: t.exit, project: t.project || "" }; }
+      };
+      for (const t of turns) {
+        if (!t.agent) continue;
+        totalTurns++; if (t.exit && t.exit !== 0) totalFails++;
+        bumpRel(ALL, t);
+        if (t.project) { bumpRel(t.project, t); projSet.add(t.project); }
       }
-      // lessons-accumulated-over-time per agent scope (relay lessons carry a ts; skip the unstamped older ones)
-      const lessonDays = {};
-      for (const l of state.lessons) { const d = dayOf(l.ts); if (!d) continue; (lessonDays[l.scope] ||= {}); lessonDays[l.scope][d] = (lessonDays[l.scope][d] || 0) + 1; }
-      out.agents = Object.values(byAgent).sort((a, b) => b.turns - a.turns).map(a => {
-        const days = Object.keys(a.days).sort();
-        let cum = 0; const ld = lessonDays[a.agent] || {};
-        return {
-          agent: a.agent, turns: a.turns, failures: a.failures, failRate: a.turns ? +(a.failures / a.turns).toFixed(3) : 0,
+      // lessons-accumulated-over-time per scope -> agent brand -> day (agent-scoped lessons only)
+      const lessonAgg = {};
+      for (const l of state.lessons) {
+        if (l.scope === "global") continue; const d = dayOf(l.ts); if (!d) continue;
+        const bump = scope => { (((lessonAgg[scope] ||= {})[l.scope] ||= {})[d]) = (lessonAgg[scope][l.scope][d] || 0) + 1; };
+        bump(ALL); const p = projOf(l.by); if (p) bump(p);
+      }
+      const buildAgents = scope => Object.values(relAgg[scope] || {}).sort((a, b) => b.turns - a.turns).map(a => {
+        const days = Object.keys(a.days).sort(); let cum = 0; const ld = (lessonAgg[scope] || {})[a.agent] || {};
+        return { agent: a.agent, turns: a.turns, failures: a.failures, failRate: a.turns ? +(a.failures / a.turns).toFixed(3) : 0,
           lastFailure: a.lastFailure, models: [...a.models],
           series: {
             failRate: days.map(d => ({ day: d, turns: a.days[d].turns, failures: a.days[d].failures, rate: a.days[d].turns ? +(a.days[d].failures / a.days[d].turns).toFixed(3) : 0 })),
             lessons: Object.keys(ld).sort().map(d => ({ day: d, count: (cum += ld[d]) })),
-          },
-        };
+          } };
       });
 
-      // Scrooge guardrails (per model → per task) + per-model economics from the cached ledger
+      // Scrooge guardrails (global per model) + per-model economics from the ledger, bucketed by project
       let guard = {}; try { guard = JSON.parse(readFileSync(join(homedir(), ".token-scrooge", "lessons.json"), "utf8")) || {}; } catch {}
       try { const lp = join(homedir(), ".token-scrooge", "calls.jsonl"); const st = statSync(lp); if (st.mtimeMs !== _ledgerCache.mtimeMs) { const rows = readFileSync(lp, "utf8").trim().split("\n").map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(c => c && c.ok); _ledgerCache = { mtimeMs: st.mtimeMs, rows }; } } catch {}
-      const ledgerByModel = {};
-      for (const c of _ledgerCache.rows) {
-        const m = (ledgerByModel[c.model] ||= { calls: 0, ti: 0, to: 0, cost: 0, days: {} });
+      const ledAgg = {};   // scope -> model -> {calls,ti,to,cost,days}
+      const bumpLed = (scope, c) => {
+        const m = ((ledAgg[scope] ||= {})[c.model] ||= { calls: 0, ti: 0, to: 0, cost: 0, days: {} });
         m.calls++; m.ti += c.tokens_in || 0; m.to += c.tokens_out || 0; m.cost += c.cost_usd || 0;
         const dk = dayOf(c.ts); if (dk) { const d = (m.days[dk] ||= { cost: 0, ti: 0, to: 0 }); d.cost += c.cost_usd || 0; d.ti += c.tokens_in || 0; d.to += c.tokens_out || 0; }
-      }
+        (scopeModels[scope] ||= new Set()).add(c.model);
+      };
+      for (const c of _ledgerCache.rows) { if (!c.model) continue; bumpLed(ALL, c); if (c.project) { bumpLed(c.project, c); projSet.add(c.project); } }
+
       const savedOf = (ti, to, cost) => +Math.max(0, ti * 15 / 1e6 + to * 75 / 1e6 - cost).toFixed(2);
       let totalGuardrails = 0;
-      const mkModel = (model, g) => {
+      const mkModel = (scope, model, g) => {
         const gcount = Object.values(g || {}).reduce((s, arr) => s + (Array.isArray(arr) ? arr.length : 0), 0);
-        totalGuardrails += gcount; const lm = ledgerByModel[model];
+        if (scope === ALL) totalGuardrails += gcount;   // guardrails are global — count once
+        const lm = (ledAgg[scope] || {})[model];
         return { model, guardrails: g || {}, guardrailCount: gcount, calls: lm ? lm.calls : 0, cost_usd: lm ? +lm.cost.toFixed(4) : 0,
           saved_usd: lm ? savedOf(lm.ti, lm.to, lm.cost) : 0,
           series: { saved: lm ? Object.keys(lm.days).sort().map(d => ({ day: d, saved: savedOf(lm.days[d].ti, lm.days[d].to, lm.days[d].cost) })) : [] } };
       };
-      const modelKeys = new Set([...Object.keys(guard).filter(k => k !== "*"), ...Object.keys(ledgerByModel), ...modelsSeen]);
-      out.models = [...modelKeys].sort().map(m => mkModel(m, guard[m]));
-      if (guard["*"]) out.models.unshift(mkModel("∗ all models", guard["*"]));   // guardrails that apply to every model
+      const buildModels = scope => {
+        const keys = new Set(scopeModels[scope] || []);          // models used in this scope
+        if (scope === ALL) for (const k of Object.keys(guard)) if (k !== "*") keys.add(k);   // global view also lists every guardrailed model
+        const arr = [...keys].sort().map(m => mkModel(scope, m, guard[m]));
+        if (guard["*"]) arr.unshift(mkModel(scope, "∗ all models", guard["*"]));   // guardrails that apply to every model
+        return arr;
+      };
+
+      out.lessons.projects = [...projSet].sort();
+      out.agents = buildAgents(ALL); out.models = buildModels(ALL);
+      for (const p of out.lessons.projects) { out.agentsByProject[p] = buildAgents(p); out.modelsByProject[p] = buildModels(p); }
 
       out.totals = { lessons: state.lessons.length, guardrails: totalGuardrails, turns: totalTurns, failures: totalFails, failRate: totalTurns ? +(totalFails / totalTurns).toFixed(3) : 0, models: out.models.length };
       return json(res, 200, out);

package/mcp.mjs

@@ -161,19 +161,32 @@ server.tool("relay_wait", "Block up to `timeout` seconds waiting for the next me
     return { content: [{ type: "text", text: messages.length ? messages.map(fmt).join("\n") : "(timed out, no message)" }] };
   });
 
-await api("POST", "/register", { session: SESSION, project: PROJECT, status: `active in ${PROJECT}` }).catch(() => {});
-
-// Heartbeat — keep this session's presence fresh for as long as the MCP process lives.
-// Registration alone decays after the hub's online window (5 min); without this, idle agents
-// — and EVERY agent after the laptop sleeps (dead connection, no resume event) — fall off the
-// board while their process is still alive. This is the UNIVERSAL counterpart to the Claude-only
-// PostToolUse heartbeat hook: it runs inside the relay every agent loads (Claude, codex, gemini,
-// kimi, deepseek), so the whole crew stays tracked. We POST /register with NO status, so the
-// hub refreshes lastSeen but preserves the session's meaningful status. setInterval pauses during
-// sleep and fires on wake, so presence self-heals within one interval; .unref() lets the process
-// still exit cleanly when the agent closes the stdio transport (no phantom peers).
 const HEARTBEAT_MS = Number(process.env.RELAY_HEARTBEAT_MS || 60 * 1000);
-setInterval(() => { api("POST", "/register", { session: SESSION, project: PROJECT }).catch(() => {}); }, HEARTBEAT_MS).unref?.();
+
+// Mirror the SessionStart/PostToolUse hooks: a session opened in the home directory itself
+// isn't project work — auto-registering it would spawn a phantom "<username>" project board.
+// Opt in explicitly with RELAY_SESSION or RELAY_PROJECT. The MCP server still starts so the
+// user can call relay tools (e.g. relay_whoami) deliberately; we just skip auto-presence.
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const isHomeDirSession = !process.env.RELAY_SESSION && !process.env.RELAY_PROJECT && projectDir === homedir();
+
+if (!isHomeDirSession) {
+  await api("POST", "/register", { session: SESSION, project: PROJECT, status: `active in ${PROJECT}` })
+    .catch((err) => { process.stderr.write(`[trantor-mcp] initial register failed: ${err?.message || err}\n`); });
+
+  // Heartbeat — keep this session's presence fresh for as long as the MCP process lives.
+  // Registration alone decays after the hub's online window (5 min); without this, idle agents
+  // — and EVERY agent after the laptop sleeps (dead connection, no resume event) — fall off the
+  // board while their process is still alive. This is the UNIVERSAL counterpart to the Claude-only
+  // PostToolUse heartbeat hook: it runs inside the relay every agent loads (Claude, codex, gemini,
+  // kimi, deepseek), so the whole crew stays tracked. We POST /register with NO status, so the
+  // hub refreshes lastSeen but preserves the session's meaningful status. setInterval pauses during
+  // sleep and fires on wake, so presence self-heals within one interval; .unref() lets the process
+  // still exit cleanly when the agent closes the stdio transport (no phantom peers).
+  setInterval(() => { api("POST", "/register", { session: SESSION, project: PROJECT }).catch(() => {}); }, HEARTBEAT_MS).unref?.();
+} else {
+  process.stderr.write("[trantor-mcp] home directory — not auto-registering on the bus (set RELAY_SESSION or RELAY_PROJECT to opt in)\n");
+}
 
 await server.connect(new StdioServerTransport());
-process.stderr.write(`[trantor-mcp] connected as ${SESSION} -> ${URL_BASE} (heartbeat ${HEARTBEAT_MS}ms)\n`);
+process.stderr.write(`[trantor-mcp] connected as ${SESSION} -> ${URL_BASE}${isHomeDirSession ? " (no auto-presence: home dir)" : ` (heartbeat ${HEARTBEAT_MS}ms)`}\n`);

package/package.json

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

package/ui.html

@@ -140,6 +140,19 @@ main:not(.learn-open) .learn-body{display:none}
 .felabel{fill:#7e8ca3;font-size:9px;font-family:ui-monospace,monospace;opacity:0;pointer-events:none;transition:opacity .15s}
 .fe:hover .felabel{opacity:1}
 .fe:hover .fedge{stroke:#5fa8ff}
+/* timeline view */
+.timeline{padding:14px 18px;overflow-y:auto;max-height:66vh;display:flex;flex-direction:column;gap:5px;background:#0c111c;border-top:1px solid var(--line)}
+.tevent{font-size:12.5px;line-height:1.4;color:var(--mut);display:flex;align-items:center;gap:7px;padding:4px 0}
+.tevent .tts{font-family:ui-monospace,monospace;font-size:10px;color:var(--dim);min-width:64px}
+.tevent .tphrase b{color:var(--tx)}
+.tevent .tstatus{font-weight:700;font-size:11px;text-transform:uppercase;letter-spacing:.04em}
+.tevent .tstatus.todo{color:var(--mut)}
+.tevent .tstatus.doing{color:var(--blu)}
+.tevent .tstatus.testing{color:var(--amb)}
+.tevent .tstatus.failed{color:var(--red)}
+.tevent .tstatus.done{color:var(--grn)}
+.tevent .tstatus.blocked{color:var(--red)}
+.tevent .arr{color:var(--dim);margin:0 2px}
 /* per-project inter-agent conversation lane */
 .proj-chat{margin:4px 16px 14px;border:1px solid var(--line);border-radius:10px;background:#0c111c}
 .proj-chat h5{margin:0;padding:7px 11px;font-size:10px;text-transform:uppercase;letter-spacing:.09em;color:var(--dim);border-bottom:1px solid var(--line);display:flex;align-items:center;gap:6px}
@@ -250,6 +263,7 @@ async function econ(){
 econ();setInterval(econ,15000);
 function poolOf(session){const b=brandOf(session);const k=b==='anthropic'?'claude':b==='openai'?'codex':b==='moonshot'?'kimi':b;return POOLS[k]||'';}
 const VIEWS = JSON.parse(localStorage.getItem("abViews") || "{}");
+let HISTORY = {};
 function setView(proj, v){ VIEWS[proj] = v; localStorage.setItem("abViews", JSON.stringify(VIEWS)); render(); }
 function toggleIdle(name){ if(!name)return; const s=new Set(JSON.parse(localStorage.getItem("abIdleOpen")||"[]")); s.has(name)?s.delete(name):s.add(name); localStorage.setItem("abIdleOpen",JSON.stringify([...s])); render(); }
 let armedDel=null,armedTs=0;   // pending ✕ confirmation (project name + when it was armed)
@@ -405,6 +419,19 @@ function wireFlow(el){
 }
 let suppressClickId = null;
 function projOf(m){return m.project||(String(m.from).includes(':')?String(m.from).split(':').pop():'');}
+function timelineHTML(proj) {
+  const events = HISTORY[proj] || [];
+  if (!events.length) return '<div class="timeline empty">no history yet</div>';
+  const rows = events.map(e => {
+    const time = new Date(e.ts).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' });
+    let phrase = "";
+    if (e.type === "created") phrase = `created "<b>${esc(e.title)}</b>" as <span class="tstatus ${esc(e.to)}">${esc(e.to)}</span>`;
+    else if (e.type === "moved") phrase = `moved "<b>${esc(e.title)}</b>" <span class="tstatus ${esc(e.from)}">${esc(e.from)}</span> <span class="arr">→</span> <span class="tstatus ${esc(e.to)}">${esc(e.to)}</span>`;
+    else phrase = `${esc(e.type)} "<b>${esc(e.title)}</b>"`;
+    return `<div class="tevent"><span class="tts">${time}</span>${iconFor(e.by, 13)} <span class="tphrase">${phrase}</span> <span class="dim">by @${esc(String(e.by).split(':')[0])}</span></div>`;
+  }).join('');
+  return `<div class="timeline" data-proj="${esc(proj)}">${rows}</div>`;
+}
 function chatLane(msgs){
   if(!msgs.length)return `<div class="proj-chat"><h5><span class="lc"></span>conversation</h5><div class="chatempty">no messages yet — agents talk here as they coordinate</div></div>`;
   const rows=msgs.slice(-8).map(m=>`<div class="cmsg ${m.to==='all'?'bc':''}"><span class="ct">${new Date(m.ts).toLocaleTimeString([],{hour:'2-digit',minute:'2-digit'})}</span>${iconFor(m.from,13)}<span class="cf">${esc(String(m.from).split(':')[0])}</span><span class="arr">→</span><span class="cto">${esc(m.to==='all'?'all':String(m.to).split(':')[0])}</span>: ${esc(m.text)}</div>`).join('');
@@ -415,6 +442,15 @@ async function render(){
   try{projects=(await (await fetch('/projects')).json()).projects||[];}catch(e){}
   try{tasks=(await (await fetch('/tasks')).json()).tasks||[];}catch(e){}
   try{msgs=(await (await fetch('/recent?limit=200')).json()).messages||[];}catch(e){}
+
+  const histP = projects.filter(p => VIEWS[p.project] === "timeline").map(async p => {
+    try {
+      const h = await (await fetch(`/history?project=${encodeURIComponent(p.project)}`)).json();
+      HISTORY[p.project] = h.events || [];
+    } catch(e) {}
+  });
+  await Promise.all(histP);
+
   // hub was reset (server empty but feed shows history) -> clear the stale client-side feed
   if(!msgs.length&&$('#feed').childElementCount>0){$('#feed').innerHTML='';nmsg=0;}
   const liveSess=new Set();projects.forEach(p=>p.agents.forEach(a=>{if(a.online)liveSess.add(a.session)}));
@@ -441,7 +477,8 @@ async function render(){
   if(!projects.length){el.innerHTML='<div class="empty big">no projects yet — agents register a project on connect</div>';return;}
   const idleOpen=new Set(JSON.parse(localStorage.getItem("abIdleOpen")||"[]"));
   const projBlock=p=>{
-    const pt=tasks.filter(t=>t.project===p.project);
+    const pt = tasks.filter(t=>t.project===p.project);
+    const pmsgs = msgs.filter(m=>projOf(m)===p.project);
     const done=pt.filter(t=>t.status==='done').length;
     const pct=pt.length?Math.round(done/pt.length*100):0;
     const agents=p.agents.sort((a,b)=>b.online-a.online).map(a=>`<span class="agent ${a.online?'':'offl'}${a.health==='down'?' down':a.health==='errored'?' err':''}" title="${esc(a.session)}${a.online?' · online':' · offline'}${a.health&&a.health!=='ok'?' · '+a.health:''}">${iconFor(a.session,15)}<span class="nm">${esc(a.session)}</span>${a.status?` <span class="ast">· ${esc(a.status)}</span>`:''}${poolOf(a.session)?` <span class="ast" style="opacity:.7">[${esc(poolOf(a.session))}]</span>`:''}</span>`).join('');
@@ -460,15 +497,15 @@ async function render(){
     }).join('');
     const ph=p.phase||'';
     const brief=p.brief?`<span class="brief">${esc(p.brief)}</span>`:`<span class="brief dim">— no brief yet · an agent sets it with relay_project_brief</span>`;
-    const pmsgs=msgs.filter(m=>projOf(m)===p.project);
     const view = VIEWS[p.project] || "board";
-    const vtog = `<div class="vtog"><button class="vbtn ${view==="board"?"on":""}" data-proj="${esc(p.project)}" data-view="board">BOARD</button><button class="vbtn ${view==="flow"?"on":""}" data-proj="${esc(p.project)}" data-view="flow">FLOW</button></div>`;
+    const vtog = `<div class="vtog"><button class="vbtn ${view==="board"?"on":""}" data-proj="${esc(p.project)}" data-view="board">BOARD</button><button class="vbtn ${view==="flow"?"on":""}" data-proj="${esc(p.project)}" data-view="flow">FLOW</button><button class="vbtn ${view==="timeline"?"on":""}" data-proj="${esc(p.project)}" data-view="timeline">TIMELINE</button></div>`;
     const ctl=`<span class="mv"><b class="mvup" data-proj="${esc(p.project)}" title="move up">▲</b><b class="mvdn" data-proj="${esc(p.project)}" title="move down">▼</b></span>${p.idle===true?`<span class="pdel" data-proj="${esc(p.project)}" title="forget this project (cards, peers, brief) — it returns if an agent registers it again">✕</span>`:''}`;
+
     return `<div class="proj${p.idle===true?' idle':''}" data-projname="${esc(p.project)}"${p.idle===true?` data-idleproj="${esc(p.project)}"`:''}>`+
       `<div class="proj-h"><span class="pname">📁 <b>${esc(p.project)}</b></span>${vtog}<div class="agents">${agents||'<span class="dim">no agents</span>'}</div><span class="spacer"></span><span class="prog">${done}/${pt.length} done · ${pct}%</span>${ctl}</div>`+
       `<div class="proj-brief">${brief}${ph?`<span class="phase ${phaseClass(ph)}">${esc(ph)}</span>`:''}</div>`+
       `<div class="pbar"><i style="width:${pct}%"></i></div>`+
-      (view === "flow" ? flowHTML(pt, p.project) : `<div class="kanban">${cols}</div>`)+
+      (view === "flow" ? flowHTML(pt, p.project) : view === "timeline" ? timelineHTML(p.project) : `<div class="kanban">${cols}</div>`)+
       chatLane(pmsgs)+
     `</div>`;
   };
@@ -504,6 +541,8 @@ async function render(){
   if(armedDel&&Date.now()-armedTs<4000){const ab=el.querySelector(`.pdel[data-proj="${CSS.escape(armedDel)}"]`);if(ab){ab.classList.add('arm');ab.textContent='✕ sure?';}}
   const sr=$('#sortreset');if(sr)sr.onclick=()=>{localStorage.removeItem('abOrder');render();};
   wireFlow(el);
+  // keep each timeline scrolled to the latest event
+  el.querySelectorAll('.timeline').forEach(c=>{if(c.scrollHeight-c.clientHeight<60||c.dataset.stuck!=='0')c.scrollTop=c.scrollHeight;c.onscroll=()=>{c.dataset.stuck=(c.scrollHeight-c.scrollTop-c.clientHeight<40)?'1':'0';};});
   el.querySelectorAll('.tcard, .fnode').forEach(c=>c.onclick=async()=>{
     const id=+c.dataset.id,t=tasks.find(x=>x.id===id);if(!t)return;
     if(suppressClickId&&+suppressClickId===id)return;   // drag-end, not a click
@@ -557,20 +596,22 @@ function renderLearnBody(){const el=$('#learnBody');if(!el)return;if(!LEARN){el.
   else h+=lessons.slice(0,40).map(l=>`<div class="lles"><span class="sc">${esc(l.scope)}</span>${esc(l.text)}</div>`).join('');
   if(!learnProj)for(const[ag,arr]of Object.entries(L.lessons.byAgent||{}))h+=`<div class="lles"><span class="sc">${esc(ag)}</span>${esc(arr[0].text)}${arr.length>1?` <span class="dim">+${arr.length-1} more</span>`:''}</div>`;
   h+=`</div>`;
-  // Per-LLM reliability + progression charts
-  h+=`<div class="lsec"><h3>Per-LLM reliability</h3>`;
-  if(!(L.agents||[]).length)h+=`<div class="lempty">no turn telemetry yet</div>`;
-  for(const a of (L.agents||[])){const fr=(a.failRate*100).toFixed(1);
+  // Per-LLM reliability + progression charts — scoped to the selected project (or all)
+  const scopeLbl=learnProj?` <span class="dim" style="text-transform:none;letter-spacing:0">· ${esc(learnProj)}</span>`:'';
+  const ags=learnProj?(L.agentsByProject[learnProj]||[]):(L.agents||[]);
+  h+=`<div class="lsec"><h3>Per-LLM reliability${scopeLbl}</h3>`;
+  if(!ags.length)h+=`<div class="lempty">no turn telemetry${learnProj?' for this project':''} yet</div>`;
+  for(const a of ags){const fr=(a.failRate*100).toFixed(1);
     h+=`<div class="lcard"><div class="lc-h">${iconFor(a.agent,14)}<span class="nm">${esc(a.agent)}</span><span class="mut">${a.models.filter(m=>m!=='default').join(', ')||'default'}</span></div>`;
     h+=`<span class="lstat"><b>${a.turns}</b> turns</span><span class="lstat ${a.failures?'bad':'good'}"><b>${fr}%</b> fail</span>${a.lastFailure?`<span class="lstat">last exit ${a.lastFailure.exit}</span>`:''}`;
     if((a.series.failRate||[]).length>1)h+=`<div class="lchart"><div class="ltask">fail-rate / day</div>${lcLine(a.series.failRate,'rate',{color:LRED,fill:true})}</div>`;
     if((a.series.lessons||[]).length>1)h+=`<div class="lchart"><div class="ltask">lessons learned (cumulative)</div>${lcLine(a.series.lessons,'count',{color:LGRN,fill:true})}</div>`;
     h+=`</div>`;}
   h+=`</div>`;
-  // Baked-in guardrails per model + savings chart
-  h+=`<div class="lsec"><h3>Baked-in improvements <span class="lbadge">auto-injected into prompts</span></h3>`;
-  const gm=(L.models||[]).filter(m=>m.guardrailCount>0);
-  if(!gm.length)h+=`<div class="lempty">no model guardrails yet</div>`;
+  // Baked-in guardrails per model + savings chart — guardrails are global; savings scoped to the project
+  h+=`<div class="lsec"><h3>Baked-in improvements${scopeLbl} <span class="lbadge">auto-injected into prompts</span></h3>`;
+  const gm=(learnProj?(L.modelsByProject[learnProj]||[]):(L.models||[])).filter(m=>m.guardrailCount>0);
+  if(!gm.length)h+=`<div class="lempty">no guardrailed models${learnProj?' used in this project':''} yet</div>`;
   for(const m of gm){h+=`<div class="lcard"><div class="lc-h"><span class="nm">${esc(m.model)}</span>${m.saved_usd?`<span class="mut">$${m.saved_usd} saved · ${m.calls} calls</span>`:''}</div>`;
     for(const[task,arr]of Object.entries(m.guardrails||{})){h+=`<div class="ltask">${esc(task)}</div>`;for(const g of arr)h+=`<div class="lguard">${esc(g)}</div>`;}
     if((m.series.saved||[]).length>1)h+=`<div class="lchart"><div class="ltask">savings / day</div>${lcBars(m.series.saved,'saved',{color:LGRN})}</div>`;