trantor 0.17.14 → 0.17.15

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.14",
+  "version": "0.17.15",
   "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/handoff-now.mjs

@@ -1,21 +1,20 @@
 #!/usr/bin/env node
-// trantor — detached handoff worker. The PostToolUse heartbeat spawns this when a
-// session crosses its context warn threshold, so the (up to ~60s) scrooge summary
-// never blocks a tool call. Writes a whole-session handoff and prompts to open a
-// fresh session. Args: <projectDir> <sessionId> <transcriptPath> [trigger]
-import { readConfig, writeHandoff, pingBus, maybeSpawn,
-         contextUsage, alreadyHandedOff, markHandedOff } from "./lib/handoff.mjs";
+// trantor — detached EARLY-WARNING handoff worker. The PostToolUse heartbeat spawns this when a
+// session crosses its context warn threshold (~85% of a known window). Its job is to PREPARE a
+// safety-net handoff and NOTIFY — NOT to open a window. Spawning a fresh session while the original
+// is still perfectly usable created a surprise pop-up + an orphaned duplicate session; the actual
+// fresh-window spawn now happens only AT THE WALL (PreCompact). The (~60s) scrooge summary runs here,
+// detached, so it never blocks a tool call. Args: <projectDir> <sessionId> <transcriptPath> [trigger]
+import { readConfig, writeHandoff, pingBus, contextUsage } from "./lib/handoff.mjs";
 import { basename } from "node:path";
 
 const [, , projectDir = process.cwd(), sessionId = "", transcript = "", trigger = "context-warn"] = process.argv;
 try {
   const conf = readConfig();
-  const cur = contextUsage(transcript, conf)?.tokens || 0;
-  if (alreadyHandedOff(sessionId, cur)) process.exit(0); // another path beat us to it
   const { file, record } = writeHandoff({ projectDir, sessionId, transcript, trigger });
-  process.stderr.write(`[trantor] early handoff written: ${file} (frac warn)\n`);
+  process.stderr.write(`[trantor] early handoff written (safety net, no spawn): ${file}\n`);
+  // notify the bus so a watcher knows a handoff is ready — but do NOT spawn a window here.
   await pingBus(basename(projectDir), record.id, conf);
-  if (maybeSpawn(projectDir, conf)) markHandedOff(sessionId, cur);
 } catch (e) {
   process.stderr.write(`[trantor] handoff-now error: ${e?.message || e}\n`);
 }

package/hooks/heartbeat.mjs

@@ -19,7 +19,7 @@ import { homedir, hostname } from "node:os";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { readConfig, contextUsage, warnFrac, alreadyHandedOff } from "./lib/handoff.mjs";
-import { resolveProject } from "../lib/project.mjs";
+import { resolveProject, hostId } from "../lib/project.mjs";
 
 const HEARTBEAT_MS = Number(process.env.RELAY_HEARTBEAT_MS || 60 * 1000);
 const FETCH_TIMEOUT_MS = Number(process.env.RELAY_HEARTBEAT_TIMEOUT_MS || 1500);
@@ -83,7 +83,7 @@ async function main(stdinRaw) {
   // identity, else a RELAY_AGENT brand ("codex","kimi",…) per project, else hostname:project.
   const project = resolveProject(projectDir);
   const session = process.env.RELAY_SESSION
-    || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${project}` : `${hostname()}:${project}`);
+    || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${project}` : `${hostId()}:${project}`);
 
   // Throttle: only act if HEARTBEAT_MS has elapsed since the last tick for THIS session.
   const stamp = join(homedir(), ".agent-bus", `hb-${session.replace(/[^A-Za-z0-9_.-]/g, "_")}.stamp`);

package/hooks/sessionstart.mjs

@@ -10,7 +10,7 @@ import { readFileSync, writeFileSync, existsSync, readdirSync } from "node:fs";
 import { join, basename } from "node:path";
 import { homedir, hostname } from "node:os";
 import { execSync } from "node:child_process";
-import { resolveProject } from "../lib/project.mjs";
+import { resolveProject, hostId } from "../lib/project.mjs";
 
 // Load the most recent UNCONSUMED handoff for this project (written by precompact.mjs
 // / the heartbeat early-warning). `claim` marks it consumed so exactly one session
@@ -78,7 +78,7 @@ try {
   }
   const project = resolveProject(projectDir);
   const session = process.env.RELAY_SESSION
-    || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${project}` : `${hostname()}:${project}`);
+    || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${project}` : `${hostId()}:${project}`);
   const url = relayUrl();
 
   // register self + post an initial presence status (no LLM turn — instant for others to read)

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: [], cardEventsBackfilled: false, aliases: {} };
+let state = { messages: [], peers: {}, seq: 0, tasks: [], taskSeq: 0, projectMeta: {}, lessons: [], cardEvents: [], cardEventsBackfilled: false, aliases: {}, phaseMeta: {} };
 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 : [], cardEventsBackfilled: !!loaded.cardEventsBackfilled, aliases: (loaded.aliases && typeof loaded.aliases === "object") ? loaded.aliases : {} };
