trantor 0.17.40 → 0.17.42

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.40",
+  "version": "0.17.42",
   "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + crew orchestration for independent AI coding agents (Claude, Codex, Gemini, Kimi, DeepSeek)",
   "mcpServers": {
     "relay": {

package/hooks/hooks.json

@@ -1,11 +1,15 @@
 {
-  "description": "trantor — auto-register each session + inject live roster (SessionStart); heartbeat presence on every tool call + mirror the session's TodoWrite list onto the board as cards (PostToolUse); write a handoff before compaction (PreCompact); card each sub-agent's notional API cost when it finishes (SubagentStop)",
+  "description": "trantor — auto-register each session + inject live roster (SessionStart); post an in-flight 'doing' card when a sub-agent is dispatched (PreToolUse); heartbeat presence on every tool call + deliver unread bus messages to a busy session mid-turn + mirror the session's TodoWrite list onto the board as cards (PostToolUse); write a handoff before compaction (PreCompact); card each sub-agent's notional API cost when it finishes (SubagentStop)",
   "hooks": {
     "SessionStart": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/sessionstart.mjs" } ] }
     ],
+    "PreToolUse": [
+      { "matcher": "Task|Agent", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/subagent-start.mjs" } ] }
+    ],
     "PostToolUse": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/heartbeat.mjs" } ] },
+      { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/inbox-deliver.mjs" } ] },
       { "matcher": "TodoWrite", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/todo-sync.mjs" } ] }
     ],
     "PreCompact": [

package/hooks/inbox-deliver.mjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+// trantor PostToolUse inbox delivery — surface bus messages to a BUSY session.
+//
+// The bug this fixes: Trantor message delivery is pure pull-on-demand. relay_send only
+// enqueues on the hub; the recipient learns of a message ONLY when the model itself
+// chooses to call relay_inbox/relay_wait. A session grinding through a long tool-use loop
+// never makes that choice, so it sits "online" (the heartbeat keeps lastSeen fresh) but
+// DEAF — a peer can ping it twice over 10 minutes and get no reply. (Observed 2026-06-23:
+// a new session pinged a mid-build sibling; the sibling never answered because it was busy
+// and never polled.)
+//
+// The fix, hook-side (don't trust the model to poll): a busy session IS firing tool calls,
+// so this PostToolUse hook runs constantly. Each run polls /inbox and injects any NEW peer
+// messages via hookSpecificOutput.additionalContext — which Claude Code delivers as a
+// system reminder the model acts on IN THE SAME TURN, between its own tool calls. So a ping
+// lands within a few seconds even mid-build, and the model can reply via relay_send without
+// waiting for the human to prompt it.
+//
+// Cheap + fail-silent by contract: a per-session poll stamp gates the network call, a short
+// fetch timeout means we never add real latency, and we ALWAYS exit clean with valid stdout.
+// First run initialises the cursor to "now" (current max id) and injects NOTHING, so a
+// session is never flooded with the whole backlog of old broadcasts on its first tool call.
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { resolveProject, hostId } from "../lib/project.mjs";
+
+const POLL_MS = Number(process.env.RELAY_INBOX_POLL_MS || 4000);
+const FETCH_TIMEOUT_MS = Number(process.env.RELAY_INBOX_TIMEOUT_MS || 1500);
+
+function relayUrl() {
+  if (process.env.RELAY_URL) return process.env.RELAY_URL;
+  try {
+    const cfg = join(homedir(), ".agent-bus", "config.json");
+    if (existsSync(cfg)) { const u = JSON.parse(readFileSync(cfg, "utf8")).url; if (u) return u; }
+  } catch {}
+  return "http://127.0.0.1:4477";
+}
+
+// Keep injected text safe to embed in JSON: drop control chars that could corrupt the
+// additionalContext payload (the model still gets the readable message).
+function sanitize(s) { return String(s == null ? "" : s).replace(/[\x00-\x1f\x7f-\x9f]/g, " "); }
+
+async function getInbox(url, session, since) {
+  const r = await fetch(`${url}/inbox?session=${encodeURIComponent(session)}&since=${since}`,
+    { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+  if (!r.ok) throw new Error(`hub ${r.status}`);
+  return r.json();   // { messages: [...], cursor }
+}
+
+// PostToolUse hands us the tool-input JSON on stdin. We don't need it, but we must DRAIN it:
+// a large tool input (e.g. a big Write) can exceed the 64KB pipe buffer and block the parent's
+// write if nobody reads. Consume + discard, with a short timeout so we never hang.
+function drainStdin() {
+  return new Promise(res => {
+    try { process.stdin.resume(); process.stdin.on("data", () => {}); process.stdin.on("end", res); }
+    catch { res(); }
+    setTimeout(res, 80);
+  });
+}
+
+// Self-validating stdout: model-facing additionalContext only when we actually deliver.
+function emit(ctx) {
+  if (!ctx) return "{}";
+  const obj = { hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: ctx } };
+  const out = JSON.stringify(obj);
+  try { JSON.parse(out); return out; } catch { return "{}"; }
+}
+
+async function main() {
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  // Mirror heartbeat.mjs / sessionstart.mjs: a home-directory session isn't project work and
+  // isn't on the bus — nothing to deliver. Opt in with RELAY_SESSION / RELAY_PROJECT.
+  if (!process.env.RELAY_SESSION && !process.env.RELAY_PROJECT && projectDir === homedir()) return "{}";
+
+  // Resolve THIS session's identity EXACTLY as mcp.mjs / heartbeat.mjs do, so we poll the
+  // same peer the relay registered (RELAY_SESSION wins; else RELAY_AGENT brand; else host:project).
+  const project = resolveProject(projectDir);
+  const session = process.env.RELAY_SESSION
+    || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${project}` : `${hostId()}:${project}`);
+
+  const safe = session.replace(/[^A-Za-z0-9_.-]/g, "_");
+  const dir = join(homedir(), ".agent-bus");
+  const pollStamp = join(dir, `inbox-poll-${safe}.stamp`);
+  const cursorFile = join(dir, `inbox-cursor-${safe}.id`);
+
+  // Throttle: poll the hub at most once per POLL_MS. Write the stamp BEFORE the network call
+  // so a burst of parallel tool calls doesn't all fire (and double-deliver).
+  try {
+    if (existsSync(pollStamp)) {
+      const last = Number(readFileSync(pollStamp, "utf8")) || 0;
+      if (Date.now() - last < POLL_MS) return "{}";   // within window — skip
+    }
+  } catch {}
+  try { writeFileSync(pollStamp, String(Date.now())); } catch {}
+
+  const url = relayUrl();
+
+  // First run: no cursor yet. Initialise to the current max deliverable id and inject NOTHING,
+  // so we start listening "from now" instead of replaying the whole backlog of old broadcasts.
+  if (!existsSync(cursorFile)) {
+    try {
+      const { cursor } = await getInbox(url, session, 0);
+      writeFileSync(cursorFile, String(cursor || 0));
+    } catch {}
+    return "{}";
+  }
+
+  let cursor = 0;
+  try { cursor = Number(readFileSync(cursorFile, "utf8")) || 0; } catch {}
+
+  let messages = [], next = cursor;
+  try {
+    const res = await getInbox(url, session, cursor);
+    messages = Array.isArray(res.messages) ? res.messages : [];
+    next = res.cursor || cursor;
+  } catch { return "{}"; }   // hub down / timeout — never block the tool flow
+
+  if (!messages.length) return "{}";
+
+  // Advance the cursor immediately so we don't re-inject these on the next tool call.
+  try { writeFileSync(cursorFile, String(next)); } catch {}
+
+  const lines = messages.map(m => {
+    const direct = m.to === session;
+    const tag = direct ? "📨 DIRECT" : "📣 broadcast";
+    const when = (() => { try { return new Date(m.ts).toLocaleTimeString(); } catch { return ""; } })();
+    return `- ${tag} from ${sanitize(m.from)}${when ? ` (${when})` : ""}: ${sanitize(m.text)}`;
+  });
+
+  const ctx =
+    `<trantor-inbox count="${messages.length}">\n` +
+    `📬 ${messages.length} new bus message(s) arrived while you were working (you did not poll for these — Trantor surfaced them automatically):\n` +
+    lines.join("\n") + `\n` +
+    `If a peer is asking you something or waiting on you, reply now with the relay_send tool (to their session id). ` +
+    `If a message just needs an ack, send a short one. You can keep working after responding.\n` +
+    `</trantor-inbox>\n`;
+
+  return emit(ctx);
+}
+
+// Never block or break the tool flow: drain stdin, swallow everything, always emit valid stdout.
+drainStdin()
+  .then(main)
+  .then(out => { try { process.stdout.write(out || "{}"); } catch {} })
+  .catch(() => { try { process.stdout.write("{}"); } catch {} })
+  .finally(() => process.exit(0));

package/hooks/sessionstart.mjs

@@ -94,11 +94,35 @@ function sanitize(s) {
   return out;
 }
 
+// Session title for the picker / `claude --resume` / Claude mobile. Claude Code otherwise names a session
+// after its FIRST PROMPT (the `ai-title` transcript entry) — so several sessions started with the same
+// prompt (or sibling sessions in different projects) all look alike. We name it "<project> · <current work>"
+// where the work is the single most relevant in-flight item from the board, so concurrent sessions are
+// instantly distinguishable. (SessionStart can set the title via hookSpecificOutput.sessionTitle; it has no
+// mid-session rename, so this reflects the project's state at startup.)
+function sessionTitleFrom(project, cu) {
+  let work = "";
+  if (cu) {
+    // prefer real work cards (doing → testing → todo), skipping transient cc-subagent infra cards which
+    // would otherwise dominate "most recent" and make every session title noise; then the project brief.
+    const real = a => (Array.isArray(a) ? a.filter(t => t.source !== "cc-subagent") : []);
+    const first = a => (a.length ? a[0].title : "");
+    work = first(real(cu.doing)) || first(real(cu.testing)) || first(real(cu.todo)) || cu.brief || "";
+  }
+  work = String(work || "").replace(/\s+/g, " ").trim()
+    .replace(/^v?\d+\.\d+\.\d+\s*[:—–•·-]\s*/i, "");   // drop a leading release-version prefix (just noise here)
+  if (work.length > 44) work = work.slice(0, 43).trimEnd() + "…";
+  return sanitize(work ? `${project} · ${work}` : project).slice(0, 90);
+}
+
 let additionalContext = "";
 let userBanner = "";   // shown to the USER in-terminal via the hook's `systemMessage` (not model-only context)
+let sessionTitle = "";  // picker / --resume / mobile title — set to "<project> · <current work>" below
+let userTitle = "";     // a title the USER set explicitly (--name / rename); never override it
 try {
   let source = "", stdinObj = {};
   try { stdinObj = JSON.parse((await readStdin()) || "{}"); source = stdinObj.source || ""; } catch {}
+  userTitle = (stdinObj && stdinObj.session_title) ? String(stdinObj.session_title) : "";   // user already named it
   const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
   // Sessions started in the home directory itself aren't project work — registering
   // them spawns a phantom "<username>" project board on the dashboard. Set
@@ -109,6 +133,7 @@ try {
     process.exit(0);
   }
   const project = resolveProject(projectDir);
+  sessionTitle = project;   // baseline — enriched with the current work item after the catch-up fetch below
   const session = process.env.RELAY_SESSION
     || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${project}` : `${hostId()}:${project}`);
   const url = relayUrl();
@@ -137,6 +162,7 @@ try {
   // SAME project where it stands instead of starting blind. Cheap + LLM-free.
   try {
     const cu = await jget(`${url}/catchup?project=${encodeURIComponent(project)}`).catch(() => null);
+    sessionTitle = sessionTitleFrom(project, cu);   // "<project> · <current work>" for the picker/--resume/mobile
     let gitlog = "";
     try { gitlog = execSync(`git -C ${JSON.stringify(projectDir)} log --oneline -5 2>/dev/null`, { encoding: "utf8", timeout: 2500 }).trim(); } catch {}
     if ((cu && cu.total > 0) || gitlog) {
@@ -248,18 +274,21 @@ try {
 // Hook protocol: emit additionalContext (model-facing) via stdout JSON, plus an optional
 // `systemMessage` (USER-facing — rendered as a line in the terminal, our update indicator).
 // Self-validate so we never emit something Claude Code can't parse — fall back to sanitized, then {}.
-function emit(ctx, sysMsg) {
+function emit(ctx, sysMsg, title) {
   const obj = {};
   if (ctx) obj.hookSpecificOutput = { hookEventName: "SessionStart", additionalContext: ctx };
+  if (title) (obj.hookSpecificOutput ||= { hookEventName: "SessionStart" }).sessionTitle = title;
   if (sysMsg) obj.systemMessage = sysMsg;
   const out = JSON.stringify(obj);
   try { JSON.parse(out); return out; } catch { /* fall through */ }
   try {
     const safe = {};
     if (ctx) safe.hookSpecificOutput = { hookEventName: "SessionStart", additionalContext: sanitize(ctx) };
+    if (title) (safe.hookSpecificOutput ||= { hookEventName: "SessionStart" }).sessionTitle = sanitize(title);
     if (sysMsg) safe.systemMessage = sanitize(sysMsg);
     return JSON.stringify(safe);
   } catch { return "{}"; }
 }
-process.stdout.write(emit(additionalContext, userBanner));
+// Set the session title unless the user already named it explicitly (--name / rename).
+process.stdout.write(emit(additionalContext, userBanner, userTitle ? "" : sessionTitle));
 process.exit(0);

package/hooks/subagent-start.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// trantor PreToolUse hook (Task|Agent) — when a sub-agent is DISPATCHED, post an in-flight "doing" card so
+// the board shows work IN PROGRESS while it runs. The existing SubagentStop hook (subagent-cost.mjs) flips
+// the matching card to "done" via the hub's cc-subagent title-fingerprint dedup. Without this, every auto-
+// card was born "done" (SubagentStop/git-backfill) so nothing ever showed as in progress. Fail-silent:
+// never block or delay the dispatch.
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { resolveProject, hostId } from "../lib/project.mjs";
+
+function readStdin() {
+  return new Promise(res => { let d = ""; process.stdin.setEncoding("utf8");
+    process.stdin.on("data", c => (d += c)); process.stdin.on("end", () => res(d));
+    setTimeout(() => res(d), 100); });
+}
+function relayUrl() {
+  if (process.env.RELAY_URL) return process.env.RELAY_URL;
+  try { const c = join(homedir(), ".agent-bus", "config.json"); if (existsSync(c)) { const u = JSON.parse(readFileSync(c, "utf8")).url; if (u) return u; } } catch {}
+  return "http://127.0.0.1:4477";
+}
+
+try {
+  const input = JSON.parse((await readStdin()) || "{}");
+  const ti = input.tool_input || {};
+  const cwd = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const project = resolveProject(cwd);
+  const agentType = String(ti.subagent_type || "subagent").slice(0, 40);
+  // MUST mirror subagent-cost.mjs's title derivation (lines 100-101) so the hub's title fingerprint pairs
+  // this start card with the SubagentStop "done" card into ONE rolling cc-subagent card.
+  const task = String(ti.prompt || ti.description || agentType).replace(/\s+/g, " ").trim().slice(0, 90);
+  const title = `${agentType}: ${task}`.slice(0, 180);
+  await fetch(`${relayUrl()}/task`, {
+    method: "POST", headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      project, title, status: "doing",
+      assignee: `${agentType}:${project}`, by: `${hostId()}:${project}`,
+      source: "cc-subagent", costKind: "subagent-notional", phase: "sub-agents",
+    }),
+    signal: AbortSignal.timeout(1500),
+  }).catch(() => {});
+} catch (e) {
+  process.stderr.write(`[trantor] subagent-start error: ${e?.message || e}\n`);
+}
+process.stdout.write("{}");
+process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.40",
+  "version": "0.17.42",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"
@@ -10,7 +10,7 @@
     "zod": "^4.4.3"
   },
   "scripts": {
-    "test": "node test.mjs && node test-scenarios.mjs && node test-failure.mjs && node test-handoff.mjs && node test-agents.mjs && node test-update.mjs && node test-handoff-guard.mjs && node test-balances.mjs && node test-subagent-cost.mjs"
+    "test": "node test.mjs && node test-scenarios.mjs && node test-failure.mjs && node test-handoff.mjs && node test-agents.mjs && node test-update.mjs && node test-handoff-guard.mjs && node test-balances.mjs && node test-subagent-cost.mjs && node test-inbox.mjs && node test-inflight.mjs"
   },
   "description": "The hub-world for AI agent crews — orchestrate Claude Code, Codex, Gemini, Kimi & DeepSeek as live crews with a plan-aware Advisor, a Kanban/flow command center, a testing gate, and an economics brain (Scrooge).",
   "files": [

package/ui.html

@@ -15,6 +15,24 @@ header{display:flex;align-items:center;gap:13px;padding:11px 18px;border-bottom:
 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}
+/* Project-tab strip (between header + main): jump to a project (multi) or switch focus (solo). */
+.ptabs{display:flex;gap:6px;align-items:center;padding:7px 18px;border-bottom:1px solid var(--line);background:var(--panel);overflow-x:auto;white-space:nowrap}
+.ptab{display:inline-flex;align-items:center;gap:6px;font:inherit;font-size:11px;font-weight:600;color:var(--mut);background:#0c121e;border:1px solid #34465f;border-radius:11px;padding:4px 10px;cursor:pointer;white-space:nowrap;text-decoration:none;flex:none}
+.ptab:hover{color:var(--tx);border-color:var(--grn)}
+.ptab.on{color:#06120c;background:var(--grn);border-color:var(--grn)}
+.ptab.live::before{content:"";width:6px;height:6px;border-radius:50%;background:var(--grn);box-shadow:0 0 6px var(--grn);flex:none}
+.ptab.home{color:var(--dim);font-weight:700}
+/* per-project "open in its own window" pop-out icon */
+.popout{color:var(--mut);text-decoration:none;font-size:16px;line-height:1;cursor:pointer;flex:none}
+.popout:hover{color:var(--grn)}
+.proj.flash{animation:flashp 1.2s ease}
+@keyframes flashp{0%,100%{box-shadow:none}30%{box-shadow:0 0 0 2px var(--grn)}}
+/* SOLO = single-project full-window (deep link ?project=<name>): hide side rails, board fills the window. */
+body.solo main{grid-template-columns:1fr}
+body.solo .learn,body.solo aside{display:none}
+body.solo .boards{padding:0}
+body.solo .popout{display:none}
+body.solo .proj{margin:0;border:none;border-radius:0}
 /* 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}
@@ -275,6 +293,7 @@ aside h2{font-size:10.5px;text-transform:uppercase;letter-spacing:.09em;color:va
   <span class="pill" id="credits" title="Provider credit left — $ balance (prepaid) or % quota (coding plans). Refill/pace before a build stalls. Pushed by sessions/CLI (the hub has no keys)." 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>
+<div class="ptabs" id="ptabs" style="display:none"></div>
 <main>
   <section class="learn" id="learn">
     <div class="learn-head" id="learnToggle" title="Learning — lessons, per-LLM reliability, baked-in guardrails">
@@ -303,6 +322,9 @@ const usd=(n,dp=2)=>(Number(n)||0).toLocaleString('en-US',{minimumFractionDigits
 const $usd=(n,sym='$',dp=2)=>sym+usd(n,dp);
 const COLS=[['todo','To Do'],['doing','In Progress'],['testing','Testing'],['done','Done'],['blocked','Blocked']];
 let nmsg=0;
+// SOLO = single-project full-window mode via deep link ?project=<name>. Parsed once (search is static
+// per load). When set, render() shows ONLY that project's board/FLOW/TIMELINE and hides the side rails.
+const SOLO=(()=>{try{return decodeURIComponent(new URLSearchParams(location.search).get('project')||'');}catch(e){return new URLSearchParams(location.search).get('project')||'';}})();
 
 /* ---- LLM provider icons (lobehub SVGs — same set used across crebral.ai) ----
    Keyed by the AI coding-CLI brand parsed from a session id (e.g. "claude:crebral"). */
@@ -715,6 +737,26 @@ function chatLane(msgs){
   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('');
   return `<div class="proj-chat"><h5><span class="lc"></span>conversation · ${msgs.length}</h5><div class="chatlog">${rows}</div></div>`;
 }
+// Top project-tab strip: chips for every real project. In SOLO it switches the focused project (navigates);
+// in the multi-project view it smooth-scrolls to that project's section. The current SOLO project is hilit.
+function renderTabStrip(projects){
+  const strip=$('#ptabs');if(!strip)return;
+  const real=projects.filter(p=>p.project&&p.project!=='(unassigned)');
+  if(!real.length){strip.style.display='none';return;}
+  strip.style.display='';
+  const chips=real.map(p=>{
+    const on=SOLO&&(p.project===SOLO||p.project.toLowerCase()===SOLO.toLowerCase());
+    const live=(p.agents||[]).some(a=>a.online);
+    return `<button class="ptab${on?' on':''}${live?' live':''}" data-proj="${esc(p.project)}" title="${esc(p.project)}"><span>${esc(p.project)}</span></button>`;
+  }).join('');
+  strip.innerHTML=(SOLO?`<a class="ptab home" href="${esc(location.pathname)}" title="back to all projects">⌂ all</a>`:'')+chips;
+  strip.querySelectorAll('.ptab[data-proj]').forEach(b=>b.onclick=()=>{
+    const name=b.dataset.proj;
+    if(SOLO){location.search='?project='+encodeURIComponent(name);return;}
+    const sec=document.querySelector(`.proj[data-projname="${CSS.escape(name)}"], .idle-row[data-projname="${CSS.escape(name)}"]`);
+    if(sec){sec.scrollIntoView({behavior:'smooth',block:'start'});sec.classList.add('flash');setTimeout(()=>sec.classList.remove('flash'),1200);}
+  });
+}
 async function render(){
   let projects=[],tasks=[],msgs=[];
   try{projects=(await (await fetch('/projects')).json()).projects||[];}catch(e){}
@@ -790,7 +832,7 @@ async function render(){
     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-h"><span class="pname">📁 <b>${esc(p.project)}</b></span><a class="popout" href="?project=${encodeURIComponent(p.project)}" target="_blank" rel="noopener" title="open this project in its own window" onclick="event.stopPropagation()">↗</a>${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) : view === "timeline" ? timelineHTML(p.project) : `<div class="kanban">${cols}</div>`)+
@@ -800,12 +842,21 @@ async function render(){
   // idle projects (zero online agents) collapse to thin rows below the live boards
   const idleRow=p=>{
     const pt=tasks.filter(t=>t.project===p.project);const done=pt.filter(t=>t.status==='done').length;
-    return `<div class="idle-row" data-projname="${esc(p.project)}" data-idleproj="${esc(p.project)}" title="click to expand">💤 <span class="nm">${esc(p.project)}</span><span class="dim">· ${esc(p.phase||'')} · ${done}/${pt.length} cards</span><span class="spacer"></span><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><span class="pdel" data-proj="${esc(p.project)}" title="forget this project (cards, peers, brief) — it returns if an agent registers it again">✕</span></div>`;
+    return `<div class="idle-row" data-projname="${esc(p.project)}" data-idleproj="${esc(p.project)}" title="click to expand">💤 <span class="nm">${esc(p.project)}</span><span class="dim">· ${esc(p.phase||'')} · ${done}/${pt.length} cards</span><span class="spacer"></span><a class="popout" href="?project=${encodeURIComponent(p.project)}" target="_blank" rel="noopener" title="open this project in its own window" onclick="event.stopPropagation()">↗</a><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><span class="pdel" data-proj="${esc(p.project)}" title="forget this project (cards, peers, brief) — it returns if an agent registers it again">✕</span></div>`;
   };
-  const live=projects.filter(p=>p.idle!==true),idlers=projects.filter(p=>p.idle===true);
-  el.innerHTML=(ORDER.length?`<div class="sortmode" id="sortreset" title="you've ordered projects manually — click to go back to automatic (recency) ordering">sort: manual · ↺ back to auto</div>`:'')
-    +live.map(projBlock).join('')
-    +(idlers.length?`<div class="idle-head">idle projects · ${idlers.length}</div>`+idlers.map(p=>idleOpen.has(p.project)?projBlock(p):idleRow(p)).join(''):'');
+  renderTabStrip(projects);
+  if(SOLO){
+    // single-project full-window: render ONLY the deep-linked project, side rails hidden via body.solo
+    document.body.classList.add('solo');
+    const only=projects.filter(p=>p.project===SOLO||p.project.toLowerCase()===SOLO.toLowerCase());
+    if(!only.length){el.innerHTML=`<div class="empty big">project “${esc(SOLO)}” not found — <a href="${esc(location.pathname)}" style="color:var(--grn)">view all projects</a></div>`;return;}
+    el.innerHTML=only.map(projBlock).join('');
+  } else {
+    const live=projects.filter(p=>p.idle!==true),idlers=projects.filter(p=>p.idle===true);
+    el.innerHTML=(ORDER.length?`<div class="sortmode" id="sortreset" title="you've ordered projects manually — click to go back to automatic (recency) ordering">sort: manual · ↺ back to auto</div>`:'')
+      +live.map(projBlock).join('')
+      +(idlers.length?`<div class="idle-head">idle projects · ${idlers.length}</div>`+idlers.map(p=>idleOpen.has(p.project)?projBlock(p):idleRow(p)).join(''):'');
+  }
   // keep each project's chat scrolled to the latest line
   el.querySelectorAll('.chatlog').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';};});
   // click a card -> advance status todo->doing->done