trantor 0.17.59 → 0.17.60

package/.claude-plugin/marketplace.json

@@ -13,7 +13,7 @@
       "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, GLM, 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.59",
+      "version": "0.17.60",
       "author": {
         "name": "Sasha Bogojevic"
       },

package/.claude-plugin/plugin.json

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

package/bin/cli.mjs

@@ -70,6 +70,7 @@ switch (cmd) {
   case "summarize": run("bin/summarize.mjs"); break;
   case "policy": run("bin/policy.mjs"); break;
   case "inbox": run("bin/inbox.mjs"); break;
+  case "duty": run("bin/duty.mjs"); break;
   case "identity": {
     const { load, publicView, generate, keyPath } = await import(join(ROOT, "lib/identity.mjs"));
     const sub = args[0], name = args[1] || "human";

package/bin/crew-runner.mjs

@@ -136,7 +136,9 @@ const cli = CLI[AGENT] || (NATIVE.has(AGENT) ? null : CLI.opencode);
 if (!cli) { console.error(`unknown agent '${AGENT}' (native: ${[...NATIVE].join(", ")}; any other name = an opencode provider seat)`); process.exit(1); }
 if (!CLI[AGENT]) log(`'${AGENT}' is not a built-in seat — running it as an opencode provider (BYOM)`);
 
-const RULES = `Rules: you are ${SESSION} on the trantor crew. Work your assigned file(s), report on the bus (relay_send, <280 chars), move your Kanban card as you go (doing -> testing -> done; run the tests in 'testing', use 'failed' + a report if they break). When your work for THIS message is finished, END YOUR TURN — do NOT park, do NOT loop relay_wait; the runner waits for you and will wake you with the next message.`;
+// RUNNER_RULES / RUNNER_KICKOFF env overrides: the runner is also the substrate for non-crew
+// always-on seats (the fleet DUTY agent, bin/duty.mjs) whose doctrine is not "work your card".
+const RULES = process.env.RUNNER_RULES || `Rules: you are ${SESSION} on the trantor crew. Work your assigned file(s), report on the bus (relay_send, <280 chars), move your Kanban card as you go (doing -> testing -> done; run the tests in 'testing', use 'failed' + a report if they break). When your work for THIS message is finished, END YOUR TURN — do NOT park, do NOT loop relay_wait; the runner waits for you and will wake you with the next message.`;
 
 // ---- failure visibility ----------------------------------------------------
 // A turn's CLI can fail (credits exhausted, auth, crash) and the runner would just

package/bin/duty.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// trantor duty — the always-on fleet DUTY AGENT: one seat that watches the whole hub and triages
+// so the human never has to be a switchboard.
+//
+//   trantor duty up [--hub <url>] [--agent claude]     start (idempotent — reaps a prior seat)
+//   trantor duty down                                  stop
+//   trantor duty status                                pid + last turns + presence
+//
+// Division of labor (the overseer doctrine, extended): DETECTION stays mechanical and hub-side —
+// RELAY_DUTY_SESSION makes the hub DM this seat when a direct message sits undelivered past
+// RELAY_DUTY_UNDELIVERED_MS or the overseer emits a warning. The SEAT only triages: relay, wake,
+// annotate, and only involves the human when a real decision is needed. It runs under the same
+// crew-runner that keeps crew seats alive (long-poll wake, turn telemetry, failure reporting) —
+// just with a triage doctrine instead of "work your card" (RUNNER_RULES / CREW_KICKOFF).
+import { spawn, execSync } from "node:child_process";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, openSync, rmSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { loadOrCreate } from "../lib/identity.mjs";
+import { sfetchJson } from "../lib/signed-fetch.mjs";
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const BUS = process.env.AGENT_BUS_DIR || join(homedir(), ".agent-bus");
+const DIR = join(BUS, "fleet");                  // the seat's cwd — project name "fleet"
+const PIDF = join(BUS, "duty.pid");
+const LOGF = join(BUS, "duty.log");
+
+const argv = process.argv.slice(2);
+const cmd = argv[0] || "status";
+const val = (k, d) => { const i = argv.indexOf(`--${k}`); return i >= 0 ? (argv[i + 1] || d) : d; };
+
+let config = {}; try { config = JSON.parse(readFileSync(join(BUS, "config.json"), "utf8")); } catch {}
+// The fleet hub: where the projects live. Default = the most common per-project hub in config,
+// falling back to the global url — a fleet watcher belongs where the fleet is.
+function fleetHub() {
+  const counts = new Map();
+  for (const u of Object.values(config.hubs || {})) counts.set(u, (counts.get(u) || 0) + 1);
+  const top = [...counts.entries()].sort((a, b) => b[1] - a[1])[0];
+  return val("hub", top?.[0] || config.url || "http://127.0.0.1:4477");
+}
+
+const AGENT = val("agent", "claude");
+const SESSION = `${AGENT}:fleet`;
+
+const RULES = `Rules: you are ${SESSION}, the trantor fleet DUTY AGENT — the always-on triage seat. You NEVER write code and NEVER edit project files. On every wake: (1) read the message(s) that woke you; (2) triage with your relay tools — relay_peers for who is live/down, relay_board with the project param for any board, relay_inbox for your own backlog; runner logs live at ~/.agent-bus/logs/<agent>-<project>.jsonl if a seat looks dead; (3) ACT: an UNDELIVERED escalation means the recipient is idle, deaf (wrong hub / stale hooks — a known failure mode), or gone — relay the content to a live session that can act, wake a crew seat with a direct message, or post the information into the project lane so the human's app notifies them; an OVERSEER warning means two parties may collide — message them to coordinate; a seat reported down/errored — check its log tail and either resend its contract or report exactly what is needed. (4) Report each action in ONE bus message (<280 chars) to the lane it concerns. If only a human can decide, say exactly that, in that lane, once. Then END YOUR TURN — the runner wakes you for the next event.`;
+
+const KICKOFF = `You are ${SESSION}, the fleet duty agent, freshly started. Do a short patrol: relay_peers (note anything down/errored), then relay_inbox. Handle what is actionable per the Rules, post one line to the bus saying the duty seat is on watch, and end your turn.\n\n${RULES}`;
+
+async function ensureFleetIdentity(hub) {
+  const id = loadOrCreate(SESSION, "agent");
+  const probe = await sfetchJson(`${hub}/peers`, { method: "GET", identity: id, signal: AbortSignal.timeout(5000) }).catch(() => null);
+  if (probe && probe.status !== 401) return true;          // enrolled (or hub not enforcing)
+  // Not enrolled: mint an owner invite with FLEET-WIDE write (write ⊇ read) and enroll with it.
+  const owner = loadOrCreate(config.ownerIdentity || "admin", "human");
+  const inv = await sfetchJson(`${hub}/invite`, { identity: owner, payload: { scopes: [{ project: "*", role: "write" }], ttlSec: 3600 }, signal: AbortSignal.timeout(5000) });
+  const invJson = await inv.json().catch(() => ({}));
+  if (!inv.ok || !invJson.token) { console.error(`could not mint fleet invite on ${hub}: ${invJson.error || inv.status} — is ${config.ownerIdentity || "admin"} the owner there?`); return false; }
+  const enr = await sfetchJson(`${hub}/enroll`, { identity: id, payload: { token: invJson.token, pubkey: id.pubkey, name: SESSION, kind: "agent" }, signal: AbortSignal.timeout(5000) });
+  const enrJson = await enr.json().catch(() => ({}));
+  if (!enr.ok) { console.error(`fleet enroll failed: ${enrJson.error || enr.status}`); return false; }
+  console.log(`— enrolled ${SESSION} on ${hub} with fleet-wide write —`);
+  return true;
+}
+
+function alivePid() {
+  try {
+    const pid = Number(readFileSync(PIDF, "utf8"));
+    if (pid && process.kill(pid, 0) === undefined) return pid;
+  } catch {}
+  return 0;
+}
+
+if (cmd === "up") {
+  const hub = fleetHub();
+  mkdirSync(DIR, { recursive: true });
+  const prior = alivePid();
+  if (prior) { console.log(`— reaping prior duty seat (pid ${prior}) —`); try { process.kill(prior); } catch {} }
+  try { execSync(`pkill -f "crew-runner.mjs ${AGENT} ${DIR}"`, { stdio: "ignore" }); } catch {}
+  if (!(await ensureFleetIdentity(hub))) process.exit(1);
+  const out = openSync(LOGF, "a");
+  const child = spawn(process.execPath, [join(ROOT, "bin", "crew-runner.mjs"), AGENT, DIR], {
+    detached: true, stdio: ["ignore", out, out],
+    env: { ...process.env, RELAY_URL: hub, RUNNER_RULES: RULES, CREW_KICKOFF: KICKOFF },
+  });
+  child.unref();
+  writeFileSync(PIDF, String(child.pid));
+  console.log(`— duty agent up: ${SESSION} (pid ${child.pid}) watching ${hub} — log: ${LOGF}`);
+  console.log(`  hub feeds it: undelivered DMs (>${Math.round(Number(process.env.RELAY_DUTY_UNDELIVERED_MS || 600000) / 60000)}m) + overseer warnings — set RELAY_DUTY_SESSION=${SESSION} on the hub service.`);
+  process.exit(0);
+}
+
+if (cmd === "down") {
+  const pid = alivePid();
+  if (pid) { try { process.kill(pid); } catch {} console.log(`— duty seat stopped (pid ${pid}) —`); }
+  else console.log("no duty seat running");
+  try { execSync(`pkill -f "crew-runner.mjs ${AGENT} ${DIR}"`, { stdio: "ignore" }); } catch {}
+  try { rmSync(PIDF, { force: true }); } catch {}
+  process.exit(0);
+}
+
+// status
+{
+  const pid = alivePid();
+  console.log(pid ? `duty seat RUNNING (pid ${pid}) as ${SESSION}` : "duty seat NOT running");
+  try {
+    const lines = readFileSync(join(BUS, "logs", `${AGENT}-fleet.jsonl`), "utf8").trim().split("\n").slice(-3);
+    console.log("last turns:"); for (const l of lines) console.log(`  ${l}`);
+  } catch { console.log("(no turns logged yet)"); }
+  process.exit(0);
+}

package/hub.mjs

@@ -245,6 +245,7 @@ function overseerTick() {
     overseerWarned.set(key, now());
     appendEvent("overseer.warn", c.project, "overseer",
       { kind: c.kind, sessions: c.sessions || [], files: c.files || [], detail: c.detail || "", narrated: false });
+    if (DUTY_SESSION) hubSend(DUTY_SESSION, `⚠️ OVERSEER ${c.kind} [${c.project}]: ${c.detail || ""} — if the parties are not already coordinating, message them.`, c.project);
     const level = _overseer.levelFor ? _overseer.levelFor(c.project, pol.autonomy) : 1;
     if (level >= 3 && c.kind === "file-conflict") {
       const g = { id: ++state.verifyGateSeq, project: c.project, status: "open", ts: now(),
@@ -257,6 +258,41 @@ function overseerTick() {
 }
 setInterval(overseerTick, OVERSEER_TICK_MS).unref?.();
 
+// --- the DUTY AGENT feed (deterministic escalation; the seat itself is bin/duty.mjs) -----------
+// RELAY_DUTY_SESSION names the always-on triage seat (e.g. "claude:fleet"). The hub DMs it when:
+//   1. a DIRECT message has sat undelivered past RELAY_DUTY_UNDELIVERED_MS — the sender believes
+//      it was heard and nobody is listening (the crebral-health 4-day failure mode);
+//   2. the overseer emits a warning (wired inside overseerTick below).
+// Escalations are hub-authored ("hub:duty") — they never impersonate a session — and dedup per
+// message id so a standing outage escalates once, not every tick.
+const DUTY_SESSION = String(process.env.RELAY_DUTY_SESSION || "");
+const DUTY_UNDELIVERED_MS = Number(process.env.RELAY_DUTY_UNDELIVERED_MS || 10 * 60 * 1000);
+const dutyEscalated = new Set();
+function hubSend(to, text, project) {
+  const msg = { id: ++state.seq, ts: now(), from: "hub:duty", to, text: String(text).slice(0, 2000), project: String(project || "").slice(0, 80) };
+  state.messages.push(msg); if (state.messages.length > 5000) state.messages.splice(0, 1000);
+  dirty = true; pushToStreams(msg);
+  appendEvent("message", msg.project, msg.from, { msgId: msg.id, toSession: msg.to, text: msg.text.slice(0, 2000), refs: [] });
+  return msg;
+}
+function dutyTick() {
+  if (!DUTY_SESSION) return;
+  const cutoff = now() - DUTY_UNDELIVERED_MS;
+  const floor = now() - 24 * 3600 * 1000;                 // never escalate ancient history
+  for (const m of state.messages) {
+    if (m.ts > cutoff || m.ts < floor) continue;
+    if (!m.to || m.to === "all" || m.to === DUTY_SESSION || m.from === "hub:duty") continue;
+    if (dutyEscalated.has(m.id)) continue;
+    if ((state.peers[m.to]?.deliveredUpTo || 0) >= m.id) continue;
+    dutyEscalated.add(m.id);
+    hubSend(DUTY_SESSION,
+      `⚠️ UNDELIVERED for ${Math.round((now() - m.ts) / 60000)}m: #${m.id} ${m.from} -> ${m.to} — "${String(m.text).slice(0, 280)}" — the recipient has not been handed this. Triage: is the recipient's session idle, deaf (wrong hub / old hooks), or gone? Relay, wake, or note it on their board.`,
+      m.project || "");
+  }
+  if (dutyEscalated.size > 5000) { let n = dutyEscalated.size - 4000; for (const k of dutyEscalated) { dutyEscalated.delete(k); if (--n <= 0) break; } }
+}
+setInterval(dutyTick, OVERSEER_TICK_MS).unref?.();
+
 if (durableStore?.subscribeChanges) {
   durableStore.subscribeChanges((p) => {
     if (p && p.src === HUB_SRC) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.59",
+  "version": "0.17.60",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"
@@ -11,7 +11,7 @@
     "pg": "^8.22.0"
   },
   "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 && node test-inbox.mjs && node test-inflight.mjs && node test-notify.mjs && node test-focus.mjs && node test-reaper.mjs && node test-events.mjs && node test-scrub.mjs && node test-store-delta.mjs && node test-claims.mjs && node test-adopt.mjs && node test-summarize.mjs && node test-identity-core.mjs && node test-identity.mjs && node test-identity-instances.mjs && node test-inbox-delivery.mjs && node test-hub-routing.mjs && python3 engine/test-routing.py && node test-reconcile.mjs && bash test-crew.sh"
+    "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 && node test-notify.mjs && node test-focus.mjs && node test-reaper.mjs && node test-events.mjs && node test-scrub.mjs && node test-store-delta.mjs && node test-claims.mjs && node test-adopt.mjs && node test-summarize.mjs && node test-identity-core.mjs && node test-identity.mjs && node test-identity-instances.mjs && node test-duty.mjs && node test-inbox-delivery.mjs && node test-hub-routing.mjs && python3 engine/test-routing.py && node test-reconcile.mjs && bash test-crew.sh"
   },
   "description": "The hub-world for AI agent crews — orchestrate Claude Code, Codex, GLM, Kimi, DeepSeek & any OpenRouter model as live crews with a plan-aware Advisor, a Kanban/flow command center, a testing gate, and an economics brain (Scrooge).",
   "files": [