+    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, aliases: (loaded.aliases && typeof loaded.aliases === "object") ? loaded.aliases : {}, phaseMeta: (loaded.phaseMeta && typeof loaded.phaseMeta === "object") ? loaded.phaseMeta : {} };
     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 || "" };
   }
@@ -154,6 +154,95 @@ function appendCardEvent(type, task, by, from = null, to = null) {
   if (state.cardEvents.length > 5000) state.cardEvents.splice(0, state.cardEvents.length - 5000);
 }
 
+// --- FLOW v2: derive a project's PHASES (the orchestrator-rooted flowchart spine) ---
+// Real data is deps-sparse (most cards carry no deps), so we DON'T derive phases from the
+// dependency graph. Instead: a card's phase = its title-prefix family (P5a/P5b → "P5",
+// CBv2-1/CBfix → "CB", FA-comp1 → "FA", …) when present; otherwise it's clustered with its
+// time-neighbours into a "Setup N" round (gap > 8h opens a new round). Phases are ordered by
+// first-seen. The orchestrator (host session, "machine:project") vs crew ("brand:project")
+// split gives each phase its fan-out actors; the plan/integrate spine nodes are synthetic
+// because real per-phase orchestrator cards are rare. `sparse` flags a board that's mostly
+// un-prefixed (the UI shows an "inferred phases" notice — never a silent blob).
+const PHASE_GAP_MS = 8 * 60 * 60 * 1000;
+const agentBrand = (a) => { const s = String(a || ""); const i = s.indexOf(":"); return i > 0 ? s.slice(0, i) : (s || ""); };
+// Crew = a known helper-CLI brand; anything else with a brand (a machine hostname like
+// "MacBook-Pro-M1.local" or "MacBookPro.hsd1.fl.comcast.net", or a generic "host") is the
+// orchestrator. Brand-based (not hostname-pattern) so it's robust to hostname instability.
+const CREW_BRANDS = /^(codex|gemini|kimi|deepseek|claude|qwen|grok|glm|mistral|llama)$/i;
+const isOrchAssignee = (a) => { const b = agentBrand(a); return !!b && !CREW_BRANDS.test(b); };
+function phaseFamily(title) {
+  const s = String(title || "").trim();
+  // "P5a Structured…", "P4-construction", "P3 Quantity" → P5/P4/P3 (group all P5a/b/c/d together).
+  // The trailing letter and the separator must NOT be swallowed by \b (P5a has none between 5 and a).
+  let m;
+  if ((m = s.match(/^P(\d+)[a-z]?(?:[\s\-:.]|$)/i))) return "P" + m[1];
+  if (/^CBv?\d/i.test(s) || /^CBfix/i.test(s) || /^CB[\s\-:.]/i.test(s)) return "CB";
+  if (/^FA[\s\-:.\d]/i.test(s)) return "FA";
+  if (/^RunCost/i.test(s)) return "RunCost";
+  return null;
+}
+function phaseStatus(counts) {
+  if (counts.failed) return "failed";
+  if (counts.doing || counts.testing) return "active";
+  const total = counts.todo + counts.doing + counts.testing + counts.failed + counts.done + counts.blocked;
+  if (total > 0 && counts.done === total) return "done";
+  if (counts.blocked) return "blocked";
+  if (counts.todo === total) return "planned";
+  return "active";
+}
+// A human "what is this phase about" line derived from the cards themselves: strip the phase-prefix
+// token, take the subject before the first em/en-dash, dedupe, join the first few. Retroactive — no
+// captured plan needed. An explicit phase goal (phaseMeta) overrides this in the /phases endpoint.
+function phaseTheme(cards) {
+  const subs = [];
+  const seen = new Set();
+  for (const c of cards) {
+    let s = String(c.title || "")
+      // drop the phase token INCLUDING any sub-index (P3.5, P5a, CBv2-1) + separators, so no "1"/".5" leaks
+      .replace(/^\s*(P\d+[a-z]?(?:[.\-]\d+)?|CBv?\d+(?:[.\-]\d+)?|CBfix|FA[-\s:]?\w*|RunCost)[\s:\-–—#]*/i, "")
+      .split(/[—–]| - /)[0].trim();                                                    // subject before a dash
+    if (!s) continue;
+    const k = s.toLowerCase().slice(0, 22);
+    if (seen.has(k)) continue;
+    seen.add(k); subs.push(s.slice(0, 48));
+    if (subs.length >= 3) break;
+  }
+  return subs.join(" · ").slice(0, 120);
+}
+function derivePhases(tasks) {
+  const sorted = [...tasks].sort((a, b) => (a.ts || 0) - (b.ts || 0));
+  let miscRound = 0, lastMiscTs = 0;
+  for (const t of sorted) {
+    // an explicit phase tag (set at plan time) wins; else infer from the title prefix; else time-cluster.
+    const explicit = t.phase && String(t.phase).trim();
+    const fam = explicit || phaseFamily(t.title);
+    if (fam) { t._phase = fam; }
+    else {
+      if (!lastMiscTs || (t.ts || 0) - lastMiscTs > PHASE_GAP_MS) miscRound++;
+      lastMiscTs = t.ts || lastMiscTs;
+      t._phase = `Setup ${miscRound}`;
+    }
+  }
+  const byPhase = new Map();
+  for (const t of sorted) { if (!byPhase.has(t._phase)) byPhase.set(t._phase, []); byPhase.get(t._phase).push(t); }
+  const phases = [...byPhase.entries()].map(([key, cards]) => {
+    const counts = { todo:0, doing:0, testing:0, failed:0, done:0, blocked:0 };
+    for (const c of cards) counts[c.status] = (counts[c.status] || 0) + 1;
+    const node = (c) => ({ id: c.id, title: c.title, assignee: c.assignee || "", agent: agentBrand(c.assignee), model: c.model || "", status: c.status, difficulty: c.difficulty || "", ts: c.ts || 0, updated: c.updated || c.ts || 0, deps: Array.isArray(c.deps) ? c.deps : [] });
+    const crew = cards.filter(c => !isOrchAssignee(c.assignee)).map(node);
+    const orchestrators = cards.filter(c => isOrchAssignee(c.assignee)).map(node);
+    return {
+      key, label: key, theme: phaseTheme(cards),
+      start: Math.min(...cards.map(c => c.ts || 0)), end: Math.max(...cards.map(c => c.updated || c.ts || 0)),
+      counts, total: cards.length, status: phaseStatus(counts),
+      agents: [...new Set(crew.map(c => c.agent).filter(Boolean))],
+      crew, orchestrators,
+    };
+  }).sort((a, b) => a.start - b.start);
+  const miscCount = sorted.filter(t => /^Setup /.test(t._phase)).length;
+  return { phases, total: sorted.length, sparse: sorted.length > 0 && miscCount / sorted.length > 0.5, derivedBy: "title-prefix + time-cluster" };
+}
+
 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;
   try {
@@ -170,6 +259,7 @@ const server = http.createServer(async (req, res) => {
       const st0 = ["todo","doing","testing","failed","done","blocked"].includes(b.status) ? b.status : "todo";
       const t = { id: ++state.taskSeq, project: canon(String(b.project || "").slice(0,80)), title: String(b.title||"").slice(0,200),
         assignee: b.assignee || "", status: st0,
+        phase: String(b.phase || "").slice(0, 40),   // explicit phase tag (FLOW v2) — wins over title-prefix inference
         difficulty: ["easy","medium","hard"].includes(b.difficulty) ? b.difficulty : "",
         model: String(b.model || "").slice(0, 60),
         deps: Array.isArray(b.deps) ? [...new Set(b.deps.map(Number).filter(n => Number.isInteger(n) && n > 0))].slice(0, 20) : [],
@@ -323,6 +413,28 @@ const server = http.createServer(async (req, res) => {
         lastActivity,
       });
     }
+    // FLOW v2: the orchestrator-rooted phase flowchart. Returns the project's cards grouped into
+    // ordered phases (title-prefix + time-cluster), each with its crew fan-out + orchestrator nodes.
+    if (req.method === "GET" && P === "/phases") {
+      const proj = canon(q.project || "");
+      if (!proj) return json(res, 400, { error: "project required" });
+      const mine = state.tasks.filter(t => canon(t.project) === proj);
+      const out = derivePhases(mine);
+      for (const p of out.phases) p.goal = state.phaseMeta[`${proj}::${p.key}`]?.goal || "";   // explicit goal overrides the derived theme
+      return json(res, 200, { project: proj, brief: state.projectMeta[proj]?.brief || "", ...out });
+    }
+    // Set a phase's explicit GOAL — what this phase needs to do (the orchestrator captures this at plan
+    // time, like a per-phase brief). Surfaces in the FLOW v2 header in place of the derived theme.
+    if (req.method === "POST" && P === "/phase") {
+      const b = await body(req);
+      const proj = canon(String(b.project || "").slice(0, 80)), phase = String(b.phase || "").slice(0, 40);
+      if (!proj || !phase) return json(res, 400, { error: "project + phase required" });
+      const k = `${proj}::${phase}`; const m = state.phaseMeta[k] || {};
+      if (b.goal !== undefined) m.goal = String(b.goal).slice(0, 400);
+      m.by = b.by || m.by || ""; m.updated = now();
+      state.phaseMeta[k] = m; dirty = true;
+      return json(res, 200, { ok: true, project: proj, phase, goal: m.goal || "" });
+    }
     if (req.method === "GET" && P === "/projects") {        // project-grouped view
       prunePeers();
       const cutoff = now() - ONLINE_MS; const byProj = {};

package/lib/project.mjs

@@ -6,7 +6,9 @@
 // RELAY_PROJECT always wins (deliberate override / crew inheritance). The hub
 // applies an alias map on top of this to fold any historical divergence.
 import { execSync } from "node:child_process";
-import { basename } from "node:path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { basename, join, dirname } from "node:path";
+import { homedir, hostname } from "node:os";
 
 export function gitRoot(dir) {
   try {
@@ -21,3 +23,24 @@ export function resolveProject(cwd = process.cwd()) {
   const root = gitRoot(cwd);
   return basename(root || cwd).slice(0, 80);
 }
+
+// Stable machine identity. os.hostname() is network-dependent — the same Mac reports
+// "MacBook-Pro-M1.local" on one network and "MacBookPro.hsd1.fl.comcast.net" on another, which
+// forks one machine into two session identities on the bus. Resolve a stable id ONCE and persist it
+// to ~/.agent-bus/machine-id so it never drifts: RELAY_HOST_ID > persisted id > macOS LocalHostName
+// (stable, no domain) > hostname() without its domain suffix.
+let _hostId = null;
+export function hostId() {
+  if (_hostId) return _hostId;
+  if (process.env.RELAY_HOST_ID) return (_hostId = process.env.RELAY_HOST_ID.slice(0, 60));
+  const f = join(homedir(), ".agent-bus", "machine-id");
+  try { if (existsSync(f)) { const v = readFileSync(f, "utf8").trim(); if (v) return (_hostId = v.slice(0, 60)); } } catch {}
+  let id = "";
+  if (process.platform === "darwin") {
+    try { id = execSync("scutil --get LocalHostName", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 1500 }).trim(); } catch {}
+  }
+  if (!id) id = String(hostname() || "host").split(".")[0];
+  id = id.slice(0, 60) || "host";
+  try { mkdirSync(dirname(f), { recursive: true }); writeFileSync(f, id); } catch {}
+  return (_hostId = id);
+}

package/mcp.mjs

@@ -10,7 +10,7 @@ import { join, basename } from "node:path";
 import { homedir, hostname } from "node:os";
 import { execSync, spawnSync } from "node:child_process";
 import { advise } from "./bin/advise.mjs";
-import { resolveProject } from "./lib/project.mjs";
+import { resolveProject, hostId } from "./lib/project.mjs";
 import { z } from "zod";
 
 function relayUrl() {
@@ -28,7 +28,7 @@ const PROJECT = resolveProject(process.env.CLAUDE_PROJECT_DIR || process.cwd());
 // Identity: RELAY_SESSION wins; else RELAY_AGENT ("codex", "kimi", …) brands the session per-project
 // (set it once in the CLI's global MCP config — works in every project); else hostname:project.
 const SESSION = process.env.RELAY_SESSION
-  || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${PROJECT}` : `${hostname()}:${PROJECT}`);
+  || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${PROJECT}` : `${hostId()}:${PROJECT}`);
 let cursor = 0;
 
 async function api(method, path, payload) {
@@ -48,11 +48,19 @@ server.tool("relay_whoami", "Show this session's relay identity, project, and th
 });
 
 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 }) => {
+  { 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 branch edges in the Flow view (e.g. integration depends on every crew card)"), phase: z.string().optional().describe("phase/milestone this card belongs to (e.g. 'P5', 'Auth', 'Launch') — groups it in the Flow view's phase flowchart. Optional; otherwise inferred from the title prefix + time."), 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, phase, 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}]` }] };
+    const { task } = await api("POST", "/task", { project: proj, title, status: status || "todo", assignee: assignee || SESSION, difficulty, model, deps, phase, by: SESSION });
+    return { content: [{ type: "text", text: `card #${task.id} added to ${proj}: "${title}" [${task.status}]${phase?` · phase ${phase}`:""}` }] };
+  });
+
+server.tool("relay_phase_goal", "Set what a PHASE is for — its goal — shown as the phase header in the Flow view (overrides the theme auto-derived from card titles). Capture this when you plan a phase so the board says what each milestone needs to do, not just 'P5'. Phase keys match relay_task_add's `phase` (or the inferred title-prefix family like 'P5').",
+  { phase: z.string().describe("the phase key (e.g. 'P5', 'Auth', 'Launch')"), goal: z.string().describe("1-2 sentences: what this phase delivers + done-criteria"), project: z.string().optional().describe("board (default: this session's project)") },
+  async ({ phase, goal, project }) => {
+    const proj = project || PROJECT;
+    await api("POST", "/phase", { project: proj, phase, goal, by: SESSION });
+    return { content: [{ type: "text", text: `phase "${phase}" goal set for ${proj}` }] };
   });
 
 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.",

package/package.json

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

package/ui.html

@@ -107,9 +107,14 @@ main:not(.learn-open) .learn-body{display:none}
 .sortmode:hover{color:var(--mut)}
 .proj.idle .proj-h{opacity:.55;cursor:pointer}
 /* flow (DAG) view */
-.vtog{display:flex;gap:2px;margin-left:10px}
-.vbtn{font-size:10px;font-weight:700;letter-spacing:.05em;padding:2px 9px;border-radius:10px;border:1px solid var(--line);background:var(--card);color:var(--dim);cursor:pointer}
-.vbtn.on{color:var(--grn);border-color:#1d4a44;background:#0f1d1b}
+/* view switcher — a clearly-labelled segmented control so it doesn't disappear next to the model chips */
+.vtog{display:inline-flex;align-items:stretch;margin-left:12px;border:1px solid #34465f;border-radius:11px;overflow:hidden;background:#0c121e;flex:none}
+.vtog .vlbl{display:flex;align-items:center;font-size:8.5px;font-weight:800;letter-spacing:.09em;color:var(--mut);padding:0 8px;text-transform:uppercase;background:#131c2c;border-right:1px solid #34465f}
+.vbtn{font-size:10.5px;font-weight:800;letter-spacing:.04em;padding:4px 13px;border:0;border-left:1px solid #1f2839;background:transparent;color:#9fb0c4;cursor:pointer}
+.vbtn:first-of-type{border-left:0}
+.vbtn:hover{background:#172339;color:var(--tx)}
+.vbtn.on{color:#04110e;background:var(--grn)}
+.vbtn.on:hover{background:var(--grn);color:#04110e}
 .flowwrap{padding:14px 16px;overflow:auto}
 .flowwrap svg{display:block}
 .fnode{cursor:pointer}
@@ -165,6 +170,34 @@ main:not(.learn-open) .learn-body{display:none}
 .tlgl svg{flex:none}
 .tlwrap .fhint{position:absolute;right:10px;bottom:6px;z-index:3}
 .tlnode{cursor:pointer}
+/* FLOW v2 = horizontal orchestrator-rooted flowchart TREE. A spine runs left→right; each phase is a
+   ◇ plan node that fans OUT (drawn edges) to its crew/LLM card nodes, then converges INTO a ◆ integrate
+   node, which connects to the next phase. Agent is a node property, not the axis. Native horizontal scroll. */
+.pflowwrap{background:#0b1019;border-top:1px solid var(--line)}
+.finfo{background:#1a2030;border:1px solid var(--line);border-radius:8px;padding:7px 10px;font-size:11px;color:var(--mut);margin:10px 14px 0}
+.pflowwrap.gflow{position:relative;padding-bottom:22px}
+.gscroll{overflow-x:auto;overflow-y:hidden;padding:4px 0 2px}
+.gscroll svg{display:block}
+.gedge{fill:none;stroke:#33405c;stroke-width:1.6;opacity:.8}
+.gedge.done{stroke:var(--grn2);opacity:.5}
+.gspine{fill:none;stroke:#5a6b86;stroke-width:2.5}
+.gnode{cursor:default}
+.gnode[data-id]{cursor:pointer}
+.gnbox{fill:#101827;stroke:rgba(255,255,255,.12);stroke-width:1}
+.gnode[data-id]:hover .gnbox{stroke:rgba(255,255,255,.55);fill:#162032}
+.gnode.orch .gnbox{fill:#0e1730;stroke:#2c3a55;stroke-dasharray:4 3}
+.gnode.failed .gnbox,.gnode.blocked .gnbox{stroke:var(--red)}
+.gntext{fill:#eaf1fa;font-size:11px;font-family:ui-sans-serif,system-ui;pointer-events:none}
+.gnsub{fill:var(--mut);font-size:9.5px;font-family:ui-sans-serif,system-ui;pointer-events:none}
+.pfband{fill:#0c1320;opacity:.45}
+.pfband.alt{fill:#0e1626;opacity:.55}
+.pfbandtop{opacity:.12}
+.pfbandtop.done{fill:var(--grn2)}.pfbandtop.active{fill:#f0b24b}.pfbandtop.failed,.pfbandtop.blocked{fill:var(--red)}.pfbandtop.planned{fill:#46566f}
+.pflabel{font-size:16px;font-weight:800;font-family:ui-sans-serif,system-ui}
+.pflabel.done{fill:var(--grn2)}.pflabel.active{fill:#f0b24b}.pflabel.failed{fill:var(--red)}.pflabel.planned,.pflabel.blocked{fill:#aeb9c8}
+.pfcount{fill:var(--mut);font-size:10.5px;font-family:ui-sans-serif,system-ui}
+.pfsub{fill:#9fb0c4;font-size:10.5px;font-family:ui-sans-serif,system-ui}
+.pflowwrap .fhint{position:absolute;right:12px;bottom:5px}
 /* card detail modal — the full story of one card: status journey + the agent's own bus reports */
 .cmodal{position:fixed;inset:0;z-index:60;display:flex;align-items:center;justify-content:center;background:rgba(4,7,12,.62)}
 .cmpanel{background:var(--panel);border:1px solid var(--line);border-radius:14px;width:min(760px,93vw);max-height:84vh;display:flex;flex-direction:column;box-shadow:0 20px 64px rgba(0,0,0,.55)}
@@ -309,6 +342,7 @@ 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 = {};
+let PHASES = {};
 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)
@@ -320,71 +354,104 @@ function moveProj(name,dir){
   [names[i],names[j]]=[names[j],names[i]];
   localStorage.setItem("abOrder",JSON.stringify(names)); render();
 }
-// FLOW = development timeline. Cards laid left→right in BUILD ORDER (even slots — bursts don't cram,
-// idle gaps don't waste space), one lane per agent, each card a readable FIXED-width block segmented
-// by the time it spent in each status. Natively scrollable left/right; lane labels pinned in a left
-// gutter; dependency edges converge = merges. (No proportional-time slivers, no zoom cut-off.)
-const TLSCROLL = {};
+// FLOW v2 = the project's TRUE shape: an orchestrator-rooted phase flowchart. The orchestrator is the
+// spine (the left rail); each PHASE blooms — ◇ plan → the crew fans out to its cards → ◆ converge —
+// then the next phase begins. Agent identity is a node badge, not the axis. Phases come from the hub
+// (/phases: title-prefix + time-cluster; deps-sparse boards fall back to time + a visible notice).
+// Each crew node keeps its full /card detail on click.
 function flowHTML(pt, proj){
-  if (!pt.length) return '<div class="empty">no cards yet</div>';
-  const NOW = Date.now();
+  const data = PHASES[proj];
+  if (!data) return '<div class="pflowwrap"><div class="empty">loading flow…</div></div>';
+  if (!data.phases || !data.phases.length) return '<div class="pflowwrap"><div class="empty">no cards yet</div></div>';
   const SCOL = { todo:'#3a4458', doing:'#4a90d9', testing:'#f59e0b', failed:'#ef6a6a', blocked:'#ef6a6a', done:'#14b8a6' };
-  const GUT = 96, TH = 24, ROW = 42, BAR = 26, SLOT = 188, CW = 172, PAD = 10;
-  const cards = pt.map(t => {
-    const h = (t.history && t.history.length) ? t.history.slice() : [{ to: t.status || 'todo', ts: t.ts || NOW }];
-    return { t, h, tStart: h[0].ts || t.ts || NOW, tEnd: (t.status === 'done' ? (h[h.length-1].ts || NOW) : NOW) };
+  const NW = 168, NH = 34, RG = 11, CG = 64, PGAP = 76, MT = 64, MB = 22;
+  const stackH = n => n*NH + Math.max(0,n-1)*RG;
+  // Per-phase layout: cards spread by their INTRA-PHASE dependency depth. Independent cards share
+  // column 0 (parallel, hanging off the plan node); a card that depends on another lands one column
+  // to the right of its parent (a branch/chain). Leaves (no dependents) converge into integrate.
+  const layouts = data.phases.map(ph => {
+    const work = [...ph.crew.map(n => ({ ...n, _orch:false })), ...ph.orchestrators.map(n => ({ ...n, _orch:true }))];
+    const cards = work.length ? work : [{ id:0, title:'(no cards)', status:ph.status, agent:'', synthetic:true, deps:[] }];
+    const idSet = new Set(cards.map(c => c.id)); const byId = {}; cards.forEach(c => byId[c.id] = c);
+    const parentsOf = c => (c.deps || []).filter(d => idSet.has(d) && d !== c.id);
+    const dmemo = {}; const depth = (c, seen) => {
+      if (dmemo[c.id] != null) return dmemo[c.id];
+      seen = seen || new Set(); if (seen.has(c.id)) return 0; seen.add(c.id);
+      const ps = parentsOf(c); const d = ps.length ? Math.max(...ps.map(p => depth(byId[p], seen))) + 1 : 0;
+      return (dmemo[c.id] = d);
+    };
+    cards.forEach(c => c._d = depth(c));
+    const maxDepth = Math.max(0, ...cards.map(c => c._d));
+    const cols = []; for (let d = 0; d <= maxDepth; d++) cols[d] = cards.filter(c => c._d === d);
+    const hasChild = c => cards.some(o => parentsOf(o).includes(c.id));
+    return { ph, cards, byId, parentsOf, hasChild, maxDepth, cols };
   });
-  cards.sort((a,b)=> a.tStart - b.tStart || a.t.id - b.t.id);
-  cards.forEach((c,i)=> c.col = i);
-  const byId = {}; for (const c of cards) byId[c.t.id] = c;
-  const laneKey = t => (String(t.assignee || 'unassigned').split(':')[0] || 'unassigned');
-  const laneFirst = {}; for (const c of cards){ const k = laneKey(c.t); if (laneFirst[k] == null) laneFirst[k] = c.col; }
-  const lanes = [...new Set(cards.map(c => laneKey(c.t)))].sort((a,b)=> laneFirst[a]-laneFirst[b]);
-  const laneIdx = Object.fromEntries(lanes.map((k,i)=>[k,i]));
-  const X = col => GUT + col*SLOT + PAD;
-  const laneY = i => TH + i*ROW + (ROW-BAR)/2;
-  const totalW = GUT + cards.length*SLOT + 24, totalH = TH + lanes.length*ROW + 8;
-  let svg = '';
-  for (let i=0;i<lanes.length;i++){ const yb = TH + i*ROW;
-    if (i%2) svg += `<rect class="tlband" x="${GUT}" y="${yb}" width="${totalW-GUT}" height="${ROW}"/>`;
-    svg += `<line class="tlsep" x1="${GUT}" y1="${yb}" x2="${totalW}" y2="${yb}"/>`;
-  }
-  // build-order time markers (every few cards, label that card's real timestamp) — scroll with the chart
-  const step = Math.max(1, Math.round(cards.length/12));
-  for (let i=0;i<cards.length;i+=step){ const xx = X(cards[i].col) + CW/2;
-    svg += `<line class="tlgrid" x1="${xx}" y1="${TH}" x2="${xx}" y2="${totalH-6}"/>`;
-    svg += `<text class="tlt" x="${xx}" y="15">${esc(new Date(cards[i].tStart).toLocaleString([], {month:'short',day:'numeric',hour:'2-digit',minute:'2-digit'}))}</text>`;
-  }
-  for (const c of cards) for (const d of (c.t.deps||[])){ const A = byId[d]; if (!A) continue;
-    const x1 = X(A.col)+CW, y1 = laneY(laneIdx[laneKey(A.t)])+BAR/2, x2 = X(c.col), y2 = laneY(laneIdx[laneKey(c.t)])+BAR/2, mx = (x1+x2)/2;
-    svg += `<path class="tledge ${A.t.status==='done'?'done':''}" marker-end="url(#tarr)" d="M${x1},${y1} C${mx},${y1} ${mx},${y2} ${x2},${y2}"/>`;
-  }
-  for (const c of cards){ const xx = X(c.col), yy = laneY(laneIdx[laneKey(c.t)]), dur = Math.max(1, c.tEnd - c.tStart);
-    svg += `<g class="tlnode ${c.t.status}" data-id="${c.t.id}"><title>${esc(c.t.title)} — ${c.t.status} · @${esc(laneKey(c.t))}\n${esc(new Date(c.tStart).toLocaleString())}</title>`;
-    let sx = xx;
-    for (let i=0;i<c.h.length;i++){ const s0 = c.h[i].ts || c.tStart, s1 = (i+1<c.h.length) ? (c.h[i+1].ts||s0) : c.tEnd;
-      const w = Math.max(1.5, (Math.max(0, s1-s0)/dur)*CW);
-      svg += `<rect x="${sx.toFixed(1)}" y="${yy}" width="${w.toFixed(1)}" height="${BAR}" fill="${SCOL[c.h[i].to]||'#3a4458'}"/>`; sx += w;
+  const maxColCount = Math.max(1, ...layouts.flatMap(L => L.cols.map(c => c.length)));
+  const Y0 = MT + stackH(maxColCount)/2;               // shared horizontal spine midline
+  const totalH = MT + stackH(maxColCount) + MB;
+  const gnode = (x, y, title, status, id, orch, agent) => {
+    const stripe = SCOL[status] || '#3a4458';
+    return `<g class="gnode ${status}${orch?' orch':''}"${id?` data-id="${id}"`:''}>`
+      + `<rect class="gnbox" x="${x}" y="${y}" width="${NW}" height="${NH}" rx="8"/>`
+      + `<rect x="${x}" y="${y}" width="4" height="${NH}" rx="2" fill="${stripe}"/>`
+      + `<text class="gntext" x="${x+11}" y="${y+(agent?15:23)}">${esc(title.slice(0,24))}${title.length>24?'…':''}</text>`
+      + (agent?`<text class="gnsub" x="${x+11}" y="${y+29}">@${esc(agent)}</text>`:'')
+      + `<title>${esc(title)}${agent?' · @'+esc(agent):''} — ${status}</title></g>`;
+  };
+  const gedge = (x1,y1,x2,y2,done) => { const mx=(x1+x2)/2;
+    return `<path class="gedge${done?' done':''}" d="M${x1},${y1} C${mx},${y1} ${mx},${y2} ${x2},${y2}"/>`; };
+  let x = 26, svg = '', bands = '', prevIntRight = null, pi = 0;
+  for (const L of layouts){
+    const { ph, cards, byId, parentsOf, hasChild, maxDepth, cols } = L;
+    const planX = x, planY = Y0 - NH/2;
+    const colX = d => planX + (d+1)*(NW+CG);
+    const intX = colX(maxDepth + 1), intY = Y0 - NH/2;
+    // per-phase background band (alternating) so each phase reads as one region; collected separately
+    // so all bands paint BEHIND the edges/nodes. The header sits inside the band's top strip.
+    const bx = planX - 16, bw = (intX + NW + 16) - bx;
+    bands += `<rect class="pfband ${pi%2?'alt':''}" x="${bx}" y="2" width="${bw}" height="${totalH-4}" rx="10"/>`
+          +  `<rect class="pfbandtop ${ph.status}" x="${bx}" y="2" width="${bw}" height="${MT-12}" rx="10"/>`;
+    // header: phase label + the GOAL (explicit) or derived THEME — "what this phase is about"
+    const desc = (ph.goal || ph.theme || '').slice(0, Math.max(28, Math.floor(bw/7)));
+    svg += `<text class="pflabel ${ph.status}" x="${planX}" y="${MT-38}">${esc(ph.label)}</text>`
+        +  `<text class="pfcount" x="${planX}" y="${MT-38}" dx="${(esc(ph.label).length*9)+12}">${ph.status} · ${ph.total} card${ph.total>1?'s':''}</text>`
+        +  `<text class="pfsub" x="${planX}" y="${MT-21}">${esc(desc)}</text>`;
+    if (prevIntRight != null) svg += `<path class="gspine" marker-end="url(#garr)" d="M${prevIntRight},${Y0} L${planX},${Y0}"/>`;
+    svg += gnode(planX, planY, '◇ '+ph.label+' · plan', ph.status, null, true, '');
+    // position every card: x by dep-depth column, y stacked + centered on the spine within its column
+    const pos = {};
+    cols.forEach((colCards, d) => {
+      const startY = Y0 - stackH(colCards.length)/2;
+      colCards.forEach((c, k) => { pos[c.id] = { x: colX(d), y: startY + k*(NH+RG) }; });
+    });
+    for (const c of cards){
+      const p = pos[c.id], parents = parentsOf(c);
+      if (parents.length) for (const pid of parents){ const pp = pos[pid]; if (pp) svg += gedge(pp.x+NW, pp.y+NH/2, p.x, p.y+NH/2, byId[pid].status==='done'); }
+      else svg += gedge(planX+NW, planY+NH/2, p.x, p.y+NH/2, ph.status==='done');   // root → plan
+      svg += gnode(p.x, p.y, (c.id?'#'+c.id+' ':'')+c.title, c.status, c.synthetic?null:c.id, !!c._orch, c.agent||'');
+      if (!hasChild(c)) svg += gedge(p.x+NW, p.y+NH/2, intX, intY+NH/2, c.status==='done');   // leaf → integrate
     }
-    svg += `<rect class="tlbar" x="${xx}" y="${yy}" width="${CW}" height="${BAR}" rx="5"/>`;
-    svg += `<text class="tltitle" x="${xx+7}" y="${yy+BAR/2+4}">${esc(c.t.title.slice(0,25))}${c.t.title.length>25?'…':''}</text>`;
-    svg += `</g>`;
+    svg += gnode(intX, intY, '◆ integrate', ph.status, null, true, '');
+    prevIntRight = intX + NW;
+    x = intX + NW + PGAP;
+    pi++;
   }
-  const defs = `<defs><marker id="tarr" viewBox="0 0 8 8" refX="7" refY="4" markerWidth="6" markerHeight="6" orient="auto"><path d="M0,0 L8,4 L0,8 z" fill="#14b8a6"/></marker></defs>`;
-  let gut = `<div class="tlgut" style="width:${GUT}px"><div class="tlguth" style="height:${TH}px">time →</div>`;
-  for (const k of lanes) gut += `<div class="tlgl" style="height:${ROW}px">${iconFor(k,13)}<span>${esc(k)}</span></div>`;
-  gut += `</div>`;
-  return `<div class="tlwrap" data-proj="${esc(proj)}" style="height:${Math.min(totalH+14, 540)}px">`
-    + `<div class="tlscroll" data-proj="${esc(proj)}"><svg width="${totalW}" height="${totalH}">${defs}${svg}</svg></div>`
-    + gut + `<div class="fhint">build order →  ·  scroll left/right</div></div>`;
+  const totalW = x + 10;
+  const defs = `<defs><marker id="garr" viewBox="0 0 8 8" refX="7" refY="4" markerWidth="6" markerHeight="6" orient="auto"><path d="M0,0 L8,4 L0,8 z" fill="#46566f"/></marker></defs>`;
+  const notice = data.sparse ? `<div class="finfo">⚠ inferred phases — few cards carry explicit tags (P1/P5…), so they're grouped by time + title. Prefix cards (e.g. "P6 …") for sharper phases.</div>` : '';
+  return `<div class="pflowwrap gflow" data-proj="${esc(proj)}">${notice}`
+    + `<div class="gscroll" data-proj="${esc(proj)}"><svg width="${totalW}" height="${totalH}">${defs}${bands}${svg}</svg></div>`
+    + `<div class="fhint">orchestrator → crew → integrate · phase by phase  ·  scroll left/right →</div></div>`;
 }
+const GSCROLL = {};
 function wireTimeline(el){
-  el.querySelectorAll('.tlscroll').forEach(s => {
+  // FLOW v2 graph: click a card node to open its full /card detail; preserve horizontal scroll per project.
+  el.querySelectorAll('.gscroll').forEach(s => {
     const proj = s.dataset.proj;
-    if (TLSCROLL[proj] != null) s.scrollLeft = TLSCROLL[proj];
-    s.onscroll = () => { TLSCROLL[proj] = s.scrollLeft; };
+    if (GSCROLL[proj] != null) s.scrollLeft = GSCROLL[proj];
+    s.onscroll = () => { GSCROLL[proj] = s.scrollLeft; };
   });
-  el.querySelectorAll('.tlnode').forEach(n => n.onclick = () => openCard(+n.dataset.id));
+  el.querySelectorAll('.gnode[data-id]').forEach(n => n.onclick = () => openCard(+n.dataset.id));
 }
 // Card detail modal: one card's FULL story — its status journey interleaved with the agent's own bus
 // reports (what it did, why, how). Click any card in the FLOW timeline to open it.
@@ -531,7 +598,10 @@ async function render(){
       HISTORY[p.project] = h.events || [];
     } catch(e) {}
   });
-  await Promise.all(histP);
+  const phaseP = projects.filter(p => VIEWS[p.project] === "flow").map(async p => {
+    try { PHASES[p.project] = await (await fetch(`/phases?project=${encodeURIComponent(p.project)}`)).json(); } catch(e) {}
+  });
+  await Promise.all([...histP, ...phaseP]);
 
   // 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;}
@@ -586,7 +656,7 @@ async function render(){
     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 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><button class="vbtn ${view==="timeline"?"on":""}" data-proj="${esc(p.project)}" data-view="timeline">TIMELINE</button></div>`;
+    const vtog = `<div class="vtog"><span class="vlbl">view</span><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)}"`:''}>`+