trantor 0.17.3 → 0.17.5

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

package/.claude-plugin/plugin.json

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

@@ -5,7 +5,7 @@
 // machines reach it (e.g. over a Tailscale tailnet), set RELAY_HOST=0.0.0.0 — but only on a
 // private network, or add auth first. See "Always-on / remote hub" in the README (roadmap).
 import http from "node:http";
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -16,6 +16,35 @@ const DATA = join(DATA_DIR, "bus.json");
 const ONLINE_MS = Number(process.env.RELAY_ONLINE_MS || 5 * 60 * 1000);
 if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
 
+// Scrooge ledger cache: /economics is polled every ~15s by the dashboard, but the ledger
+// (~/.token-scrooge/calls.jsonl) only changes when a cheap-model call lands. Re-parse the whole
+// file only when its mtime moves; otherwise reuse the parsed rows. Keeps the lifetime running
+// total cheap to serve no matter how big the ledger grows.
+let _ledgerCache = { mtimeMs: -1, rows: [] };
+
+// Per-turn failure telemetry lives across many ~/.agent-bus/logs/<agent>-<project>.jsonl files
+// (written by crew-runner.mjs). Scanning them all every /learning poll would be wasteful, so cache
+// the aggregate and only rescan when a log file changes (tracked by the dir's newest mtime).
+const LOGDIR = join(homedir(), ".agent-bus", "logs");
+let _telemetryCache = { maxMtimeMs: -1, turns: [] };
+function scanTelemetry() {
+  let files = [];
+  try { files = readdirSync(LOGDIR).filter(f => f.endsWith(".jsonl")); } catch { return _telemetryCache.turns; }
+  let maxMtime = 0;
+  for (const f of files) { try { const m = statSync(join(LOGDIR, f)).mtimeMs; if (m > maxMtime) maxMtime = m; } catch {} }
+  if (maxMtime === _telemetryCache.maxMtimeMs) return _telemetryCache.turns;   // nothing changed
+  const turns = [];
+  for (const f of files) {
+    let txt = ""; try { txt = readFileSync(join(LOGDIR, f), "utf8"); } catch { continue; }
+    for (const line of txt.trim().split("\n")) {
+      if (!line) continue;
+      try { const r = JSON.parse(line); if (r && r.agent) turns.push(r); } catch {}
+    }
+  }
+  _telemetryCache = { maxMtimeMs: maxMtime, turns };
+  return turns;
+}
+
 // 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: [] };
