trantor 0.18.118 → 0.18.120

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.118",
+  "version": "0.18.120",
   "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

@@ -169,15 +169,15 @@ switch (cmd) {
     break;
   }
   case "invite": {
-    const { loadOrCreate, signRequest } = await import(join(ROOT, "lib/identity.mjs"));
+    const { resolveOwnerIdentity, signRequest } = await import(join(ROOT, "lib/identity.mjs"));
     const nameIdx = args.indexOf("--name"), scopeIdx = args.indexOf("--scope");
     const name = nameIdx >= 0 ? args[nameIdx + 1] : "";
     const scopeRaw = scopeIdx >= 0 ? (args[scopeIdx + 1] || "") : "";
     if (!name || !scopeRaw) { console.error("usage: trantor invite --name <name> --scope <project>:<role>"); process.exit(1); }
     const [project, role = "write"] = scopeRaw.split(":");
-    let hub = "http://127.0.0.1:4477";
-    try { hub = JSON.parse(readFileSync(join(process.env.HOME || "", ".agent-bus", "config.json"), "utf8")).url || hub; } catch {}
-    const id = loadOrCreate("admin", "human");
+    const { resolveHubInfo } = await import(join(ROOT, "lib/project.mjs"));
+    const hub = resolveHubInfo().url;
+    const id = await resolveOwnerIdentity(hub);
     const payload = { scopes: [{ project, role }], ttlSec: 86400 };
     const body = JSON.stringify(payload);
     const sig = signRequest(id, { method: "POST", path: "/invite", body });

package/bin/pair.mjs

@@ -21,15 +21,23 @@ if (!role || role.startsWith("--")) {
   process.exit(1);
 }
 
-const { load, signRequest } = await import(join(ROOT, "lib/identity.mjs"));
+const { resolveOwnerIdentity, phoneHubAddress, signRequest } = await import(join(ROOT, "lib/identity.mjs"));
 const { resolveHubInfo } = await import(join(ROOT, "lib/project.mjs"));
 
 const hub = resolveHubInfo().url.replace(/\/+$/, "");
-// The operator's owner key, the same one the desktop app signs with (hub.rs owner_identity).
-// Loaded, never minted: a fresh key is unknown to the hub and every invite would 401.
-const owner = process.env.TRANTOR_IDENTITY || "sasha@mac";
-const id = load(owner);
-if (!id) { console.error(`error: no key for the owner identity "${owner}". Set TRANTOR_IDENTITY, or run \`trantor keys status\``); process.exit(1); }
+let id, used;
+try {
+  const response = await fetch(`${hub}/health`, { signal: AbortSignal.timeout(8000) });
+  if (!response.ok) throw new Error(`hub health returned HTTP ${response.status}`);
+  const health = await response.json();
+  used = phoneHubAddress(hub, String(health.publicUrl || ""), forceTailnet);
+  id = await resolveOwnerIdentity(hub);
+} catch (error) {
+  const message = `Pairing failed: ${error.message}. Hub: ${hub}`;
+  if (asJson) console.log(JSON.stringify({ error: message }));
+  else console.error(message);
+  process.exit(1);
+}
 
 const payload = { scopes: [{ project: "*", role }], ttlSec: 600, kind: "human" };
 const body = JSON.stringify(payload);
@@ -64,21 +72,6 @@ if (!r.ok) {
   process.exit(1);
 }
 
-// v1.4: the link carries the hub's public address (Tailscale Funnel) so the phone pairs without
-// Tailscale. /invite itself always goes to the tailnet hub — owner routes never answer in public.
-// /health reports publicUrl; --tailnet forces the tailnet address. No publicUrl (or /health
-// unreachable — the invite already minted) falls back to the tailnet hub.
-const linkHub = (async () => {
-  if (forceTailnet) return { hub, public: false };
-  try {
-    const h = await fetch(`${hub}/health`).then((r) => r.json()).catch(() => ({}));
-    const pub = String(h.publicUrl || "").trim().replace(/\/+$/, "");
-    if (pub) return { hub: pub, public: true };
-  } catch {}
-  return { hub, public: false };
-})();
-
-const used = await linkHub;
 const link = `trantor://enroll?hub=${encodeURIComponent(used.hub)}&token=${j.token}`;
 const expiresAt = Number(j.expiresAt) || Date.now() + 600000;
 const mins = Math.max(0, Math.round((expiresAt - Date.now()) / 60000));

package/hooks/lib/handoff-claims.mjs

@@ -85,7 +85,7 @@ export function loadPendingHandoff(project, { claim = true, freshSession = null,
       if (!claim) return record;
       const next = claimHandoffFile(path, freshSession, now);
       if (!next) return null;
-      const readFirst = readFirstPaths(next.summary || "");
+      const readFirst = readFirstPaths(next.summary || "", { projectDir: next.project || process.cwd() });
       writeFileSync(recapStampPath(dir, freshSession.session_id), JSON.stringify({
         handoffId: next.id, file, token: next.claim.token, ts: now,
         mode: next.mode === "unattended" ? "unattended" : "attended", readFirst,
@@ -135,3 +135,11 @@ export function completeHandoffRecap({ sessionId, transcriptPath, dir = handoffD
   else traceRecapAttempt(stampPath, { ts: now, sessionId, outcome: "no-record-update" });
   return { recapped: !!next, missed };
 }
+
+// Persist before emitting the reminder so subsequent turns cannot repeat it (#13061).
+export function markHandoffReadReminder({ sessionId, dir = handoffDir() }) {
+  try {
+    return !!updateRecord(recapStampPath(dir, sessionId), stamp =>
+      stamp.readReminderShown ? null : { ...stamp, readReminderShown: true });
+  } catch { return false; }
+}

package/hooks/lib/handoff.mjs

@@ -3,10 +3,11 @@
 // spawns a fresh same-agent session. PreCompact cannot stop compaction, so continuing with a full
 // window means a NEW session; both paths share a per-session guard so nothing is written or spawned twice.
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, openSync, readSync, fstatSync, closeSync, rmSync } from "node:fs";
-import { join, basename, dirname, sep } from "node:path";
+import { join, basename, dirname, sep, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { execSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { asString, asRecord } from "../../lib/decode.mjs";
 import { deriveSubagentManifest } from "../../lib/subagent-manifest.mjs";
 import { signedPost, loadIdentity } from "./api.mjs";
 // #7037: signedHeaders is SYNCHRONOUS, which is why this path can sign at all — see hubCallSync.
@@ -692,7 +693,7 @@ export function writeHandoff({ projectDir, sessionId, transcript, trigger, summa
   // paths disarms the #8162 gate — every check downstream passes vacuously, and the summarizer
   // produced exactly that before #8232 asked it for the section. The memory index is knowable
   // without the model; PRD and TDD stay the summarizer's to find (only it knows they exist).
-  if (!readFirstPaths(narrative).length) {
+  if (!readFirstPaths(narrative, { projectDir }).length) {
     const mem = memoryIndexPath(projectDir);
     if (mem) narrative += `\n\n## READ FIRST\n${mem}`;
   }
@@ -869,7 +870,7 @@ export function memoryIndexPath(projectDir) {
  *  can check it. Recognised: a `READ FIRST`/`READ-FIRST`/`Read first:` heading or line, and every
  *  path-looking token until the next blank line or heading — narrow on purpose: a path in passing
  *  is not a reading order. @returns {string[]} paths, deduped, capped */
-export function readFirstPaths(summary, { max = 12 } = {}) {
+export function readFirstPaths(summary, { max = 12, projectDir = process.cwd() } = {}) {
   const text = String(summary || "");
   const out = [];
   const lines = text.split(/\r?\n/);
@@ -880,10 +881,13 @@ export function readFirstPaths(summary, { max = 12 } = {}) {
     if (!collecting && !opens) continue;
     if (collecting && (line === "" || /^#{1,6}\s/.test(line))) break;
     collecting = true;
-    // Paths: a token with a slash or a known doc/memory extension, stripped of markdown furniture.
-    for (const m of line.matchAll(/[`"'(\[]?([~./\w-]*[\w-]+\.(?:md|mjs|js|ts|tsx|json|sql|rs|py|sh|txt))[`"')\]]?/g)) {
-      const p = m[1].replace(/^[`"'(\[]+|[`"')\]]+$/g, "");
-      if (p && !out.includes(p)) out.push(p);
+    // Preserve bracketed routes and globs as whole tokens; never turn a suffix into a path.
+    for (const m of line.matchAll(/`([^`]+)`|"([^"]+)"|'([^']+)'|[^\s`"'<>]+/g)) {
+      const p = (m[1] || m[2] || m[3] || m[0]).replace(/^\(|[),;:]$/g, "");
+      if (!/\.(?:md|mjs|js|ts|tsx|json|sql|rs|py|sh|txt)$/.test(p) || /[*?]/.test(p)) continue;
+      const full = p.startsWith("~/") ? join(homedir(), p.slice(2)) : resolve(projectDir, p);
+      try { if (!statSync(full).isFile()) continue; } catch { continue; }
+      if (!out.includes(p)) out.push(p);
       if (out.length >= max) return out;
     }
   }
@@ -901,8 +905,29 @@ export function pathsReadIn(transcriptPath, paths) {
   // Only the tool CALLS count. A path quoted in the injected handoff summary, or in the model's own
   // prose, must never read as "opened" — that is precisely the proxy this card exists to kill.
   const opened = new Set();
-  for (const m of body.matchAll(/"name"\s*:\s*"(Read|Grep|Glob|NotebookRead)"\s*,\s*"input"\s*:\s*\{([^}]*)\}/g)) {
-    for (const f of m[2].matchAll(/"(?:file_path|path|pattern)"\s*:\s*"([^"]+)"/g)) opened.add(f[1]);
+  for (const line of body.split("\n")) {
+    let row;
+    try { row = asRecord(JSON.parse(line)); } catch { continue; }
+    if (row?.type !== "assistant" || row.isSidechain) continue;
+    for (const call of Array.isArray(row.message?.content) ? row.message.content : []) {
+      if (call.type !== "tool_use") continue;
+      if (["Read", "Grep", "Glob", "NotebookRead"].includes(call.name)) {
+        for (const key of ["file_path", "path", "pattern"]) {
+          const path = asString(asRecord(call.input)?.[key]);
+          if (path !== null) opened.add(path);
+        }
+      }
+      const command = asString(asRecord(call.input)?.command);
+      if (call.name !== "Bash" || command === null) continue;
+      const tokens = command.match(/"[^"]*"|'[^']*'|[^\s;&|]+|[;\n&|]+/g) || [];
+      let reader = false, commandStart = true;
+      for (const token of tokens) {
+        if (/^[;\n&|]+$/.test(token)) { reader = false; commandStart = true; continue; }
+        const word = token.replace(/^["']|["']$/g, "");
+        if (commandStart) { commandStart = false; reader = /^(?:\/[^ ]*\/)?(?:cat|sed|head)$/.test(word); continue; }
+        if (reader && !word.startsWith("-")) opened.add(word);
+      }
+    }
   }
   const hit = (p) => {
     const base = p.split("/").pop();

package/hooks/stop-inbox.mjs

@@ -13,7 +13,7 @@ import { signedGet } from "./lib/api.mjs";   // signed: enforce hubs 401 unsigne
 import { ledgerPaths, ensureStart, anchorCursor, writeCursor } from "./lib/inbox-ledger.mjs";
 import { readArm, clearArm, markHandedOff, subagentsActive } from "./lib/handoff.mjs";
 
-import { completeHandoffRecap } from "./lib/handoff-claims.mjs";
+import { completeHandoffRecap, markHandoffReadReminder } from "./lib/handoff-claims.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -129,7 +129,8 @@ async function main() {
 
   if (process.env.RELAY_STOP_INBOX === "0") return allow();
   const recap = completeHandoffRecap({ sessionId: String(input.session_id || ""), transcriptPath: input.transcript_path || "" });
-  if (recap?.missed.length && !input.stop_hook_active) {
+  if (recap?.missed.length && !input.stop_hook_active
+    && markHandoffReadReminder({ sessionId: String(input.session_id || "") })) {
     process.stdout.write(JSON.stringify({ decision: "block", reason: `Read these handoff files before recapping: ${recap.missed.join(", ")}` }));
     return;
   }

package/hub/routes/session.mjs

@@ -20,6 +20,7 @@ const CLAIMED_EXPIRED_REASON = "The Mac claimed this prompt but never delivered
 const ACK_OUTCOMES = new Set(["delivered", "blocked", "not_ready", "stalled", "no_agent", "stale"]);
 const ANSWER_PICKS_MAX = 10;
 const ANSWER_OTHER_MAX = 2000;
+const ANSWER_ENTRIES_MAX = 4;    // CC's question limit per ask (#12912)
 // #12161: photo attachments ride POST /session/prompt as base64 JPEGs. The phone downscales to
 // the byte cap; the hub stores the bytes on disk next to its state (never in bus.json) and hands
 // metadata to the claiming desktop, which downloads them through GET /session/attachment.
@@ -243,14 +244,33 @@ export function createSessionRuntime({ state, markDirty, appendEvent, pushEventT
       if (!project) return json(res, 400, { error: "project required" });
       if (!session) return json(res, 400, { error: "session required" });
       if (!toolId) return json(res, 400, { error: "toolId required" });
-      const picks = (Array.isArray(b.picks) ? b.picks : []).map(Number).filter(Number.isInteger).slice(0, ANSWER_PICKS_MAX);
-      const other = String(b.other || "").slice(0, ANSWER_OTHER_MAX);
-      if (!picks.length && !other.trim()) return json(res, 400, { error: "picks or other required" });
+      // #12912: a multi-question ask carries answers[] (1..4 entries, one per question in
+      // order); the old single-question { picks, other } body normalizes to one entry.
+      const normEntry = (e) => {
+        const picks = (Array.isArray(e?.picks) ? e.picks : []).map(Number).filter(Number.isInteger).slice(0, ANSWER_PICKS_MAX);
+        const other = String(e?.other || "").slice(0, ANSWER_OTHER_MAX);
+        if (!picks.length && !other.trim()) return null;
+        const entry = { picks };
+        if (other.trim()) entry.other = other;
+        return entry;
+      };
+      let answers;
+      if (Array.isArray(b.answers)) {
+        if (!b.answers.length || b.answers.length > ANSWER_ENTRIES_MAX) {
+          return json(res, 400, { error: `answers needs 1..${ANSWER_ENTRIES_MAX} entries` });
+        }
+        answers = b.answers.map(normEntry);
+        if (answers.some(a => !a)) return json(res, 400, { error: "each answer needs picks or a non-blank other" });
+      } else {
+        const entry = normEntry(b);
+        if (!entry) return json(res, 400, { error: "picks or other required" });
+        answers = [entry];
+      }
       expireQueued();
       if (queueFull()) return json(res, 429, { error: "prompt queue full; try again after pending work finishes" });
       state.sessionPromptSeq += 1;
-      const text = other.trim() ? other : `picks ${picks.join(", ")}`;
-      const p = { id: state.sessionPromptSeq, project, kind: "answer", session, toolId, picks, other,
+      const text = answers.map(a => a.other ? a.other : `picks ${a.picks.join(", ")}`).join("; ");
+      const p = { id: state.sessionPromptSeq, project, kind: "answer", session, toolId, answers,
         text, by: String(auth?.identity?.name || "").slice(0, 120), ts: now(), status: "queued" };
       state.sessionPrompts.push(p);
       trimPrompts();
@@ -379,15 +399,29 @@ export function createSessionRuntime({ state, markDirty, appendEvent, pushEventT
     }
 
     // The public view of a queue row: plain prompts are kind "prompt"; answers carry their
-    // session, toolId, picks and other; crew commands carry action, seats, from and to —
+    // session, toolId and normalized answers (plus legacy picks/other for a one-entry answer); crew commands carry action, seats, from and to —
     // so the claiming desktop has everything it needs. Attachments ride as metadata only;
     // the bytes go to the claimer through GET /session/attachment.
     const promptView = (p) => {
       const view = { id: p.id, project: p.project, text: p.text, by: p.by, ts: p.ts, status: p.status, kind: p.kind || "prompt" };
       if (p.attachments?.length) view.attachments = p.attachments.map(({ name, size }) => ({ name, size }));
       if (p.kind === "answer") {
-        view.session = p.session; view.toolId = p.toolId; view.picks = p.picks;
-        if (p.other && p.other.trim()) view.other = p.other;   // absent, never "", when nothing was typed
+        view.session = p.session; view.toolId = p.toolId;
+        // #12912: the view always carries the normalized answers; the legacy top-level picks and
+        // other ride along only for a one-entry answer so a desktop that predates it keeps working.
+        // A row persisted before answers[] shipped has picks/other but no answers — derive the one
+        // entry from them so new clients read old rows too.
+        let answers = Array.isArray(p.answers) && p.answers.length ? p.answers : null;
+        if (!answers) {
+          const entry = { picks: Array.isArray(p.picks) ? p.picks : [] };
+          if (String(p.other || "").trim()) entry.other = p.other;
+          answers = [entry];
+        }
+        view.answers = answers;
+        if (answers.length === 1) {
+          view.picks = answers[0].picks;
+          if (answers[0].other?.trim()) view.other = answers[0].other;   // absent, never "", when nothing was typed
+        }
       }
       if (p.kind === "crew") {
         view.action = p.action; view.seats = p.seats;

package/lib/identity.mjs

@@ -5,6 +5,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync, chmodSy
 import { spawnSync } from "node:child_process";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { isIP } from "node:net";
 import { isTestIdentity } from "./test-identity-names.mjs";
 import { asFunction, asString } from "./decode.mjs";
 
@@ -207,6 +208,71 @@ export function publicView(identity) {
   return { name: identity.name, kind: identity.kind, pubkey: identity.pubkey, createdAt: identity.createdAt };
 }
 
+function loopbackHost(host) {
+  return ["localhost", "localhost.", "[::1]"].includes(host) || (isIP(host) === 4 && host.startsWith("127."));
+}
+
+export function loopbackHub(base) {
+  const url = new URL(base);
+  if (!/^https?:$/.test(url.protocol) || url.username || url.password || url.search || url.hash || url.pathname !== "/") return false;
+  return loopbackHost(url.hostname);
+}
+
+export function phoneHubAddress(base, publicUrl = "", forceTailnet = false) {
+  const hub = String(!forceTailnet && publicUrl || base).trim().replace(/\/+$/, "");
+  const url = new URL(hub);
+  if (!/^https?:$/.test(url.protocol) || loopbackHost(url.hostname) || ["0.0.0.0", "[::]"].includes(url.hostname)) {
+    throw new Error(`Your phone cannot reach ${hub}: this address only works on this Mac. Use Tailscale on the Mac and iPhone and configure the hub with the Mac's Tailscale address (then use trantor pair --tailnet), or configure a public hub URL.`);
+  }
+  return { hub, public: !forceTailnet && !!publicUrl };
+}
+
+// The hub's owner-only read verifies a candidate without minting an invite or changing scopes.
+export async function resolveOwnerIdentity(base) {
+  let config = {};
+  try { config = JSON.parse(readFileSync(join(busDir(), "config.json"), "utf8")); } catch {}
+  const explicit = process.env.TRANTOR_IDENTITY || process.env.RELAY_OWNER_IDENTITY || config.ownerIdentity;
+  const names = explicit ? [explicit] : listKeyNames().flatMap(file => {
+    try {
+      const record = JSON.parse(readFileSync(join(keysDir(), `${file}.json`), "utf8"));
+      return record.kind === "human" && record.name ? [record.name] : [];
+    } catch { return []; }
+  });
+  const request = async (id, path, payload) => {
+    const method = payload ? "POST" : "GET";
+    const body = payload ? JSON.stringify(payload) : undefined;
+    return fetch(`${base.replace(/\/+$/, "")}${path}`, {
+      method, body, redirect: "error", headers: { "content-type": "application/json", ...signRequest(id, { method, path, body }) },
+      signal: AbortSignal.timeout(8000),
+    });
+  };
+  let unavailable = "";
+  for (const name of names) {
+    const id = load(name);
+    if (!id) {
+      unavailable = `The key for "${name}" is unavailable on this Mac. Unlock the identity Keychain or restore this identity's key.`;
+      continue;
+    }
+    const response = await request(id, "/keys/usage");
+    if (response.ok) return id;
+    if (response.status === 401 && loopbackHub(base)) {
+      const error = await response.json();
+      if (error.error === "unknown identity") {
+        const enrolled = await request(id, "/enroll", { name: id.name, kind: "human" });
+        if (enrolled.ok && (await request(id, "/keys/usage")).ok) return id;
+      }
+    }
+  }
+  if (!names.length && loopbackHub(base)) {
+    const id = loadOrCreate("human", "human");
+    if (!id) throw new Error("The local human identity exists, but its key is unavailable. Unlock the identity Keychain or restore its key.");
+    const enrolled = await request(id, "/enroll", { name: id.name, kind: "human" });
+    if (enrolled.ok && (await request(id, "/keys/usage")).ok) return id;
+    throw new Error("The local hub refused owner enrollment. Ask its owner for an invite or configure the existing owner identity.");
+  }
+  throw new Error(unavailable || `No local owner identity is authorized on ${base}. Enroll this Mac with an owner invite, or select its existing owner key with TRANTOR_IDENTITY.`);
+}
+
 // --- migrate + status (`trantor keys …`) ---------------------------------------------------------
 // One <safe-name>.json per durable identity; the instances/ subdir holds per-session subkeys that
 // die with the session and stay files by design.

package/package.json

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