trantor 0.18.41 → 0.18.43

package/bin/crew/models.mjs

@@ -0,0 +1,62 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { call } from "./core.mjs";
+import { reapSeat } from "./state.mjs";
+
+function routeModel(ctx, provider, candidates, task, difficulty) {
+  const bundled = join(ctx.root, "engine/bin/scrooge");
+  const script = existsSync(bundled) ? bundled : "scrooge";
+  const args = candidates
+    ? [script, "route", "--candidates", candidates, "-t", task, "-d", difficulty, "--json"]
+    : [script, "route", "--provider", provider, "-t", task, "-d", difficulty, "--json"];
+  const result = call("python3", args, { env: ctx.env });
+  if (!result.ok || !result.stdout) return "";
+  try { return JSON.parse(result.stdout).qualified || ""; }
+  catch { return ""; }
+}
+
+export function resolveModel(ctx, agent, provider, task, difficulty) {
+  const result = call("opencode", ["models", provider], { env: ctx.env });
+  const candidates = result.ok ? result.stdout.split(/\s+/).filter(Boolean).join(" ") : "";
+  let model = routeModel(ctx, provider, candidates, task, difficulty);
+  if (!model && candidates) {
+    model = `${provider}/${candidates.split(" ")[0]}`;
+    console.error(`[crew] router unavailable for ${agent}:${provider} — using the provider's own catalog head (${model})`);
+  }
+  if (!model) throw new Error(`[crew] live model selection failed for ${agent}:${provider} — no router and no catalog; refusing opencode global default`);
+  if (model.split("/")[0] !== provider) throw new Error(`[crew] router selected ${model} outside ${provider} — refusing cross-provider fallback`);
+  return model;
+}
+
+export function resolveSpec(ctx, spec, task, difficulty, skipped) {
+  const [agent, ...rest] = spec.split(":");
+  reapSeat(ctx, agent);
+  let field = rest.join(":");
+  if (!field) {
+    if (agent === "glm") field = "zai-coding-plan";
+    else if (!["codex", "kimi", "claude", "gemini", "dsh", "opencode"].includes(agent)) field = agent;
+  }
+  if (!field) return { agent, model: "" };
+  if (field.includes("/")) return { agent, model: field };
+  if (["claude", "codex", "kimi", "gemini"].includes(agent)) {
+    console.log(`  → ${agent}: model ${field} (native pin)`);
+    return { agent, model: field };
+  }
+  try {
+    const model = resolveModel(ctx, agent, field, task, difficulty);
+    console.log(`  → ${agent}: live model ${model} (${field} · ${task}/${difficulty})`);
+    return { agent, model };
+  } catch (error) {
+    console.error(error.message);
+    console.error(`[crew] ✗ skipping seat '${agent}' — model resolution failed for ${field} (${task}/${difficulty}); remaining seats still launch`);
+    skipped.push(`${agent}: model resolution failed for ${field} (${task}/${difficulty})`);
+    return null;
+  }
+}
+
+export function reportSkipped(skipped) {
+  if (!skipped.length) return 0;
+  console.log(`\n✗✗ ${skipped.length} seat(s) skipped (model resolution failed) — the rest of the crew still launched:`);
+  for (const line of skipped) console.log(`   - ${line}`);
+  return 1;
+}

package/bin/crew/open.mjs