@@ -167,22 +196,43 @@ const server = http.createServer(async (req, res) => {
       dirty = true; return json(res, 200, { ok: true, count: state.lessons.length });
     }
     if (req.method === "GET" && P === "/economics") {   // the brain's books, surfaced: scrooge ledger + quota profile
-      const out = { scrooge: null, profile: null };
+      const out = { scrooge: null, lifetime: null, profile: null };
       try { out.profile = JSON.parse(readFileSync(join(homedir(), ".agent-bus", "profile.json"), "utf8")).providers || {}; } catch {}
       try {
-        const since = now() / 1000 - (Number(q.hours || 24) * 3600);
-        const lines = readFileSync(join(homedir(), ".token-scrooge", "calls.jsonl"), "utf8").trim().split("\n").slice(-3000);
-        const calls = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(c => c && c.ts >= since && c.ok);
-        const sum = { calls: calls.length, tokens_in: 0, tokens_out: 0, cost_usd: 0, by_model: {} };
-        for (const c of calls) {
-          sum.tokens_in += c.tokens_in || 0; sum.tokens_out += c.tokens_out || 0; sum.cost_usd += c.cost_usd || 0;
-          const m = sum.by_model[c.model] ||= { calls: 0, cost_usd: 0 };
-          m.calls++; m.cost_usd += c.cost_usd || 0;
+        const ledger = join(homedir(), ".token-scrooge", "calls.jsonl");
+        const st = statSync(ledger);
+        if (st.mtimeMs !== _ledgerCache.mtimeMs) {   // ledger changed → reparse the whole file once
+          const rows = readFileSync(ledger, "utf8").trim().split("\n")
+            .map(l => { try { return JSON.parse(l); } catch { return null; } })
+            .filter(c => c && c.ok);
+          _ledgerCache = { mtimeMs: st.mtimeMs, rows };
         }
-        // savings vs Opus reference (~$15/M in, $75/M out — same yardstick scrooge ledger uses)
-        sum.opus_equiv_usd = +(sum.tokens_in * 15 / 1e6 + sum.tokens_out * 75 / 1e6).toFixed(2);
-        sum.cost_usd = +sum.cost_usd.toFixed(4);
-        out.scrooge = sum;
+        const rows = _ledgerCache.rows;
+        // Roll up a set of calls into spend + the frontier-model yardstick (~$15/M in, $75/M out,
+        // same reference scrooge's own ledger uses) and the resulting savings.
+        const rollup = calls => {
+          const s = { calls: calls.length, tokens_in: 0, tokens_out: 0, cost_usd: 0, by_model: {} };
+          for (const c of calls) {
+            s.tokens_in += c.tokens_in || 0; s.tokens_out += c.tokens_out || 0; s.cost_usd += c.cost_usd || 0;
+            const m = s.by_model[c.model] ||= { calls: 0, cost_usd: 0 };
+            m.calls++; m.cost_usd += c.cost_usd || 0;
+          }
+          s.opus_equiv_usd = +(s.tokens_in * 15 / 1e6 + s.tokens_out * 75 / 1e6).toFixed(2);
+          s.cost_usd = +s.cost_usd.toFixed(4);
+          s.saved_usd = +Math.max(0, s.opus_equiv_usd - s.cost_usd).toFixed(2);
+          return s;
+        };
+        // Named rolling windows the dashboard dropdown offers, all served in one response so
+        // switching the selector is instant (no refetch) — cheap because the rows are cached.
+        const nowS = now() / 1000;
+        const WINDOWS = { "24h": 24, "week": 168, "month": 720, "quarter": 2160, "year": 8760 };
+        out.windows = {};
+        for (const [k, hrs] of Object.entries(WINDOWS)) out.windows[k] = rollup(rows.filter(c => c.ts >= nowS - hrs * 3600));
+        out.lifetime = rollup(rows);                             // all-time running total
+        out.lifetime.since_ts = rows.length ? rows[0].ts : null; // first ledgered call
+        out.windows.lifetime = out.lifetime;
+        // back-compat: `scrooge` is the window older dashboards read (honor ?hours= if passed)
+        out.scrooge = q.hours ? rollup(rows.filter(c => c.ts >= nowS - Number(q.hours) * 3600)) : out.windows["24h"];
       } catch {}
       return json(res, 200, out);
     }
@@ -191,6 +241,77 @@ const server = http.createServer(async (req, res) => {
       const ls = state.lessons.filter(l => l.scope === "global" || (agent && l.scope === agent));
       return json(res, 200, { lessons: ls });
     }
+    // The self-learning loop, surfaced for the dashboard "Learning" sidebar: relay lessons grouped
+    // (global / per-agent / per-project), per-LLM reliability from turn telemetry (+ daily series for
+    // charts), and the Scrooge guardrails baked into each model's prompt (+ per-model economics).
+    if (req.method === "GET" && P === "/learning") {
+      const projOf = by => (by && by.includes(":")) ? by.split(":").pop() : "";
+      // ts is ms (lessons/telemetry) or s (ledger). Null-safe: a malformed record with a missing/bad
+      // 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: [] };
+
+      // relay lessons → global / by-agent / by-project (project derived from the recorder's session id)
+      const projSet = new Set();
+      for (const l of state.lessons) {
+        const rec = { text: l.text, scope: l.scope, by: l.by || "", project: projOf(l.by), ts: l.ts || 0 };
+        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
+      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 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 || "" }; }
+      }
+      // 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,
+          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
+      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: {} });
+        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; }
+      }
+      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 gcount = Object.values(g || {}).reduce((s, arr) => s + (Array.isArray(arr) ? arr.length : 0), 0);
+        totalGuardrails += gcount; const lm = ledgerByModel[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
+
+      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);
+    }
     if (req.method === "POST" && P === "/send") {
       const b = await body(req);
       if (!b.from || !String(b.text ?? "").trim()) return json(res, 400, { error: "from and non-empty text required" });

package/mcp.mjs

@@ -44,11 +44,12 @@ server.tool("relay_whoami", "Show this session's relay identity, project, and th
   return { content: [{ type: "text", text: `session=${SESSION}\nproject=${PROJECT}\nhub=${URL_BASE}` }] };
 });
 
