trantor 0.17.68 → 0.17.71

package/bin/proposals.mjs

@@ -5,6 +5,7 @@
 //   trantor proposals --all                 every proposal, all statuses
 //   trantor proposals approve <id> [--note "…"]
 //   trantor proposals deny <id> --note "…"       (a denial without a reason teaches nothing)
+//   trantor proposals revoke <id> [--note "…"]   (withdraw a GRANT — not a denial, no denial memory)
 //   [--hub <url>]                           target one hub when an id exists on several
 // Owner-signed: /proposal/decide is owner-gated hub-side — approval is the human's act alone.
 import { readFileSync } from "node:fs";
@@ -33,7 +34,7 @@ const post = async (hub, path, payload) => {
   return j;
 };
 
-const ICON = { pending: "⏳", approved: "✅", denied: "⛔", withdrawn: "↩️" };
+const ICON = { pending: "⏳", approved: "✅", denied: "⛔", withdrawn: "↩️", revoked: "🚫" };
 const when = (ts) => ts ? new Date(ts).toLocaleString([], { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" }) : "";
 function show(p, hub) {
   console.log(`  #${p.id} ${ICON[p.status] || ""} ${p.status.toUpperCase()} · ${p.project} · from ${p.session} · ${when(p.ts)}`);
@@ -43,7 +44,7 @@ function show(p, hub) {
   if (p.status !== "pending") console.log(`      decided ${when(p.decidedTs)} by ${p.decidedBy}${p.note ? ` — "${p.note}"` : ""}`);
 }
 function usage() {
-  console.log('usage: trantor proposals [--all] | approve <id> [--note "…"] | deny <id> --note "…"  [--hub <url>]');
+  console.log('usage: trantor proposals [--all] | approve <id> [--note "…"] | deny <id> --note "…" | revoke <id> [--note "…"]  [--hub <url>]');
   process.exit(1);
 }
 
@@ -65,24 +66,27 @@ if (cmd === "list") {
   process.exit(0);
 }
 
-if (cmd === "approve" || cmd === "deny") {
+if (cmd === "approve" || cmd === "deny" || cmd === "revoke") {
   const id = Number(argv[1]);
   if (!Number.isInteger(id) || id <= 0) usage();
   const note = val("note");
   if (cmd === "deny" && !note) { console.error('a denial needs a reason: deny <id> --note "why" — the note is what stops the agent re-proposing blind'); process.exit(1); }
-  // an id is only unique per hub — find where THIS pending proposal lives before deciding
+  // an id is only unique per hub — find where THIS proposal lives before deciding
+  // (approve/deny act on a PENDING row; revoke acts on an APPROVED one)
+  const wantStatus = cmd === "revoke" ? "approved" : "pending";
   const holding = [];
   for (const hub of hubs) {
     try {
-      const { proposals } = await get(hub, "/proposals?status=pending");
+      const { proposals } = await get(hub, `/proposals?status=${wantStatus}`);
       if (proposals?.some(p => p.id === id)) holding.push(hub);
     } catch {}
   }
-  if (!holding.length) { console.error(`no PENDING proposal #${id} on ${hubs.length > 1 ? "any of your hubs" : hubs[0]}`); process.exit(1); }
-  if (holding.length > 1) { console.error(`proposal #${id} is pending on several hubs (${holding.join(", ")}) — pick one with --hub <url>`); process.exit(1); }
+  if (!holding.length) { console.error(`no ${wantStatus.toUpperCase()} proposal #${id} on ${hubs.length > 1 ? "any of your hubs" : hubs[0]}`); process.exit(1); }
+  if (holding.length > 1) { console.error(`proposal #${id} is ${wantStatus} on several hubs (${holding.join(", ")}) — pick one with --hub <url>`); process.exit(1); }
   try {
     // `by` is the warn-mode fallback only — under enforce the hub stamps the SIGNER's name over it
-    const { proposal } = await post(holding[0], "/proposal/decide", { id, status: cmd === "approve" ? "approved" : "denied", note, by: ownerId.name || "owner" });
+    const status = cmd === "approve" ? "approved" : cmd === "deny" ? "denied" : "revoked";
+    const { proposal } = await post(holding[0], "/proposal/decide", { id, status, note, by: ownerId.name || "owner" });
     console.log(`${ICON[proposal.status]} #${proposal.id} ${proposal.status} on ${holding[0]} — the proposer (${proposal.session}) has been told over the bus`);
   } catch (err) { console.error(`⚠ ${holding[0]}: ${err.message}`); process.exit(1); }
   process.exit(0);

package/hooks/heartbeat.mjs

@@ -106,7 +106,10 @@ async function maybeEarlyWarn(stdinRaw, session) {
 }
 
 async function main(stdinRaw) {
-  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  // input.cwd FIRST — every hook must derive the project the SAME way, or two hooks in one
+  // session resolve two projects, two hubs, and half the work records where nobody reads.
+  let _in = {}; try { _in = JSON.parse(stdinRaw || "{}"); } catch {}
+  const projectDir = _in.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
   // Mirror sessionstart.mjs: home-directory sessions aren't project work — don't register
   // them (would spawn a phantom "<username>" board). Opt in with RELAY_SESSION/RELAY_PROJECT.
   if (!process.env.RELAY_SESSION && !process.env.RELAY_PROJECT && projectDir === homedir()) return;

package/hooks/inbox-deliver.mjs

@@ -33,20 +33,28 @@ const FETCH_TIMEOUT_MS = Number(process.env.RELAY_INBOX_TIMEOUT_MS || 1500);
 // 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(session, since, instance) {
-  const { ok, json } = await signedGet(`/inbox?session=${encodeURIComponent(session)}&since=${since}`, { timeoutMs: FETCH_TIMEOUT_MS, session, instance });
+async function getInbox(session, since, instance, project) {
+  const { ok, json } = await signedGet(`/inbox?session=${encodeURIComponent(session)}&since=${since}`, { timeoutMs: FETCH_TIMEOUT_MS, session, instance, project });
   if (!ok || !json) throw new Error("hub unreachable");
   return json;   // { messages: [...], cursor, superseded? }
 }
 
-// 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.
+// PostToolUse hands us the tool-input JSON on stdin, and 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.
+// It used to drain into the void and resolve with NOTHING, so `main(stdinRaw)` always got
+// undefined — which silently cost two things: `session_id` (so the per-instance cursor in
+// docs/INSTANCE-KEYS-CONTRACT.md never actually keyed by instance) and `cwd` (so this hook could
+// only ever guess its project from the process directory). Draining and KEEPING the bytes is the
+// same protection, minus the amnesia.
 function drainStdin() {
   return new Promise(res => {
-    try { process.stdin.resume(); process.stdin.on("data", () => {}); process.stdin.on("end", res); }
-    catch { res(); }
-    setTimeout(res, 80);
+    let d = "";
+    try {
+      process.stdin.setEncoding("utf8"); process.stdin.resume();
+      process.stdin.on("data", c => (d += c));
+      process.stdin.on("end", () => res(d));
+    } catch { res(d); }
+    setTimeout(() => res(d), 80);
   });
 }
 
@@ -64,7 +72,10 @@ async function main(stdinRaw) {
   // name, different session_id) has its own ledger and can't eat this session's messages.
   let instanceId = "";
   try { instanceId = String(JSON.parse(stdinRaw || "{}").session_id || ""); } catch {}
-  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  // input.cwd FIRST — every hook must derive the project the SAME way, or two hooks in one
+  // session resolve two projects, two hubs, and half the work records where nobody reads.
+  let _in = {}; try { _in = JSON.parse(stdinRaw || "{}"); } catch {}
+  const projectDir = _in.cwd || 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 "{}";
@@ -94,7 +105,7 @@ async function main(stdinRaw) {
   // so we start listening "from now" instead of replaying the whole backlog of old broadcasts.
   if (!existsSync(cursorFile)) {
     try {
-      const { cursor } = await getInbox(session, 0, instanceId);
+      const { cursor } = await getInbox(session, 0, instanceId, project);
       writeFileSync(cursorFile, String(cursor || 0));
     } catch {}
     return "{}";
@@ -105,7 +116,7 @@ async function main(stdinRaw) {
 
   let messages = [], next = cursor, superseded = false;
   try {
-    const res = await getInbox(session, cursor, instanceId);
+    const res = await getInbox(session, cursor, instanceId, project);
     messages = Array.isArray(res.messages) ? res.messages : [];
     next = res.cursor || cursor;
     superseded = res.superseded === true;

package/hooks/lib/api.mjs

@@ -49,6 +49,32 @@ export function sessionContext(projectDir) {
   return { session, project, projectDir: dir };
 }
 
+// THE PROJECT A REQUEST IS ABOUT, which is not always the project the hook process is standing in.
+//
+// This distinction cost two diagnosis sessions. A hook stamps its payload with the project from
+// Claude's session cwd (`input.cwd`), but the hub URL used to come from the HOOK PROCESS's cwd.
+// Launch a session from ~/development and those disagree: every card says "crebral-health" and
+// every one of them lands on the LOCAL hub, because "development" has no pin and falls through to
+// the global default. Nothing errors, the seat looks healthy, and half the work records where
+// nobody reads. So: the project travels WITH the request, explicit > payload > query > cwd.
+function projectFromQuery(pathOrUrl) {
+  const m = String(pathOrUrl).match(/[?&]project=([^&]*)/);
+  try { return m ? decodeURIComponent(m[1]) : ""; } catch { return m ? m[1] : ""; }
+}
+function projectOf(explicit, payload, pathOrUrl) {
+  if (explicit) return explicit;
+  if (payload && typeof payload === "object" && payload.project) return String(payload.project);
+  return projectFromQuery(pathOrUrl);
+}
+// The signing identity for a request about `project`. An explicit RELAY_SESSION/RELAY_AGENT still
+// wins (crew seats inherit them); otherwise the peer is named for the project being written, not
+// for wherever the hook happens to be running.
+function sessionFor(project) {
+  if (process.env.RELAY_SESSION) return process.env.RELAY_SESSION;
+  const p = project || sessionContext().project;
+  return process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${p}` : `${hostId()}:${p}`;
+}
+
 // The keypair for a session name, memoised per process. loadOrCreate is itself idempotent + atomic,
 // but a hook may sign several requests in one run — avoid re-reading the file each time.
 const _idCache = new Map();
@@ -86,14 +112,19 @@ function enrolledPath(session) {
   const busDir = process.env.AGENT_BUS_DIR || join(homedir(), ".agent-bus");
   return join(busDir, "keys", `${String(session).replace(/[^A-Za-z0-9_.-]/g, "_")}.enrolled`);
 }
-export async function ensureEnrolled(session, identity) {
+export async function ensureEnrolled(session, identity, project) {
   if (!identity?.pubkey) return;
+  const hub = relayUrl(project);
   const stamp = enrolledPath(session);
-  try { if (existsSync(stamp) && readFileSync(stamp, "utf8").trim() === identity.pubkey) return; } catch {}
+  // The stamp records the HUB as well as the key. It used to record only the key, so a session
+  // enrolled on one hub was considered enrolled everywhere — and its first request to a second
+  // hub went out as an unknown identity.
+  const mark = `${identity.pubkey}\t${hub}`;
+  try { if (existsSync(stamp) && readFileSync(stamp, "utf8").trim() === mark) return; } catch {}
   try {
     // sfetchJson is the FROZEN single call-site shape (lib/signed-fetch.mjs): it stringifies the
     // payload, sets content-type, and signs — so every hook signs identically with zero hand-rolling.
-    const r = await sfetchJson(`${relayUrl()}/enroll`, {
+    const r = await sfetchJson(`${hub}/enroll`, {
       method: "POST",
       payload: { pubkey: identity.pubkey, name: session, kind: "agent" },
       identity,
@@ -101,7 +132,7 @@ export async function ensureEnrolled(session, identity) {
     });
     if (r.ok) {
       try { mkdirSync(join((process.env.AGENT_BUS_DIR || join(homedir(), ".agent-bus")), "keys"), { recursive: true }); } catch {}
-      try { writeFileSync(stamp, identity.pubkey, { mode: 0o600 }); } catch {}
+      try { writeFileSync(stamp, mark, { mode: 0o600 }); } catch {}
     }
   } catch {}
 }
@@ -109,8 +140,8 @@ export async function ensureEnrolled(session, identity) {
 // Accept either a full URL (rare — a caller that already built one) or a hub-relative path. We do
 // NOT fold the origin into the signature (signed-fetch signs path+query only), so a request proxied
 // through a different host still verifies.
-function toUrl(pathOrUrl) {
-  return /^https?:\/\//.test(pathOrUrl) ? pathOrUrl : `${relayUrl()}${pathOrUrl}`;
+function toUrl(pathOrUrl, project) {
+  return /^https?:\/\//.test(pathOrUrl) ? pathOrUrl : `${relayUrl(project || projectFromQuery(pathOrUrl))}${pathOrUrl}`;
 }
 
 // Unsigned GET → { ok, status, json|null }. Never throws.
@@ -123,8 +154,8 @@ function toUrl(pathOrUrl) {
 // /peers roster. So reads stay unsigned: accepted+flagged under the default `warn` mode, and the
 // roster stays global. Flipping individual reads to signed later is a one-liner once a read needs
 // enforce-mode attribution (add a signedGet that passes `identity` through sfetchJson with GET).
-export async function getJSON(pathOrUrl, { timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
-  const url = toUrl(pathOrUrl);
+export async function getJSON(pathOrUrl, { timeoutMs = DEFAULT_TIMEOUT_MS, project } = {}) {
+  const url = toUrl(pathOrUrl, projectOf(project, null, pathOrUrl));
   try {
     const r = await fetch(url, { method: "GET", signal: AbortSignal.timeout(timeoutMs) });
     // parse the body on FAILURE too — a refusal's payload (denial note, queue guidance,
@@ -145,13 +176,14 @@ export async function getJSON(pathOrUrl, { timeoutMs = DEFAULT_TIMEOUT_MS } = {}
 // First user: the overseer-warn hook's /overseer/context — a project-scoped read, so the
 // enforce hub's own-project scope filtering is the correct behavior, not a loss. Roster-style
 // reads (/peers, /catchup cross-project discovery) stay on getJSON on purpose — see above.
-export async function signedGet(pathOrUrl, { timeoutMs = DEFAULT_TIMEOUT_MS, session, instance } = {}) {
-  const sess = session || sessionContext().session;
+export async function signedGet(pathOrUrl, { timeoutMs = DEFAULT_TIMEOUT_MS, session, instance, project } = {}) {
+  const proj = projectOf(project, null, pathOrUrl);
+  const sess = session || sessionFor(proj);
   const durable = loadIdentity(sess);
   const id = instance ? loadInstance(sess, instance) : durable;
-  await ensureEnrolled(sess, durable);           // instances never enroll — the DURABLE key does
+  await ensureEnrolled(sess, durable, proj);     // instances never enroll — the DURABLE key does
   try {
-    const r = await sfetchJson(toUrl(pathOrUrl), {
+    const r = await sfetchJson(toUrl(pathOrUrl, proj), {
       method: "GET",
       identity: id,
       signal: AbortSignal.timeout(timeoutMs),
@@ -170,15 +202,16 @@ export async function signedGet(pathOrUrl, { timeoutMs = DEFAULT_TIMEOUT_MS, ses
 }
 
 // Signed POST → { ok, status, json|null }. Never throws.
-export async function signedPost(pathOrUrl, payload, { timeoutMs = DEFAULT_TIMEOUT_MS, session, instance } = {}) {
-  const sess = session || sessionContext().session;
+export async function signedPost(pathOrUrl, payload, { timeoutMs = DEFAULT_TIMEOUT_MS, session, instance, project } = {}) {
+  const proj = projectOf(project, payload, pathOrUrl);
+  const sess = session || sessionFor(proj);
   const durable = loadIdentity(sess);
   const id = instance ? loadInstance(sess, instance) : durable;
-  await ensureEnrolled(sess, durable);           // instances never enroll — the DURABLE key does
+  await ensureEnrolled(sess, durable, proj);     // instances never enroll — the DURABLE key does
   try {
     // sfetchJson (FROZEN) stringifies the payload + signs with `id` in one call — the single shape
     // every client uses (lib/signed-fetch.mjs). We pass our memoised identity so it doesn't re-load.
-    const r = await sfetchJson(toUrl(pathOrUrl), {
+    const r = await sfetchJson(toUrl(pathOrUrl, proj), {
       method: "POST",
       payload,
       identity: id,

package/hooks/precompact.mjs

@@ -18,7 +18,9 @@ function readStdin() {
 
 try {
   const input = JSON.parse((await readStdin()) || "{}");
-  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  // input.cwd FIRST — every hook must derive the project the SAME way, or two hooks in one
+  // session resolve two projects, two hubs, and half the work records where nobody reads.
+  const projectDir = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
   const projectName = basename(projectDir);
   const transcript = input.transcript_path || "";
   const trigger = input.trigger || "auto";

package/hooks/prompt-focus.mjs

@@ -3,11 +3,17 @@
 // so a REGULAR (non-crew) Claude session's OWN work shows IN PROGRESS on the board as it happens — not only
 // when it commits or dispatches a sub-agent. ONE rolling card per session (the hub re-titles it as the focus
 // shifts and closes it to "done" when the session goes offline). Trivial acks ("yes", "go ahead") don't
-// refocus. Fail-silent + fast: NO LLM call (the title is a heuristic clean of the prompt; Scrooge-summarized
-// titles are a follow-up). Never blocks or delays the turn.
+// refocus. Fail-silent + fast: NO LLM call ON THE TURN PATH — the title is a heuristic clean of the
+// prompt, posted immediately. A long prompt then hands its rewrite to bin/focus-title.mjs, spawned
+// DETACHED so a cheap model can produce a readable board line a few seconds later without the user
+// ever waiting on it. Never blocks or delays the turn.
 import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
 import { resolveProject, hostId } from "../lib/project.mjs";
-import { signedPost } from "./lib/api.mjs";
+import { signedPost, relayUrl } from "./lib/api.mjs";
 
 function readStdin() {
   return new Promise(res => { let d = ""; process.stdin.setEncoding("utf8");
@@ -42,7 +48,29 @@ try {
   const project = resolveProject(cwd);
   const session = process.env.RELAY_SESSION
     || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${project}` : `${hostId()}:${project}`);
-  await signedPost("/focus", { session, project, title: titleFrom(trimmed), by: session }, { session });
+  // The Claude Code session UUID. `session` above is a BUS id — per host+project — so without this
+  // two Claude sessions in one project share (and fight over) a single focus card, and sub-agent
+  // cards, whose `parent` is exactly this UUID, have nothing to nest under.
+  const cc = String(input.session_id || "").slice(0, 120);
+  const r = await signedPost("/focus", { session, project, title: titleFrom(trimmed), by: session, cc }, { session });
+
+  // Only pay a model when the heuristic actually mangles the prompt. A short, already-clear ask
+  // ("fix the login redirect") reads fine as-is and buying a rewrite for it is exactly the kind of
+  // reflexive spend the economics doctrine exists to stop.
+  const id = r?.json?.id;
+  if (id && trimmed.length > 90 && process.env.TRANTOR_NO_SCROOGE_TITLES !== "1") {
+    try {
+      const busDir = process.env.AGENT_BUS_DIR || join(homedir(), ".agent-bus");
+      mkdirSync(busDir, { recursive: true });
+      const pf = join(busDir, `focus-prompt-${String(cc || session).replace(/[^A-Za-z0-9_.-]/g, "_")}.txt`);
+      writeFileSync(pf, trimmed);
+      const worker = join(dirname(dirname(fileURLToPath(import.meta.url))), "bin", "focus-title.mjs");
+      // Detached + unref'd + stdio ignored: the hook returns NOW. Nothing downstream waits on this,
+      // and a worker that dies takes the heuristic title with it, which is a fine outcome.
+      spawn(process.execPath, [worker, "--id", String(id), "--hub", relayUrl(project), "--prompt-file", pf, "--project", project],
+        { detached: true, stdio: "ignore" }).unref();
+    } catch {}
+  }
 } catch (e) {
   process.stderr.write(`[trantor] prompt-focus error: ${e?.message || e}\n`);
 }

package/hooks/sessionstart.mjs

@@ -15,7 +15,7 @@ import { resolveProject, hostId } from "../lib/project.mjs";
 import { formatSubagentManifest } from "../lib/subagent-manifest.mjs";
 import { updateAvailable, maybeNotifyDesktop, readConfig } from "./lib/update-check.mjs";
 import { maybeCheckBalances } from "./lib/balance-check.mjs";
-import { relayUrl, getJSON, signedPost } from "./lib/api.mjs";
+import { relayUrl, getJSON, signedGet, signedPost } from "./lib/api.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
@@ -129,7 +129,10 @@ 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();
+  // input.cwd FIRST, matching hooks/prompt-focus.mjs. When they disagreed, two hooks in ONE
+  // session resolved two different projects — and therefore two different hubs — so half a
+  // session's work recorded on a hub nobody was reading.
+  const projectDir = stdinObj.cwd || 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
   // RELAY_SESSION (or RELAY_PROJECT) to deliberately put a home-dir session on the bus.
@@ -142,7 +145,9 @@ try {
   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();
+  // relayUrl() with no project resolves from the hook process's cwd, which is not always the
+  // project the session is about. Pass it, or every call below can address the wrong hub.
+  const url = relayUrl(project);
 
   // register self + post an initial presence status (no LLM turn — instant for others to read)
   await jpost(`${url}/register`, { session, project, status: `active in ${project}` }, session).catch(() => {});
@@ -162,6 +167,21 @@ try {
     additionalContext += `</trantor>\n`;
   }
 
+  // ── GRANTS: standing permissions the operator has APPROVED for this project ──────
+  // The mechanical half of governance: an approval used to live only in a one-shot DM that died
+  // with the session that received it. Injecting the active grants here means EVERY future seat
+  // (including the duty agent and orchestrators, whose runners fire this hook each turn) inherits
+  // the operator's recorded decisions instead of re-asking or acting around them.
+  try {
+    const { grants = [] } = await jget(`${url}/grants?project=${encodeURIComponent(project)}`, session);
+    if (grants.length) {
+      additionalContext += `<trantor-grants project="${sanitize(project)}">\n`;
+      additionalContext += `Standing permissions the operator has APPROVED (act within the stated bound without re-asking; everything outside it still needs a proposal):\n`;
+      for (const g of grants.slice(-10)) additionalContext += `- [#${g.id}${g.key ? ` ${sanitize(g.key)}` : ""}] ${sanitize(g.scope)} — WHEN: ${sanitize(g.condition)} — NOT covered: ${sanitize(g.exclusions)}\n`;
+      additionalContext += `</trantor-grants>\n`;
+    }
+  } catch {}
+
   // ── ADOPT live crews (intersession-ops S1+S2, contract #4215) ─────────────────
   // Every boot inventories leftover crew resources via the #4214 detection lib and steers the
   // session toward ADOPTING a live crew rather than `trantor up`-ing over it (replace-in-place

package/hooks/stop-inbox.mjs

@@ -78,7 +78,7 @@ async function main() {
   let messages = [];
   try {
     // PEEK: look without claiming delivery. We may yet decide to let the stop through.
-    const peek = await signedGet(`/inbox?session=${encodeURIComponent(session)}&since=${cursor}&peek=1`, { timeoutMs: FETCH_TIMEOUT_MS, session, instance: instanceId });
+    const peek = await signedGet(`/inbox?session=${encodeURIComponent(session)}&since=${cursor}&peek=1`, { timeoutMs: FETCH_TIMEOUT_MS, session, instance: instanceId, project });
     if (!peek.ok) return allow();
     // Superseded twin (instance-keys contract): a newer instance claimed the baton — this session
     // stands down. Blocking ITS stop over messages the new instance will handle would trap it.
@@ -92,7 +92,7 @@ async function main() {
   // Committed now: claim delivery for real so neither inbox-deliver nor the deferred waker repeats it.
   let next = cursor;
   try {
-    const claim = await signedGet(`/inbox?session=${encodeURIComponent(session)}&since=${cursor}`, { timeoutMs: FETCH_TIMEOUT_MS, session, instance: instanceId });
+    const claim = await signedGet(`/inbox?session=${encodeURIComponent(session)}&since=${cursor}`, { timeoutMs: FETCH_TIMEOUT_MS, session, instance: instanceId, project });
     if (claim.ok) next = claim.json?.cursor || cursor;
   } catch {}
   try { writeFileSync(cursorFile, String(next)); } catch {}

package/hooks/subagent-start.mjs

@@ -53,8 +53,11 @@ try {
     // with the SubagentStop "done" card on any client that predates agent_id pairing (legacy fallback).
     const task = String(ti.prompt || ti.description || agentType).replace(/\s+/g, " ").trim().slice(0, 90);
     const title = `${agentType}: ${task}`.slice(0, 180);
+    // parent at CREATE time too, not only on the SubagentStart enrich — a card that spends its
+    // whole doing-life unparented is un-nestable exactly while it is the interesting one.
     await signedPost("/task", {
       project, title, status: "doing", agentType,
+      parent: String(input.session_id || "").slice(0, 120),
       assignee: `${agentType}:${project}`, by: `${hostId()}:${project}`,
       source: "cc-subagent", costKind: "subagent-notional", phase: "sub-agents",
     });

package/hooks/todo-sync.mjs

@@ -3,8 +3,8 @@
 // so SOLO work (no crew fired up) shows up live and accrues timeline history. The hub reconciles by
 // todo text (pending/in_progress/completed -> todo/doing/done). Fail-silent by contract: a bad hub,
 // a home-dir session, or any error must never block or break the tool flow.
-import { basename } from "node:path";
-import { homedir, hostname } from "node:os";
+import { homedir } from "node:os";
+import { resolveProject, hostId } from "../lib/project.mjs";
 import { signedPost } from "./lib/api.mjs";
 function readStdin() {
   return new Promise(res => { let d = ""; process.stdin.setEncoding("utf8");
@@ -13,21 +13,26 @@ function readStdin() {
 }
 
 async function main() {
-  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  // stdin FIRST: input.cwd is the session's own directory and it decides both the project and the
+  // hub, so it has to be read before either is resolved.
+  let input = {};
+  try { input = JSON.parse((await readStdin()) || "{}"); } catch { return; }
+  const projectDir = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
   // Mirror sessionstart/heartbeat: home-directory sessions aren't project work — don't card them
   // (would spawn a phantom "<username>" board). Opt in with RELAY_SESSION/RELAY_PROJECT.
   if (!process.env.RELAY_SESSION && !process.env.RELAY_PROJECT && projectDir === homedir()) return;
-
-  let input = {};
-  try { input = JSON.parse((await readStdin()) || "{}"); } catch { return; }
   if (input.tool_name && input.tool_name !== "TodoWrite") return;   // the matcher should scope us, but be safe
   const todos = input.tool_input?.todos;
   if (!Array.isArray(todos) || !todos.length) return;
 
   // Identity EXACTLY as mcp.mjs/heartbeat resolve it, so we card the same peer the relay registered.
-  const project = process.env.RELAY_PROJECT || basename(projectDir);
+  // This said `basename(projectDir)` and `hostname()`, which is not the same thing at all:
+  // resolveProject keys off the GIT ROOT (a subdirectory forked its own lane) and hostId is the
+  // stable machine id, where hostname() drifts to "MacBook-Pro-M1.local" on some networks and
+  // splits one machine into two peers.
+  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}`);
 
   await signedPost("/todos", { session, project, by: session, todos: todos.map(t => ({ content: t.content, status: t.status })) });
 }