@@ -0,0 +1,168 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { call } from "./core.mjs";
+import { createWorkspace, herdrCall, paneHasAgent, reportAgent, splitPane, workspaceList, workspacePane } from "./herdr.mjs";
+import { dropState, readRows, recordState } from "./state.mjs";
+import { resolveOrchestratorDir } from "./worktrees.mjs";
+
+const STRIP = [
+  "CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT", "CLAUDE_CODE_SESSION_ID", "CLAUDE_CODE_CHILD_SESSION",
+  "CLAUDE_CODE_BRIDGE_SESSION_ID", "CLAUDE_CODE_MESSAGING_SOCKET", "CLAUDE_CODE_MESSAGING_TOKEN",
+  "CLAUDE_CODE_EXECPATH", "CLAUDE_PID",
+];
+
+function usage() {
+  console.log("usage: trantor open [<project>]\n  host THIS project's orchestrator session as a herdr pane in workspace trantor:<project>\n  (creating the workspace if needed) and print its TARGET on stdout. A second open REATTACHES:\n  it prints the existing target and exits 0 without spawning a second orchestrator.");
+}
+
+function parseArgs(args) {
+  let project = "";
+  for (const arg of args) {
+    if (arg === "--help" || arg === "-h") return { help: true };
+    if (arg.startsWith("--")) throw new Error(`trantor open: unknown flag '${arg}'`);
+    project = arg;
+  }
+  return { project };
+}
+
+function sessionFile(ctx) {
+  return join(ctx.home, ".agent-bus", "orch-sessions.txt");
+}
+
+function sessionId(ctx) {
+  const file = sessionFile(ctx);
+  if (existsSync(file)) {
+    const row = readFileSync(file, "utf8").split("\n").map(line => line.split("\t")).find(([project, id]) => project === ctx.project && id);
+    if (row) return row[1];
+  }
+  const id = randomUUID();
+  if (!ctx.dry) writeFileSync(file, `${existsSync(file) ? readFileSync(file, "utf8") : ""}${ctx.project}\t${id}\n`);
+  return id;
+}
+
+export function hasPendingHandoff(ctx) {
+  const dir = join(ctx.env.AGENT_BUS_DIR || ctx.env.RELAY_DATA_DIR || join(ctx.home, ".agent-bus"), "handoffs");
+  if (!existsSync(dir)) return false;
+  const prefix = `${ctx.project}-`;
+  for (const file of readdirSync(dir).filter(name => name.startsWith(prefix) && name.endsWith(".json")).sort().reverse()) {
+    try { if (!JSON.parse(readFileSync(join(dir, file), "utf8")).consumed) return true; }
+    catch {}
+  }
+  return false;
+}
+
+export function takeoverSessionId(ctx, id) {
+  return hasPendingHandoff(ctx) ? randomUUID() : id;
+}
+
+function harnessFlag(ctx) {
+  const result = call(process.execPath, [join(ctx.root, "bin/autonomy.mjs"), "get", "harness", "--project", ctx.project], { env: ctx.env });
+  return result.stdout === "bypass" ? " --dangerously-skip-permissions" : "";
+}
+
+function transcript(ctx, id) {
+  const slug = ctx.dir.replace(/[/.]/g, "-");
+  return join(ctx.home, ".claude", "projects", slug, `${id}.jsonl`);
+}
+
+function orchestratorCommand(ctx, id) {
+  const env = `env ${STRIP.map(name => `-u ${name}`).join(" ")} TRANTOR_ORCH=${ctx.project}`;
+  const action = existsSync(transcript(ctx, id)) ? `--resume ${id}` : `--session-id ${id}`;
+  return `${env} claude${harnessFlag(ctx)} ${action}`;
+}
+
+function tracked(ctx, live) {
+  let workspace = "";
+  let pane = "";
+  for (const row of readRows(ctx).filter(row => row.project === ctx.project)) {
+    if (row.kind === "herdrws") {
+      if (!ctx.dry && live.proven && !live.ids.has(row.handle)) dropState(ctx, ctx.project, "herdrws", "", row.handle);
+      else workspace = row.handle;
+    }
+    if (row.kind === "orch") pane = row.handle;
+  }
+  return { workspace, pane };
+}
+
+function reattach(ctx, workspace, pane, id) {
+  if (!pane) return false;
+  if (ctx.dry) { console.log(`herdr:${workspace || "%DRYWS"}/${pane}`); return true; }
+  const renamed = herdrCall(ctx, ["pane", "rename", pane, `orchestrator · ${ctx.project}`]);
+  if (!renamed.ok) { dropState(ctx, ctx.project, "orch"); return false; }
+  if (!paneHasAgent(ctx, pane)) {
+    herdrCall(ctx, ["pane", "run", pane, orchestratorCommand(ctx, id)]);
+    reportAgent(ctx, pane, "claude");
+    console.error(`— orchestrator pane was empty: resumed session ${id} in herdr:${workspace || "?"}/${pane} —`);
+  } else console.error(`— orchestrator already hosted: reattached to herdr:${workspace || "?"}/${pane} —`);
+  console.log(`herdr:${workspace || "?"}/${pane}`);
+  return true;
+}
+
+function chooseWorkspace(ctx, live, existing) {
+  if (existing) return { workspace: existing, pane: "", fresh: false };
+  if (ctx.dry) {
+    console.error(`[dry] herdr: workspace create (cwd ${ctx.dir}) --label 'trantor:${ctx.project}'`);
+    return { workspace: "%DRYWS", pane: "", fresh: false };
+  }
+  const found = live.items.find(item => [item.label, item.name, item.custom_title].includes(`trantor:${ctx.project}`));
+  if (found) {
+    const workspace = found.workspace_id || found.id || "";
+    console.error(`— adopting existing crew workspace for ${ctx.project} (${workspace}) —`);
+    return { workspace, pane: "", fresh: false };
+  }
+  const created = createWorkspace(ctx, ctx.dir, `trantor:${ctx.project}`);
+  if (!created.workspace) throw new Error("trantor open: herdr workspace create failed");
+  return { workspace: created.workspace, pane: created.pane, fresh: true };
+}
+
+function hostPane(ctx, chosen, id) {
+  let pane = chosen.pane;
+  if (ctx.dry) {
+    pane = "%DRYORCH";
+    if (!chosen.fresh) console.error(`[dry] herdr: pane split %DRYHOST(${chosen.workspace}) --direction right --cwd ${ctx.dir}`);
+    console.error(`[dry] herdr: pane rename ${pane} 'orchestrator · ${ctx.project}' + run '${orchestratorCommand(ctx, id)}'`);
+    return pane;
+  }
+  if (!chosen.fresh) {
+    const host = workspacePane(ctx, chosen.workspace, ctx.dir);
+    if (!host) throw new Error(`trantor open: workspace ${chosen.workspace} has no live pane to host the orchestrator`);
+    pane = splitPane(ctx, host, "right", ctx.dir);
+  }
+  if (!pane) throw new Error("trantor open: could not create the orchestrator pane");
+  herdrCall(ctx, ["pane", "rename", pane, `orchestrator · ${ctx.project}`]);
+  herdrCall(ctx, ["pane", "run", pane, orchestratorCommand(ctx, id)]);
+  reportAgent(ctx, pane, "claude");
+  return pane;
+}
+
+export function openOrchestrator(ctx, args) {
+  let parsed;
+  try { parsed = parseArgs(args); }
+  catch (error) { console.error(error.message); usage(); return 1; }
+  if (parsed.help) { usage(); return 0; }
+  try {
+    Object.assign(ctx, resolveOrchestratorDir(ctx, parsed.project));
+    if (!ctx.have.herdr) throw new Error("trantor open needs herdr (the pane host) — install: curl -fsSL https://herdr.dev/install.sh | sh");
+    let id = sessionId(ctx);
+    if (hasPendingHandoff(ctx)) {
+      const fresh = takeoverSessionId(ctx, id);
+      console.error(`— recorded session ${id} handed off: starting fresh as ${fresh} to claim it —`);
+      id = fresh;
+    }
+    const live = ctx.dry ? { proven: false, ids: new Set(), names: new Set(), items: [] } : workspaceList(ctx);
+    const prior = tracked(ctx, live);
+    if (reattach(ctx, prior.workspace, prior.pane, id)) return 0;
+    const chosen = chooseWorkspace(ctx, live, prior.workspace);
+    recordState(ctx, ctx.project, "herdrws", "__ws__", chosen.workspace);
+    const pane = hostPane(ctx, chosen, id);
+    dropState(ctx, ctx.project, "orch");
+    recordState(ctx, ctx.project, "orch", "__orch__", pane);
+    console.log(`herdr:${chosen.workspace}/${pane}`);
+    console.error(`— orchestrator pane hosted: herdr:${chosen.workspace}/${pane} (claude in ${ctx.dir}). 'trantor down' spares it. —`);
+    return 0;
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+}

package/bin/crew/state.mjs

@@ -0,0 +1,153 @@
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { call, listPids, run } from "./core.mjs";
+
+export function parseRow(line) {
+  const fields = line.split("\t");
+  if (fields.length >= 4) return { project: fields[0], kind: fields[1], agent: fields[2], handle: fields[3] };
+  if (fields.length === 2) return { project: "", kind: "win", agent: fields[0], handle: fields[1] };
+  return { project: "", kind: "win", agent: fields[0] || "", handle: fields[1] || "" };
+}
+
+export function readRows(ctx) {
+  if (!existsSync(ctx.statePath)) return [];
+  return readFileSync(ctx.statePath, "utf8").split("\n").filter(Boolean).map(parseRow);
+}
+
+export function writeRows(ctx, rows) {
+  if (ctx.dry) return;
+  if (!rows.length) {
+    try { unlinkSync(ctx.statePath); } catch {}
+    return;
+  }
+  const tmp = `${ctx.statePath}.tmp`;
+  writeFileSync(tmp, `${rows.map(row => [row.project, row.kind, row.agent, row.handle].join("\t")).join("\n")}\n`);
+  renameSync(tmp, ctx.statePath);
+}
+
+export function recordState(ctx, project, kind, agent, handle) {
+  if (ctx.dry) return;
+  const rows = readRows(ctx);
+  rows.push({ project, kind, agent, handle });
+  writeRows(ctx, rows);
+}
+
+export function dropState(ctx, project, kind, agent = "", handle = "") {
+  const rows = readRows(ctx).filter(row => !(
+    row.project === project && row.kind === kind &&
+    (!agent || row.agent === agent) && (!handle || row.handle === handle)
+  ));
+  writeRows(ctx, rows);
+}
+
+function killSeatProcesses(ctx, project, agent) {
+  if (ctx.env.CREW_NO_PROC_KILL === "1" || !project || !agent) return;
+  const patterns = [`seats/${project}-${agent}\\.sh`, `crew-runner\\.mjs ${agent} .*/${project}$`];
+  for (const pattern of patterns) {
+    for (const pid of listPids(pattern)) run(ctx, "kill", ["-9", pid], { rendered: `kill -9 ${pid} 2>/dev/null` });
+  }
+}
+
+function killTerminal(ctx, handle) {
+  if (!handle) return;
+  const tty = call("osascript", ["-e", `tell application \"Terminal\" to get tty of (first window whose id is ${handle})`]).stdout;
+  if (tty) {
+    const processes = call("ps", ["-t", tty.replace("/dev/", ""), "-o", "pid="]).stdout.split(/\s+/).filter(Boolean);
+    for (const pid of processes) run(ctx, "kill", ["-9", pid], { rendered: `kill -9 ${pid} 2>/dev/null` });
+  }
+  run(ctx, "osascript", ["-e", `tell application \"Terminal\" to close (first window whose id is ${handle})`]);
+}
+
+function usage(project) {
+  console.log(`usage: trantor down [<agent>...] [--all] [--yes]\n  trantor down              tear down THIS project's crew (${project})\n  trantor down codex glm    tear down only those seats in this project\n  trantor down --all --yes  tear down EVERY project's crew on this machine (--yes required)`);
+}
+
+function parseDownArgs(ctx, args) {
+  const parsed = { all: false, yes: false, agents: [] };
+  for (const arg of args) {
+    if (arg === "--all") parsed.all = true;
+    else if (arg === "--yes" || arg === "-y") parsed.yes = true;
+    else if (arg === "--help" || arg === "-h") { usage(ctx.project); return { help: true }; }
+    else if (arg.startsWith("--")) {
+      console.log(`trantor down: unknown flag '${arg}'`);
+      usage(ctx.project);
+      return { error: true };
+    } else parsed.agents.push(arg);
+  }
+  return parsed;
+}
+
+function closeRow(ctx, row, selected, orchProjects, adapters, tmuxClosed) {
+  const perSeat = selected.length > 0;
+  const hasOrch = orchProjects.has(row.project);
+  if (row.kind === "cmuxws" && !perSeat && !hasOrch) adapters.cmux.closeWorkspace(row.handle);
+  if (row.kind === "cmux" && (perSeat || hasOrch)) adapters.cmux.closePane(row.handle);
+  if (row.kind === "herdrws" && !perSeat && !hasOrch) adapters.herdr.closeWorkspace(row.handle);
+  if (row.kind === "herdr" && (perSeat || hasOrch)) adapters.herdr.closePane(row.handle);
+  if (row.kind === "tmux") closeTmux(ctx, row, perSeat, tmuxClosed);
+  if ((row.kind === "win" || row.kind === "attach") && !(perSeat && row.kind === "attach")) killTerminal(ctx, row.handle);
+  if (!["cmuxws", "attach", "herdrws", "orch"].includes(row.kind)) killSeatProcesses(ctx, row.project, row.agent);
+}
+
+function closeTmux(ctx, row, perSeat, seen) {
+  if (perSeat) {
+    run(ctx, "tmux", ["kill-pane", "-t", row.handle], { rendered: `tmux kill-pane -t '${row.handle}' 2>/dev/null` });
+    return;
+  }
+  const session = `trantor:${row.project}`;
+  if (seen.has(session)) return;
+  seen.add(session);
+  run(ctx, "tmux", ["kill-session", "-t", session], { rendered: `tmux kill-session -t '${session}' 2>/dev/null` });
+}
+
+export function down(ctx, args, adapters) {
+  const options = parseDownArgs(ctx, args);
+  if (options.help) return 0;
+  if (options.error) return 1;
+  const rows = readRows(ctx);
+  if (!rows.length) { console.log("no tracked crew windows"); return 0; }
+  const scoped = rows.filter(row => (options.all || row.project === ctx.project) && (!options.agents.length || options.agents.includes(row.agent)));
+  const scope = options.all ? "all projects" : `project \"${ctx.project}\"`;
+  if (!scoped.length) { console.log(`nothing to tear down for ${scope}`); return 0; }
+  console.log(`— tearing down (${scope}):`);
+  for (const row of scoped) if (!["attach", "cmuxws", "herdrws", "orch"].includes(row.kind)) console.log(`  • ${row.project || "<legacy>"} · ${row.agent} (${row.kind})`);
+  if (options.all && !options.yes) {
+    console.log("— this is EVERY project's crew. Re-run with --yes to confirm:  trantor down --all --yes");
+    return 0;
+  }
+  const orchProjects = new Set(rows.filter(row => row.kind === "orch").map(row => row.project));
+  const tmuxClosed = new Set();
+  for (const row of scoped) closeRow(ctx, row, options.agents, orchProjects, adapters, tmuxClosed);
+  const removed = new Set(scoped.map(row => `${row.project}|${row.kind}|${row.agent}|${row.handle}`));
+  const kept = rows.filter(row => !removed.has(`${row.project}|${row.kind}|${row.agent}|${row.handle}`) || (orchProjects.has(row.project) && ["herdrws", "cmuxws", "orch"].includes(row.kind)));
+  writeRows(ctx, kept);
+  console.log(`— crew torn down (${scope})`);
+  return 0;
+}
+
+function terminalAlive(row) {
+  return Boolean(call("osascript", ["-e", `tell application \"Terminal\" to get id of (first window whose id is ${row.handle})`]).stdout);
+}
+
+export function prune(ctx, adapters) {
+  const rows = readRows(ctx);
+  if (!rows.length || ctx.dry) return;
+  const cmuxLive = adapters.cmux.liveWorkspaces();
+  const herdrLive = adapters.herdr.liveWorkspaces();
+  const kept = rows.filter(row => {
+    if (["win", "attach"].includes(row.kind)) return terminalAlive(row);
+    if (row.kind === "tmux") return call("tmux", ["has-session", "-t", `trantor:${row.project}`]).ok;
+    if (row.kind === "cmuxws") return !cmuxLive.proven || cmuxLive.ids.has(row.handle);
+    if (row.kind === "cmux") return !cmuxLive.proven || cmuxLive.names.has(`trantor:${row.project}`);
+    if (row.kind === "herdrws") return !herdrLive.proven || herdrLive.ids.has(row.handle);
+    if (["herdr", "orch"].includes(row.kind)) return !herdrLive.proven || herdrLive.names.has(`trantor:${row.project}`);
+    return true;
+  });
+  writeRows(ctx, kept);
+}
+
+export function reapSeat(ctx, agent) {
+  const escapedDir = ctx.dir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  for (const pid of listPids(`crew-runner\\.mjs ${agent} ${escapedDir}$`)) {
+    run(ctx, "kill", ["-9", pid], { rendered: `kill -9 ${pid} 2>/dev/null` });
+  }
+}

package/bin/crew/tmux.mjs

@@ -0,0 +1,75 @@
+import { appleScript, appleScriptString, call, runnerCommand, run, shellQuote } from "./core.mjs";
+import { recordState } from "./state.mjs";
+
+export function spawnTmux(ctx, specs, resolve) {
+  const session = `trantor:${ctx.project}`;
+  let first = !call("tmux", ["has-session", "-t", session], { env: ctx.env }).ok;
+  for (const spec of specs) {
+    const seat = resolve(spec);
+    if (!seat) continue;
+    const command = runnerCommand(ctx, seat.agent, seat.model);
+    let pane = ctx.dry ? "%DRY" : "";
+    if (first) {
+      run(ctx, "tmux", ["new-session", "-d", "-s", session, "-n", "crew", "-x", "260", "-y", "60"], { rendered: `tmux new-session -d -s '${session}' -n crew -x 260 -y 60` });
+      run(ctx, "tmux", ["send-keys", "-t", session, command, "Enter"], { rendered: `tmux send-keys -t '${session}' ${shellQuote(command)} Enter` });
+      first = false;
+    } else {
+      run(ctx, "tmux", ["split-window", "-t", session, command], { rendered: `tmux split-window -t '${session}' ${shellQuote(command)}` });
+      run(ctx, "tmux", ["select-layout", "-t", session, "tiled"], { rendered: `tmux select-layout -t '${session}' tiled >/dev/null 2>&1` });
+    }
+    if (!ctx.dry) pane = call("tmux", ["display-message", "-p", "-t", session, "#{pane_id}"], { env: ctx.env }).stdout;
+    run(ctx, "tmux", ["select-pane", "-t", pane || session, "-T", seat.agent.toUpperCase()], { rendered: `tmux select-pane -t '${pane || session}' -T ${seat.agent.toUpperCase()}` });
+    recordState(ctx, ctx.project, "tmux", seat.agent, pane || "%?");
+    console.log(`  → ${seat.agent} pane in ${session}`);
+  }
+  run(ctx, "tmux", ["set-option", "-t", session, "pane-border-status", "top"], { rendered: `tmux set-option -t '${session}' pane-border-status top >/dev/null 2>&1` });
+  run(ctx, "tmux", ["set-option", "-t", session, "pane-border-format", " #{pane_title} "], { rendered: `tmux set-option -t '${session}' pane-border-format ' #{pane_title} ' >/dev/null 2>&1` });
+  if (ctx.dry) {
+    console.log(`[dry] would attach a Terminal window to ${session}`);
+    recordState(ctx, ctx.project, "attach", "__win__", "%DRYWIN");
+    return;
+  }
+  const attached = appleScript(`tell application "Terminal"\nset w to do script "tmux attach -t ${appleScriptString(session)}"\nset custom title of w to "${appleScriptString(`${ctx.project} — trantor crew`)}"\nset theWin to first window whose tabs contains w\nreturn id of theWin\nend tell\n`);
+  if (attached.stdout) recordState(ctx, ctx.project, "attach", "__win__", attached.stdout);
+  console.log(`— crew grouped in tmux session ${session} (one window: ${ctx.project} — trantor crew). Detach with Ctrl-b d; it keeps running. —`);
+}
+
+export function spawnTerminal(ctx, specs, resolve) {
+  console.log("— no cmux/tmux → per-agent Terminal windows. For ONE grouped, named window per crew (and");
+  console.log("  bulletproof scoped teardown), install cmux, or run:  brew install tmux  —");
+  const rect = terminalRect(ctx);
+  const columns = specs.length <= 2 ? 1 : 2;
+  const rows = Math.ceil(specs.length / columns);
+  const width = Math.floor(rect.width / columns);
+  const height = Math.floor(rect.height / rows);
+  for (let index = 0; index < specs.length; index += 1) {
+    const seat = resolve(specs[index]);
+    if (!seat) continue;
+    const x = rect.x + (index % columns) * width;
+    const y = rect.y + Math.floor(index / columns) * height;
+    if (ctx.dry) {
+      console.log(`[dry] Terminal window for ${seat.agent} at ${x},${y}`);
+      recordState(ctx, ctx.project, "win", seat.agent, `%DRYWIN${index}`);
+      continue;
+    }
+    const command = `clear && ${runnerCommand(ctx, seat.agent, seat.model)}`;
+    const title = `${ctx.project} · ${seat.agent.toUpperCase()}`;
+    const result = appleScript(`tell application "Terminal"\nset w to do script "${appleScriptString(command)}"\nset custom title of w to "${appleScriptString(title)}"\nset theWin to first window whose tabs contains w\nset bounds of theWin to {${x}, ${y}, ${x + width}, ${y + height}}\nreturn id of theWin\nend tell\n`);
+    if (result.stdout) {
+      recordState(ctx, ctx.project, "win", seat.agent, result.stdout);
+      console.log(`  → ${seat.agent} window spawned (${ctx.project} · ${seat.agent})`);
+    } else console.log(`  ✗ ${seat.agent} osascript spawn ERROR`);
+    call("sleep", ["1.2"]);
+  }
+}
+
+function terminalRect(ctx) {
+  if (ctx.env.CREW_RECT) {
+    const [x, y, width, height] = ctx.env.CREW_RECT.split(",").map(Number);
+    return { x, y, width, height };
+  }
+  const result = call("osascript", ["-e", 'tell application "Finder" to get bounds of window of desktop']);
+  const [left = 0, top = 25, right = 1440, bottom = 900] = result.stdout.split(/,\s*/).map(Number);
+  const screenWidth = right - left;
+  return { x: left + Math.floor(screenWidth * 0.42), y: top || 25, width: Math.floor(screenWidth * 0.58), height: bottom - (top || 25) };
+}

package/bin/crew/verify.mjs

@@ -0,0 +1,19 @@
+import { call } from "./core.mjs";
+
+export function epochMs() {
+  return Date.now();
+}
+
+export function verifyCrew(ctx, agents, since) {
+  const result = call(process.execPath, [
+    `${ctx.root}/bin/crew-verify.mjs`, ctx.project, ...agents,
+    "--since", String(since), "--timeout", "30",
+  ], { env: ctx.env });
+  if (result.stdout) console.log(result.stdout);
+  return result.stdout;
+}
+
+export function failedAgents(output) {
+  const line = String(output).split("\n").find(value => value.startsWith("FAILED:"));
+  return line ? line.slice("FAILED:".length).split(",").map(value => value.trim()).filter(Boolean) : [];
+}

package/bin/crew/worktrees.mjs

@@ -0,0 +1,50 @@
+import { basename, join } from "node:path";
+import { existsSync } from "node:fs";
+import { call } from "./core.mjs";
+
+function gitRoot(dir) {
+  const result = call("git", ["-C", dir, "rev-parse", "--show-toplevel"]);
+  return result.ok ? result.stdout : "";
+}
+
+export function resolveOrchestratorDir(ctx, projectArg) {
+  const target = projectArg || ctx.project;
+  const badge = ctx.env.TRANTOR_ORCH || ctx.env.TRANTOR_SEAT || "";
+  const root = gitRoot(ctx.dir);
+  const here = root ? basename(root) : "";
+  if (badge && badge !== target) {
+    throw new Error(`trantor open: refused — this shell is badged for '${badge}', not '${target}'; open it from the target project's shell`);
+  }
+  if (here && here !== target) {
+    throw new Error(`trantor open: refused — cwd belongs to project '${here}', not '${target}'; cd to the target checkout first`);
+  }
+  if (!projectArg || target === here) return { dir: ctx.dir, project: target };
+  const devRoot = ctx.env.TRANTOR_DEV_ROOT || join(ctx.home, "development");
+  const targetDir = join(devRoot, target);
+  if (existsSync(targetDir)) {
+    console.error(`— opening ${target} in its checkout: ${targetDir} —`);
+    return { dir: targetDir, project: target };
+  }
+  throw new Error(`trantor open: '${target}' has no checkout at ${targetDir} — cd into the project first`);
+}
+
+function linkedByTest(env, badge, project) {
+  if (!("CREW_TEST_POLICY_LINKS" in env)) return null;
+  const links = String(env.CREW_TEST_POLICY_LINKS).split(",");
+  return links.includes(`${badge}:${project}`) || links.includes(`${project}:${badge}`);
+}
+
+export function guardCrossProjectUp(ctx) {
+  const badge = ctx.env.TRANTOR_ORCH || ctx.env.TRANTOR_SEAT || "";
+  if (!badge || badge === ctx.project) return true;
+  let linked = linkedByTest(ctx.env, badge, ctx.project);
+  if (linked === null) linked = call(process.execPath, [join(ctx.root, "bin/policy.mjs"), "check", badge, ctx.project], { env: ctx.env }).ok;
+  if (!linked) {
+    console.error(`trantor: refused — this shell is badged for '${badge}', not '${ctx.project}'.`);
+    console.error("  Cross-project action is a breach unless the operator linked the projects.");
+    console.error(`  Run: trantor policy link ${badge} ${ctx.project} --reason \"<why>\"`);
+    return false;
+  }
+  console.error(`trantor: '${badge}' ↔ '${ctx.project}' is policy-linked — proceeding.`);
+  return true;
+}

package/bin/crew-runner.mjs

@@ -31,7 +31,7 @@ import {
 const AGENT = process.argv[2];
 const DIR = process.argv[3] || process.cwd();
 // Crew agents MUST share the orchestrator's project key (one repo = one lane).
-// RELAY_PROJECT is inherited from crew.sh (the host's resolved key); else fall
+// RELAY_PROJECT is inherited from crew.mjs (the host's resolved key); else fall
 // back to the git-repo-root basename — never a loose dir basename that could
 // fork the host's "builtbetter.ai" into a separate "builtbetter" lane.
 const PROJ = process.env.RELAY_PROJECT || resolveProject(DIR);
@@ -620,6 +620,10 @@ async function runTurn(prompt, isFirst, trigger = "kickoff") {
   // the turn was CUT rather than that the CLI failed on its own. Cleared before every turn.
   const CUTF = join(homedir(), ".agent-bus", `turncut-${AGENT}-${PROJ}`);
   try { unlinkSync(CUTF); } catch {}
+  // Touched by the stderr scrubber as its LAST act (the shell below); node waits for it after
+  // spawnSync before reading ERRF — see the drain note at the spawnSync call.
+  const DRAINF = join(homedir(), ".agent-bus", `turndrain-${AGENT}-${PROJ}`);
+  try { unlinkSync(DRAINF); } catch {}
   try {
     writeFileSync(STAMPF, JSON.stringify({ turn: TURN, startedAt: Date.now(), runner: RUNNER_ID }));
     const wd = spawn(process.execPath, [join(import.meta.dirname, "turn-watchdog.mjs"), STAMPF, ERRF, String(WD_MS), SESSION, PROJ, HUB, TRANSCRIPT_DIR, TURN_DIR],
@@ -652,7 +656,7 @@ ${sweep}
   sweep $job
 ) & boxpid=$!` : "boxpid=";
   const shell = `set -o pipefail
-{ ${inner} ; } 2> >(${SCRUB} --tee2 ${ERRF}) &
+{ ${inner} ; } 2> >(${SCRUB} --tee2 ${ERRF}; : >> "${DRAINF}") &
 job=$!${box}
 wait $job; turn_exit=$?
 [ -n "$boxpid" ] && kill $boxpid 2>/dev/null
@@ -669,9 +673,9 @@ exit $turn_exit`;
     cwd: TURN_DIR, encoding: "utf8", stdio: cli.sid ? ["ignore", "pipe", "inherit"] : ["ignore", "inherit", "inherit"],
     env: { ...process.env, RELAY_URL: HUB, RELAY_AGENT: AGENT, RELAY_SESSION: SESSION, RELAY_PROJECT: PROJ,
       // #6228: badges this seat's env as belonging to PROJ, distinctly from a one-off RELAY_PROJECT
-      // override (bin/crew.sh's own tests, and any deliberate `RELAY_PROJECT=x trantor up` from a
+      // override (bin/crew.mjs's own tests, and any deliberate `RELAY_PROJECT=x trantor up` from a
       // plain shell, set RELAY_PROJECT alone and must keep working — only THIS marker means "the
-      // env I'm running in already has a project home"). crew.sh's `up` guard refuses to bring up a
+      // env I'm running in already has a project home"). crew.mjs's `up` guard refuses to bring up a
       // DIFFERENT project's crew from a shell carrying this badge, same as it refuses TRANTOR_ORCH.
       TRANTOR_SEAT: PROJ,
       // A RUNNER-MANAGED SEAT MUST NEVER HAND ITSELF A BATON.
@@ -695,12 +699,25 @@ exit $turn_exit`;
   // is the point: the shell kills while the tree is still walkable, node cannot.
   if (TURN_MAX_MS) { spawnOpts.timeout = TURN_MAX_MS + 30000; spawnOpts.killSignal = "SIGKILL"; }
   const r = spawnSync("/bin/bash", ["-c", shell], spawnOpts);
-  killWatchdog();                        // #6206: turn over — the watchdog dies NOW, it does not sleep on
-  try { unlinkSync(STAMPF); } catch {}   // disarm any survivor: the stamp is gone
   // The shell's box leaves the marker; the backstop leaves an ETIMEDOUT. Either way the turn was
   // cut, not merely failed.
   const boxed = existsSync(CUTF);
   const cut = !!TURN_MAX_MS && (boxed || r.error?.code === "ETIMEDOUT");
+  // DRAIN before classifying — but never on a CUT turn: the box's sweep killed the scrubber
+  // mid-flight, so its marker can never appear and waiting is pure stall. bash 3.2 (macOS's
+  // /bin/bash) `wait` does NOT wait for process substitutions — verified 2026-09-05 — so when
+  // spawnSync returns on a LIVE turn, the stderr scrubber can still be draining, and an auth
+  // line still in the pipe reads as an EMPTY ERRF: the turn is then mislabelled "empty-output",
+  // which breaks the seat-down contract (wrong DOWN label, retry ladder instead of a park) and
+  // cost run 33940247163 three CI-only drill-6 failures. The scrubber touches DRAINF as its
+  // last act; wait for it, bounded.
+  if (!cut) {
+    const drainStart = Date.now();
+    while (!existsSync(DRAINF) && Date.now() - drainStart < 3000) await new Promise(s => setTimeout(s, 50));
+  }
+  try { unlinkSync(DRAINF); } catch {}
+  killWatchdog();                        // #6206: turn over — the watchdog dies NOW, it does not sleep on
+  try { unlinkSync(STAMPF); } catch {}   // disarm any survivor: the stamp is gone
   if (cut) {
     // Belt and braces after the shell's descendant sweep: anything still sharing the turn's group.
     if (r.pid) { try { process.kill(-r.pid, "SIGKILL"); } catch {} }