-server.tool("relay_task_add", "Add a Kanban card to THIS project's board on the dashboard (what you're about to work on). Defaults: assigned to you, status 'todo'. Keep the team's progress visible.",
-  { title: z.string().describe("short task title"), status: z.enum(["todo","doing","testing","failed","done","blocked"]).optional(), assignee: z.string().optional().describe("session id to assign (default: you)"), difficulty: z.enum(["easy","medium","hard"]).optional().describe("difficulty tag — drives model/agent routing (relay_advise) and shows on the board"), model: z.string().optional().describe("the model this card is routed to (from relay_advise routing, or the CLI default) — shown on the card"), deps: z.array(z.number()).optional().describe("card ids this card depends on — drawn as edges in the Flow view (e.g. integration depends on every crew card)") },
-  async ({ title, status, assignee, difficulty, model, deps }) => {
-    const { task } = await api("POST", "/task", { project: PROJECT, title, status: status || "todo", assignee: assignee || SESSION, difficulty, model, deps, by: SESSION });
-    return { content: [{ type: "text", text: `card #${task.id} added to ${PROJECT}: "${title}" [${task.status}]` }] };
+server.tool("relay_task_add", "Add a Kanban card to a project's board on the dashboard (what you're about to work on). Defaults: THIS project, assigned to you, status 'todo'. Pass `project` to target another board — e.g. when you orchestrate a crew that runs in a different directory than the one you launched Claude from. Keep the team's progress visible.",
+  { title: z.string().describe("short task title"), status: z.enum(["todo","doing","testing","failed","done","blocked"]).optional(), assignee: z.string().optional().describe("session id to assign (default: you)"), difficulty: z.enum(["easy","medium","hard"]).optional().describe("difficulty tag — drives model/agent routing (relay_advise) and shows on the board"), model: z.string().optional().describe("the model this card is routed to (from relay_advise routing, or the CLI default) — shown on the card"), deps: z.array(z.number()).optional().describe("card ids this card depends on — drawn as edges in the Flow view (e.g. integration depends on every crew card)"), project: z.string().optional().describe("board to add to (default: this session's project). Set to the crew's project when you orchestrate from a different directory") },
+  async ({ title, status, assignee, difficulty, model, deps, project }) => {
+    const proj = project || PROJECT;
+    const { task } = await api("POST", "/task", { project: proj, title, status: status || "todo", assignee: assignee || SESSION, difficulty, model, deps, by: SESSION });
+    return { content: [{ type: "text", text: `card #${task.id} added to ${proj}: "${title}" [${task.status}]` }] };
   });
 
 server.tool("relay_task_move", "Move a Kanban card as you progress: todo -> doing -> testing -> done. NEVER move straight to done: move to 'testing' when you finish, run the project's tests/typecheck, then 'done' only if green — or 'failed' (with a relay_send explaining what broke) if not. The orchestrator bounces failed cards back to doing. blocked = waiting on something external.",
@@ -58,11 +59,12 @@ server.tool("relay_task_move", "Move a Kanban card as you progress: todo -> doin
     return { content: [{ type: "text", text: `card #${id} -> ${status}` }] };
   });
 
-server.tool("relay_project_brief", "Set a one-paragraph brief for THIS project shown on the dashboard: what it is, why it matters, and the goal. Set it once when you start work so anyone watching the board understands the project at a glance (the board itself shows where it is in the process).",
-  { brief: z.string().describe("1-3 sentences: what this project is + why + the goal") },
-  async ({ brief }) => {
-    await api("POST", "/project", { project: PROJECT, brief, by: SESSION });
-    return { content: [{ type: "text", text: `brief set for ${PROJECT}` }] };
+server.tool("relay_project_brief", "Set a one-paragraph brief for a project shown on the dashboard: what it is, why it matters, and the goal. Defaults to THIS project; pass `project` to brief a crew board you orchestrate from elsewhere. Set it once when you start work so anyone watching the board understands the project at a glance (the board itself shows where it is in the process).",
+  { brief: z.string().describe("1-3 sentences: what this project is + why + the goal"), project: z.string().optional().describe("board to brief (default: this session's project)") },
+  async ({ brief, project }) => {
+    const proj = project || PROJECT;
+    await api("POST", "/project", { project: proj, brief, by: SESSION });
+    return { content: [{ type: "text", text: `brief set for ${proj}` }] };
   });
 
 server.tool("relay_advise", "THE ADVISOR — ask the brain how to execute a body of work before spending tokens. Give it your work packages (with difficulty); it weighs task shape x the user's plan economics x context horizon and returns: mode (solo|scrooge|crew|hybrid), per-package executor+model routing, and a real-money estimate with quota-pool accounting. Call this at project kickoff and PRESENT the summary to the user before firing anything up.",
@@ -92,13 +94,16 @@ server.tool("relay_lesson", "Record a LESSON learned from a failure so future cr
     return { content: [{ type: "text", text: r.dedup ? "lesson already recorded" : `lesson recorded (${r.count} total)` }] };
   });
 
-server.tool("relay_board", "Show THIS project's Kanban board (all cards + their status + assignee).", {}, async () => {
-  const { tasks } = await api("GET", `/tasks?project=${encodeURIComponent(PROJECT)}`);
-  if (!tasks.length) return { content: [{ type: "text", text: `${PROJECT}: no cards yet` }] };
+server.tool("relay_board", "Show a project's Kanban board (all cards + their status + assignee). Defaults to THIS project; pass `project` to read a crew board you orchestrate from elsewhere.",
+  { project: z.string().optional().describe("board to show (default: this session's project)") },
+  async ({ project }) => {
+  const proj = project || PROJECT;
+  const { tasks } = await api("GET", `/tasks?project=${encodeURIComponent(proj)}`);
+  if (!tasks.length) return { content: [{ type: "text", text: `${proj}: no cards yet` }] };
   const by = { todo: [], doing: [], testing: [], failed: [], done: [], blocked: [] };
   for (const t of tasks) (by[t.status] || by.todo).push(`#${t.id} ${t.title}${t.assignee ? ` (@${t.assignee})` : ""}`);
   const cols = Object.entries(by).filter(([, v]) => v.length).map(([k, v]) => `${k.toUpperCase()}:\n  ${v.join("\n  ")}`);
-  return { content: [{ type: "text", text: `${PROJECT} board\n${cols.join("\n")}` }] };
+  return { content: [{ type: "text", text: `${proj} board\n${cols.join("\n")}` }] };
 });
 
 server.tool("relay_peers", "List other Claude sessions connected to the relay (online in last 5 min).", {}, async () => {

package/package.json

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

package/ui.html

@@ -11,8 +11,38 @@ header{display:flex;align-items:center;gap:13px;padding:11px 18px;border-bottom:
 .dot.off{background:var(--dim);box-shadow:none}
 .muted{color:var(--mut)}.dim{color:var(--dim)}.spacer{flex:1}
 .pill{background:var(--card);border:1px solid var(--line);border-radius:20px;padding:3px 11px;font-size:12px;color:var(--mut)}
-main{flex:1;display:grid;grid-template-columns:1fr 330px;min-height:0}
+main{flex:1;display:grid;grid-template-columns:var(--lw,44px) 1fr 330px;min-height:0}
+main.learn-open{--lw:372px}
 .boards{overflow-y:auto;padding:16px 18px}
+/* Learning sidebar (collapsible left rail) — surfaces the self-learning loop */
+.learn{background:var(--panel);border-right:1px solid var(--line);display:flex;flex-direction:column;min-height:0;overflow:hidden}
+.learn-head{display:flex;align-items:center;gap:8px;padding:11px 12px;border-bottom:1px solid var(--line);cursor:pointer;white-space:nowrap;user-select:none}
+.learn-head .lt{font-weight:700;font-size:13px;color:var(--tx)}.learn-head .lt b{color:var(--grn)}
+.learn-head .chev{margin-left:auto;color:var(--mut);font-size:14px}
+main:not(.learn-open) .learn-head{flex-direction:column;gap:12px;padding:14px 0;height:100%;border-bottom:none;justify-content:flex-start}
+main:not(.learn-open) .learn-head .lt{writing-mode:vertical-rl;transform:rotate(180deg);letter-spacing:.6px}
+main:not(.learn-open) .learn-head .chev{margin:0}
+main:not(.learn-open) .learn-body{display:none}
+.learn-body{overflow-y:auto;padding:10px 12px 26px;flex:1}
+.lsum{font-size:11.5px;color:var(--mut);line-height:1.5;margin-bottom:13px}.lsum b{color:var(--grn)}
+.lsec{margin-bottom:17px}
+.lsec>h3{font-size:10.5px;text-transform:uppercase;letter-spacing:.6px;color:var(--dim);margin:0 0 7px;display:flex;align-items:center;gap:6px}
+.lsel{background:var(--card);color:var(--tx);border:1px solid var(--line);border-radius:6px;font:inherit;font-size:11px;padding:2px 4px;margin-left:auto;cursor:pointer;outline:none}
+.lcard{background:var(--card);border:1px solid var(--line);border-radius:9px;padding:8px 10px;margin-bottom:7px}
+.lcard .lc-h{display:flex;align-items:center;gap:7px;font-size:12px;margin-bottom:5px}
+.lcard .lc-h .nm{font-weight:600;color:var(--tx)}
+.lcard .lc-h .mut{color:var(--mut);font-size:10.5px;margin-left:auto}
+.lles{font-size:11.5px;color:var(--mut);line-height:1.45;padding:5px 0;border-top:1px solid var(--line)}
+.lles:first-child{border-top:none}
+.lles .sc{display:inline-block;font-size:9px;color:var(--dim);border:1px solid var(--line);border-radius:8px;padding:0 5px;margin-right:5px;vertical-align:1px;text-transform:uppercase;letter-spacing:.4px}
+.lguard{font-size:11px;color:var(--mut);line-height:1.42;padding:3px 0 3px 13px;position:relative}
+.lguard:before{content:"";position:absolute;left:3px;top:9px;width:4px;height:4px;border-radius:50%;background:var(--grn)}
+.ltask{font-size:9px;color:var(--dim);text-transform:uppercase;letter-spacing:.5px;margin:5px 0 2px}
+.lstat{display:inline-block;font-size:10.5px;color:var(--mut);margin-right:10px}
+.lstat b{color:var(--tx)}.lstat.bad b{color:var(--red)}.lstat.good b{color:var(--grn)}
+.lchart{margin-top:4px}.lchart svg{display:block;width:100%;height:42px}
+.lbadge{font-size:8.5px;color:var(--grn);border:1px solid #1d4a44;border-radius:8px;padding:1px 6px;text-transform:none;letter-spacing:0}
+.lempty{font-size:11px;color:var(--dim);font-style:italic;padding:4px 0}
 .proj{background:var(--panel);border:1px solid var(--line);border-radius:14px;margin-bottom:16px;overflow:hidden}
 .proj-h{display:flex;align-items:center;gap:10px;padding:12px 16px;border-bottom:1px solid var(--line);background:#0e1421}
 .proj-h .pname{font-family:'Sora',ui-sans-serif,sans-serif;font-weight:700;font-size:15px}
@@ -141,10 +171,16 @@ aside h2{font-size:10.5px;text-transform:uppercase;letter-spacing:.09em;color:va
   <span class="logo">tran<b>t</b>or</span>
   <span class="pill" id="hub">—</span>
   <span class="spacer"></span>
-  <span class="pill" id="econ" title="Scrooge ledger, last 24h" style="display:none"></span>
+  <span class="pill" id="econ" title="Trantor savings vs frontier models — lifetime running total + last 24h (from the Scrooge ledger)" style="display:none"></span>
   <span class="pill"><span id="nproj">0</span> projects · <span id="nsess">0</span> live · <span id="ntask">0</span> cards</span>
 </header>
 <main>
+  <section class="learn" id="learn">
+    <div class="learn-head" id="learnToggle" title="Learning — lessons, per-LLM reliability, baked-in guardrails">
+      <span class="lt">🧠 <b>Learning</b></span><span class="chev" id="learnChev">›</span>
+    </div>
+    <div class="learn-body" id="learnBody"></div>
+  </section>
   <div class="boards" id="boards"><div class="empty big">no projects yet — agents register a project on connect</div></div>
   <aside>
     <h2>Live feed</h2>
@@ -181,15 +217,34 @@ function iconFor(s,size){const b=brandOf(s);if(!b||!ICON[b])return `<span style=
 const phaseClass=ph=>/^idle ·/.test(ph)?'planned':/FAILED|blocked/.test(ph)?'blocked':/building|verifying|progress/.test(ph)?'building':/shipped|done/.test(ph)?'shipped':'planned';
 
 let POOLS={};
+let ECON=null;
+const ECON_WINS=[['24h','last 24h'],['week','last week'],['month','last month'],['quarter','last quarter'],['year','last year']];
+let econWin=localStorage.getItem('abEconWin')||'24h';
+const econSaved=x=>x?(x.saved_usd!=null?(+x.saved_usd):Math.max(0,(x.opus_equiv_usd||0)-(x.cost_usd||0))):0;
+function renderEcon(){
+  if(!ECON||!ECON.lifetime||!ECON.lifetime.calls)return;
+  const el=$('#econ'); el.style.display='';
+  // lifetime running total is the fixed headline; the dropdown picks the comparison window.
+  if(!el.dataset.built){
+    el.innerHTML=`🪙 Trantor saved <b style="color:var(--grn)" id="econlife"></b> vs frontier`+
+      `<span style="opacity:.55"> · lifetime · </span>`+
+      `<select id="econsel" title="comparison window" style="background:#1a2030;color:inherit;border:1px solid rgba(255,255,255,.18);border-radius:4px;font:inherit;font-size:11px;padding:1px 3px;cursor:pointer;outline:none">`+
+        ECON_WINS.map(([k,l])=>`<option value="${k}">${l}</option>`).join('')+`</select>`+
+      `<span style="opacity:.85" id="econwinval"></span>`;
+    const sel=$('#econsel'); sel.value=econWin;
+    sel.onchange=()=>{econWin=sel.value; localStorage.setItem('abEconWin',econWin); renderEcon();};
+    el.dataset.built='1';
+  }
+  const w=(ECON.windows&&ECON.windows[econWin])||ECON.scrooge, wc=w?w.calls:0;
+  $('#econlife').textContent='$'+econSaved(ECON.lifetime).toFixed(2);
+  $('#econwinval').textContent=' $'+econSaved(w).toFixed(2)+' ('+wc+' call'+(wc===1?'':'s')+')';
+  const sel=$('#econsel'); if(sel)sel.value=econWin;
+}
 async function econ(){
   try{
     const e=await (await fetch('/economics')).json();
     POOLS={}; for(const[k,v]of Object.entries(e.profile||{}))POOLS[k]=v.tier;
-    if(e.scrooge&&e.scrooge.calls>0){
-      const s=e.scrooge;
-      const el=$('#econ'); el.style.display='';
-      el.innerHTML=`🪙 scrooge 24h: <b style="color:var(--grn)">$${s.cost_usd}</b> · saved ~$${Math.max(0,(s.opus_equiv_usd-s.cost_usd)).toFixed(2)} · ${s.calls} calls`;
-    }
+    ECON=e; renderEcon();
   }catch(_){}
 }
 econ();setInterval(econ,15000);
@@ -473,6 +528,60 @@ $('#send').onclick=async()=>{const t=$('#text').value.trim();if(!t)return;
 $('#text').addEventListener('keydown',e=>{if(e.key==='Enter')$('#send').click();});
 fetch('/recent?limit=40').then(r=>r.json()).then(d=>(d.messages||[]).forEach(m=>addMsg(m,false))).catch(()=>{});
 $('#hub').textContent=location.host;
+/* ---- Learning sidebar: the self-learning loop, surfaced ---- */
+const LGRN='#2dd4bf',LRED='#ef6a6a';
+// tiny inline-SVG charts (no library) — match the flow view's hand-rolled SVG approach
+function lcLine(pts,key,opt){opt=opt||{};const w=300,h=42,pad=4,color=opt.color||LGRN;if(!pts||!pts.length)return '';
+  const ys=pts.map(p=>+p[key]||0),max=Math.max(1e-6,...ys),n=pts.length;
+  const X=i=>pad+(n<=1?(w-2*pad)/2:i*(w-2*pad)/(n-1)),Y=v=>h-pad-(v/max)*(h-2*pad);
+  const pl=pts.map((p,i)=>`${X(i).toFixed(1)},${Y(+p[key]||0).toFixed(1)}`).join(' ');
+  return `<svg viewBox="0 0 ${w} ${h}" preserveAspectRatio="none">`+
+    (opt.fill?`<polygon points="${pad},${h-pad} ${pl} ${X(n-1).toFixed(1)},${h-pad}" fill="${color}" opacity=".13"/>`:'')+
+    `<polyline points="${pl}" fill="none" stroke="${color}" stroke-width="1.5" stroke-linejoin="round"/>`+
+    (n===1?`<circle cx="${X(0).toFixed(1)}" cy="${Y(ys[0]).toFixed(1)}" r="2.2" fill="${color}"/>`:'')+`</svg>`;}
+function lcBars(pts,key,opt){opt=opt||{};const w=300,h=42,pad=4,color=opt.color||LGRN;if(!pts||!pts.length)return '';
+  const ys=pts.map(p=>+p[key]||0),max=Math.max(1e-6,...ys),n=pts.length,gap=(w-2*pad)/n,bw=gap*0.68;
+  return `<svg viewBox="0 0 ${w} ${h}" preserveAspectRatio="none">`+pts.map((p,i)=>{const v=+p[key]||0,bh=(v/max)*(h-2*pad),x=pad+i*gap+(gap-bw)/2;
+    return `<rect x="${x.toFixed(1)}" y="${(h-pad-bh).toFixed(1)}" width="${bw.toFixed(1)}" height="${Math.max(0.5,bh).toFixed(1)}" rx="1" fill="${color}" opacity=".75"/>`;}).join('')+`</svg>`;}
+let LEARN=null,learnProj=localStorage.getItem('abLearnProj')||'';
+let learnOpen=localStorage.getItem('abLearnOpen')==='1';
+function applyLearnState(){document.querySelector('main').classList.toggle('learn-open',learnOpen);$('#learnChev').textContent=learnOpen?'‹':'›';}
+function renderLearnBody(){const el=$('#learnBody');if(!el)return;if(!LEARN){el.innerHTML='<div class="lempty">loading…</div>';return;}
+  const L=LEARN,t=L.totals||{};
+  let h=`<div class="lsum">Trantor has recorded <b>${t.lessons||0}</b> lessons and baked <b>${t.guardrails||0}</b> guardrails into model prompts. Across <b>${t.turns||0}</b> crew turns the failure rate is <b>${((t.failRate||0)*100).toFixed(1)}%</b> — self-healing as fixes compound.</div>`;
+  // Lessons (project filter; lifetime also shows per-agent lessons)
+  const projOpts=['<option value="">All projects (lifetime)</option>'].concat((L.lessons.projects||[]).map(p=>`<option value="${esc(p)}"${p===learnProj?' selected':''}>${esc(p)}</option>`)).join('');
+  h+=`<div class="lsec"><h3>Lessons <select class="lsel" id="lprojSel">${projOpts}</select></h3>`;
+  const lessons=learnProj?(L.lessons.byProject[learnProj]||[]):(L.lessons.global||[]);
+  if(!lessons.length)h+=`<div class="lempty">no lessons recorded for this scope yet</div>`;
+  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);
+    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>`;
+  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>`;
+    h+=`</div>`;}
+  h+=`</div>`;
+  el.innerHTML=h;
+  const ps=$('#lprojSel');if(ps)ps.onchange=()=>{learnProj=ps.value;localStorage.setItem('abLearnProj',learnProj);renderLearnBody();};}
+async function learn(){try{LEARN=await (await fetch('/learning')).json();if(learnOpen)renderLearnBody();}catch(_){}}
+$('#learnToggle').onclick=()=>{learnOpen=!learnOpen;localStorage.setItem('abLearnOpen',learnOpen?'1':'0');applyLearnState();if(learnOpen)renderLearnBody();};
+applyLearnState();learn();setInterval(learn,20000);
+
 render();setInterval(render,2500);stream();
 // Self-heal after the laptop sleeps / the tab is backgrounded: browser timers and the SSE
 // stream get suspended and don't reliably resume, so the board freezes on stale data. The