@directed/cli 0.1.2 → 0.1.3

package/dist/cli.js

@@ -2,826 +2,2014 @@
 
 // src/cli.ts
 import { realpathSync } from "fs";
+import { basename as basename4 } from "path";
 import { pathToFileURL } from "url";
-import { randomBytes as randomBytes2 } from "crypto";
-import { execFileSync } from "child_process";
+import { randomBytes as randomBytes3 } from "crypto";
+import { execFileSync, spawn as spawn3 } from "child_process";
 import { createRequire } from "module";
 
-// src/config.ts
-if (false) throw new Error("$HUB_URL is required, e.g. HUB_URL=https://hub.directed.ai");
-var DEFAULTS = {
-  acceptMode: "send",
-  tmuxBin: "tmux",
-  hubUrl: "https://hub.directed.ai",
-  toChat: false,
-  chatTargetQuery: null,
-  openOnStart: true,
-  invitees: [],
-  inviteEmails: []
-};
+// src/agent.ts
+import { basename as basename3 } from "path";
 
-// src/update-check.ts
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
+// src/claude.ts
+import { readFile, readdir, stat, writeFile } from "fs/promises";
 import { homedir } from "os";
-import { dirname, join } from "path";
-var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-function statePath() {
-  const home = process.env.DIRECTED_HOME ?? homedir();
-  return join(home, ".directed", "state.json");
-}
-function stateLoad() {
+import { basename, dirname, join as join2 } from "path";
+
+// src/hook.ts
+import { randomBytes } from "crypto";
+import { mkdtempSync, rmSync } from "fs";
+import { connect, createServer } from "net";
+import { tmpdir } from "os";
+import { join } from "path";
+var HOOK_SOCKET_ENV = "DIRECTED_HOOK_SOCKET";
+var HOOK_NONCE_ENV = "DIRECTED_HOOK_NONCE";
+var STDIN_WAIT_MS = 2e3;
+var TranscriptHook = class _TranscriptHook {
+  constructor(server, dir, socketPath, nonce) {
+    this.socketPath = socketPath;
+    this.nonce = nonce;
+    this.server = server;
+    this.dir = dir;
+  }
+  socketPath;
+  nonce;
+  server;
+  dir;
+  listeners = [];
+  last = null;
+  // A 0700 scratch directory an agent may drop launch config into. Removed with
+  // the socket when the session ends.
+  get dirPath() {
+    return this.dir;
+  }
+  // The socket lives in a 0700 directory: any process able to connect could
+  // otherwise name an arbitrary file as this session's transcript.
+  static async open() {
+    const dir = mkdtempSync(join(tmpdir(), "directed-hook-"));
+    const socketPath = join(dir, "hook.sock");
+    const nonce = randomBytes(16).toString("hex");
+    const server = createServer();
+    const hook = new _TranscriptHook(server, dir, socketPath, nonce);
+    server.on("connection", (socket) => {
+      let body = "";
+      socket.setEncoding("utf8");
+      socket.on("data", (d) => {
+        body += d;
+      });
+      socket.on("end", () => hook.accept(body));
+      socket.on("error", () => socket.destroy());
+    });
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(socketPath, resolve);
+    });
+    server.unref();
+    return hook;
+  }
+  // Every announcement, not just the first. Claude fires SessionStart again on
+  // resume, /clear and compaction, and /clear starts a new transcript -- without
+  // this the reader would stay on the abandoned one for the rest of the session.
+  // A late listener gets the most recent one: the socket opens before the agent
+  // launches, but the reader it feeds is built after.
+  onAnnounce(listener) {
+    this.listeners.push(listener);
+    if (this.last !== null) listener(this.last);
+  }
+  close() {
+    this.server.close();
+    rmSync(this.dir, { recursive: true, force: true });
+  }
+  accept(body) {
+    const announced = announcementParse(body, this.nonce);
+    if (announced === null) return;
+    this.last = announced;
+    for (const listener of this.listeners) listener(announced);
+  }
+};
+function announcementParse(body, nonce) {
+  let payload;
   try {
-    return JSON.parse(readFileSync(statePath(), "utf8"));
+    payload = JSON.parse(body);
   } catch {
     return null;
   }
+  if (typeof payload !== "object" || payload === null) return null;
+  const record = payload;
+  if (record.nonce !== nonce) return null;
+  const sessionId = record.session_id;
+  const transcriptPath = record.transcript_path;
+  const cwd = record.cwd;
+  if (typeof sessionId !== "string" || !sessionId) return null;
+  if (typeof transcriptPath !== "string" || !transcriptPath) return null;
+  return {
+    sessionId,
+    transcriptPath,
+    cwd: typeof cwd === "string" ? cwd : "",
+    trigger: typeof record.source === "string" ? record.source : "startup"
+  };
 }
-function stateSave(state) {
+async function hookRun(env = process.env) {
+  const socketPath = env[HOOK_SOCKET_ENV];
+  const nonce = env[HOOK_NONCE_ENV];
+  if (!socketPath || !nonce) return 0;
+  const payload = await stdinRead();
+  let record;
   try {
-    const path = statePath();
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify(state));
+    record = JSON.parse(payload);
   } catch {
+    return 0;
   }
+  await socketSend(socketPath, JSON.stringify({ ...record, nonce }));
+  return 0;
 }
-function versionIsNewer(latest, current) {
-  const a = latest.split(".").map(Number);
-  const b = current.split(".").map(Number);
-  for (let i = 0; i < Math.max(a.length, b.length); i++) {
-    const x = a[i] ?? 0;
-    const y = b[i] ?? 0;
-    if (x !== y) return x > y;
-  }
-  return false;
+function stdinRead() {
+  return new Promise((resolve) => {
+    let body = "";
+    const timer = setTimeout(() => resolve(body), STDIN_WAIT_MS);
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (d) => {
+      body += d;
+    });
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      resolve(body);
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timer);
+      resolve(body);
+    });
+  });
 }
-async function updateCheckRun(currentVersion, hubUrl, fetchImpl = fetch) {
-  const cached = stateLoad();
-  const now = Date.now();
-  let latest = cached?.latestKnownVersion;
-  if (!cached || now - cached.lastCheckedAt > CHECK_INTERVAL_MS) {
+function socketSend(socketPath, body) {
+  return new Promise((resolve) => {
+    const socket = connect(socketPath);
+    socket.on("connect", () => socket.end(body));
+    socket.on("close", () => resolve());
+    socket.on("error", () => {
+      socket.destroy();
+      resolve();
+    });
+  });
+}
+
+// src/claude.ts
+function projectDirEncode(cwd) {
+  return cwd.replace(/[/.]/g, "-");
+}
+var SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ClaudeAgent = class {
+  kind = "claude_code";
+  async transcriptLocate(cwd, sinceMs) {
+    const newest = await newestTranscript(projectDir(cwd));
+    if (!newest || newest.mtimeMs < sinceMs) return null;
+    return newest.path;
+  }
+  // Claude names a subagent in the result of the call that launched it, so the
+  // parent's own transcript is the whole discovery mechanism -- the .meta.json
+  // beside the child's file says nothing this does not.
+  transcriptChildren(line) {
+    let record;
     try {
-      const res = await fetchImpl(`${hubUrl}/cli/version`, { signal: AbortSignal.timeout(1500) });
-      if (res.ok) {
-        latest = (await res.json()).version;
-        stateSave({ lastCheckedAt: now, latestKnownVersion: latest });
-      }
+      record = JSON.parse(line);
     } catch {
+      return [];
     }
+    if (!isRecord(record)) return [];
+    const result = record.toolUseResult;
+    if (!isRecord(result) || typeof result.agentId !== "string" || !result.agentId)
+      return [];
+    return [{ key: childKey(result.agentId), callKey: toolUseId(record) }];
+  }
+  // Claude keeps a session's subagents in a directory named for that session,
+  // so the path follows from the root transcript and the child's own key.
+  async transcriptChildLocate(rootPath, child) {
+    const key = this.transcriptKey(rootPath);
+    if (key === null) return null;
+    const path = join2(
+      dirname(rootPath),
+      key,
+      "subagents",
+      `${child.key}.jsonl`
+    );
+    return await isFile(path) ? path : null;
+  }
+  // A settings file for this launch only, holding the user's own settings with
+  // our SessionStart hook added to them.
+  //
+  // --settings replaces rather than merges, so writing only our hook silently
+  // turned off every SessionStart hook the person had configured -- directed is
+  // meant to wrap their agent, not change how it behaves. The file is scoped to
+  // the run and removed with the hook socket; their own settings are never
+  // written to.
+  async hookArgs(hook) {
+    const path = join2(hook.dirPath, "claude-settings.json");
+    const command = `${HOOK_SOCKET_ENV}=${hook.socketPath} ${HOOK_NONCE_ENV}=${hook.nonce} ` + hookCommand();
+    await writeFile(
+      path,
+      JSON.stringify(settingsMerge(await settingsRead(), command))
+    );
+    return ["--settings", path];
   }
-  if (latest && versionIsNewer(latest, currentVersion)) {
-    process.stderr.write(`[directed] a new version is available (${currentVersion} -> ${latest}). Run 'directed upgrade' to update.
-`);
+  transcriptKey(path) {
+    const name = basename(path);
+    if (!name.endsWith(".jsonl")) return null;
+    return name.slice(0, -".jsonl".length);
+  }
+  // Claude names a transcript after its session, under the project directory
+  // for the workspace it ran in.
+  async transcriptPath(key) {
+    const path = join2(projectDir(process.cwd()), `${key}.jsonl`);
+    return await isFile(path) ? path : null;
   }
+  // Claude Code appends to the same <sessionId>.jsonl on --resume/--continue,
+  // so the resumed session's id is knowable before launch: from the flag's own
+  // argument, or from the newest transcript on disk for --continue. A bare
+  // --resume opens claude's interactive picker -- the target is unknowable, so
+  // it reads as a fresh session. --fork-session branches into a new id.
+  async resumeKey(command, cwd) {
+    const args = command.slice(1);
+    if (args.includes("--fork-session")) return null;
+    for (let i = 0; i < args.length; i++) {
+      const [flag, inline] = flagSplit(args[i]);
+      if (flag === "--resume" || flag === "-r" || flag === "--session-id") {
+        const candidate = inline ?? args[i + 1];
+        if (candidate !== void 0 && SESSION_ID_RE.test(candidate))
+          return candidate;
+      } else if (flag === "--continue" || flag === "-c") {
+        const newest = await newestTranscript(projectDir(cwd));
+        return newest ? this.transcriptKey(newest.path) : null;
+      }
+    }
+    return null;
+  }
+};
+function childKey(agentId) {
+  return agentId.startsWith("agent-") ? agentId : `agent-${agentId}`;
 }
-
-// src/upgrade.ts
-import { spawnSync } from "child_process";
-import { mkdtempSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { tmpdir } from "os";
-import { join as join2 } from "path";
-async function upgradeRun(hubUrl, fetchImpl = fetch) {
-  const scriptUrl = `${hubUrl}/cli/install.sh`;
-  process.stdout.write(`[directed] fetching installer from ${scriptUrl}
-`);
-  const res = await fetchImpl(scriptUrl);
-  if (!res.ok) {
-    console.error(`[directed] could not fetch installer: ${res.status} ${res.statusText}`);
-    return 1;
+function toolUseId(record) {
+  const message = record.message;
+  if (!isRecord(message) || !Array.isArray(message.content)) return "";
+  for (const block of message.content) {
+    if (isRecord(block) && block.type === "tool_result" && typeof block.tool_use_id === "string") {
+      return block.tool_use_id;
+    }
   }
-  const script = await res.text();
-  const dir = mkdtempSync(join2(tmpdir(), "directed-upgrade-"));
+  return "";
+}
+async function isFile(path) {
   try {
-    const scriptPath = join2(dir, "install.sh");
-    writeFileSync2(scriptPath, script, { mode: 493 });
-    const result = spawnSync("bash", [scriptPath], {
-      stdio: "inherit",
-      env: { ...process.env, DIRECTED_CLI_BASE_URL: hubUrl }
-    });
-    return result.status ?? 1;
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
+    return (await stat(path)).isFile();
+  } catch {
+    return false;
   }
 }
-
-// src/transcript/to-transcript.ts
-function turnToTranscript(turn) {
-  const text = turn.parts.filter((p) => p.kind === "text").map((p) => p.text).join("");
-  return { role: turn.role, text, clientTurnId: turn.id };
+function hookCommand() {
+  return `${JSON.stringify(process.execPath)} ${JSON.stringify(process.argv[1] ?? "")} __hook`;
 }
-
-// src/transport.ts
-var HubTransport = class {
-  constructor(hub, tokenRefresher, source, conversation, title = "", echoGuard = null, externalRef = null, destinationChatPublicId = null, memberIdentifiers = [], onUserTurn = null) {
-    this.hub = hub;
-    this.tokenRefresher = tokenRefresher;
-    this.source = source;
-    this.conversation = conversation;
-    this.title = title;
-    this.echoGuard = echoGuard;
-    this.externalRef = externalRef;
-    this.destinationChatPublicId = destinationChatPublicId;
-    this.memberIdentifiers = memberIdentifiers;
-    this.onUserTurn = onUserTurn;
+function projectDir(cwd) {
+  return join2(homedir(), ".claude/projects", projectDirEncode(cwd));
+}
+function flagSplit(arg) {
+  const at = arg.indexOf("=");
+  if (at === -1) return [arg, void 0];
+  return [arg.slice(0, at), arg.slice(at + 1)];
+}
+async function newestTranscript(dir) {
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return null;
   }
-  hub;
-  tokenRefresher;
-  source;
-  conversation;
-  title;
-  echoGuard;
-  externalRef;
-  destinationChatPublicId;
-  memberIdentifiers;
-  onUserTurn;
-  off = null;
-  sid = null;
-  chatPublicId = null;
-  agentActorPublicId = null;
-  wasReattached = false;
-  skippedInviteeList = [];
-  // On reattach, the id of the newest turn the hub already has. The resumed
-  // transcript replays from the top, and turns at or before this one must not
-  // post: some were never posted at all (mention echoes the original run's
-  // echo guard suppressed), so no server-side dedup row exists to catch them.
-  // Cleared once the replay passes it; null means no filtering.
-  replayCutoffId = null;
-  // Publishes chain through here so turnAppend for turn N resolves before N+1
-  // is sent -- message_seq is allocated in POST-arrival order, so concurrent
-  // posts (the snapshot backlog fires many at once) would scramble it.
-  chain = Promise.resolve();
-  get sessionId() {
-    return this.sid;
-  }
-  get chatId() {
-    return this.chatPublicId;
-  }
-  // The vendor agent's actor id, so a mention listener knows which member an
-  // @-mention must target to reach this CLI.
-  get agentActorId() {
-    return this.agentActorPublicId;
-  }
-  // Whether the hub matched externalRef to an earlier session (a resumed CLI
-  // run) and re-attached this one to that session's existing chat.
-  get reattached() {
-    return this.wasReattached;
-  }
-  // Invitees the hub could not match to an active connection and did not seat.
-  get skippedInvitees() {
-    return this.skippedInviteeList;
-  }
-  async start() {
-    const token = await this.tokenRefresher.current();
-    const session = await this.hub.sessionStart(token, {
-      source: this.source,
-      title: this.title,
-      externalRef: this.externalRef ?? void 0,
-      destinationChatPublicId: this.destinationChatPublicId ?? void 0,
-      memberIdentifiers: this.memberIdentifiers
-    });
-    this.sid = session.terminalSessionPublicId;
-    this.chatPublicId = session.chatPublicId;
-    this.agentActorPublicId = session.agentActorPublicId;
-    this.wasReattached = session.reattached === true;
-    this.skippedInviteeList = session.skippedMemberIdentifiers ?? [];
-    this.replayCutoffId = this.wasReattached ? session.lastClientTurnId || null : null;
-    const enqueue = (turn) => this.enqueue(turn);
-    for (const turn of this.conversation.snapshot()) enqueue(turn);
-    this.off = this.conversation.subscribe(enqueue);
-    return session.chatUrl;
+  let newest = null;
+  for (const entry of entries) {
+    if (!entry.endsWith(".jsonl")) continue;
+    const path = join2(dir, entry);
+    const info = await stat(path);
+    if (!newest || info.mtimeMs > newest.mtimeMs)
+      newest = { path, mtimeMs: info.mtimeMs };
   }
-  async stop() {
-    this.off?.();
-    this.off = null;
-    await this.chain;
-    if (this.sid === null) return;
+  return newest;
+}
+var SETTINGS_PATH_LIST = [
+  ".claude/settings.json",
+  ".claude/settings.local.json"
+];
+async function settingsRead() {
+  const merged = {};
+  const pathList = [
+    join2(homedir(), ".claude", "settings.json"),
+    ...SETTINGS_PATH_LIST.map((relative) => join2(process.cwd(), relative))
+  ];
+  for (const path of pathList) {
     try {
-      const token = await this.tokenRefresher.current();
-      await this.hub.sessionEnd(token, this.sid);
-    } catch (e) {
-      process.stderr.write(`terminal session end post failed: ${String(e)}
-`);
-    }
-  }
-  enqueue(turn) {
-    if (this.replayCutoffId !== null) {
-      if (turn.id === this.replayCutoffId) this.replayCutoffId = null;
-      return;
+      const parsed = JSON.parse(await readFile(path, "utf8"));
+      if (typeof parsed === "object" && parsed !== null)
+        Object.assign(merged, parsed);
+    } catch {
     }
-    const t = turnToTranscript(turn);
-    if (!t.text.trim()) return;
-    if (t.role === "user" && this.echoGuard?.consume(t.text)) return;
-    const sessionId = this.sid;
-    if (sessionId === null) return;
-    if (t.role === "user") this.onUserTurn?.(t.text);
-    this.chain = this.chain.then(async () => {
-      let token;
-      try {
-        token = await this.tokenRefresher.current();
-      } catch (e) {
-        process.stderr.write(`terminal session token refresh failed: ${String(e)}
-`);
-        return;
-      }
-      return this.hub.turnAppend(token, sessionId, t).then(() => {
-      }).catch((e) => {
-        process.stderr.write(`terminal session turn post failed: ${String(e)}
-`);
-      });
-    });
   }
-};
-
-// src/session.ts
-import { spawn } from "child_process";
-import { rmSync as rmSync2 } from "fs";
-import { join as join3 } from "path";
-import { tmpdir as tmpdir2 } from "os";
-import { StringDecoder } from "string_decoder";
+  return merged;
+}
+function settingsMerge(settings, command) {
+  const hooks = isRecord(settings.hooks) ? { ...settings.hooks } : {};
+  const sessionStart = Array.isArray(hooks.SessionStart) ? [...hooks.SessionStart] : [];
+  sessionStart.push({ hooks: [{ type: "command", command }] });
+  return { ...settings, hooks: { ...hooks, SessionStart: sessionStart } };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
-// src/transcript/tailer.ts
-import { open, readFile, stat } from "fs/promises";
-var POLL_MS = 400;
-var TranscriptTailer = class {
-  constructor(adapter, cwd, sinceMs, processId, onTurn, onLocate = null) {
-    this.adapter = adapter;
-    this.cwd = cwd;
-    this.sinceMs = sinceMs;
-    this.processId = processId;
-    this.onTurn = onTurn;
-    this.onLocate = onLocate;
+// src/codex.ts
+import { open, readdir as readdir2, stat as stat2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, join as join3 } from "path";
+var SESSION_ID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ROLLOUT_RE = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
+var SESSION_META_BYTES = 1024 * 1024;
+var CodexAgent = class {
+  kind = "codex";
+  isAmbiguityReported = false;
+  // Ownership comes from the rollout's own session_meta, not from the process
+  // tree: the npm `codex` is a Node shim that spawns a native binary, and only
+  // the child holds the rollout open, so inspecting the pane PID found nothing.
+  // A rollout written since launch, in our cwd, with source "cli" is ours.
+  //
+  // Two codex sessions in one workspace produce two eligible rollouts, and
+  // nothing in either file says which pane wrote it. Taking the newest would
+  // sometimes stream a colleague's session into this chat, so ambiguity gives
+  // up instead: capturing nothing is recoverable, capturing the wrong session
+  // is not.
+  async transcriptLocate(cwd, sinceMs) {
+    const key = await lockKey(sinceMs);
+    if (key !== null) return rolloutFind(key);
+    const candidates = await rolloutList(cwd, sinceMs, 2);
+    if (candidates.length > 1) {
+      if (!this.isAmbiguityReported) {
+        this.isAmbiguityReported = true;
+        process.stderr.write(
+          "[directed] more than one codex session is running in this workspace; directed cannot tell which transcript is this one, so it is not capturing the conversation.\n"
+        );
+      }
+      return null;
+    }
+    return candidates[0] ?? null;
   }
-  adapter;
-  cwd;
-  sinceMs;
-  processId;
-  onTurn;
-  onLocate;
-  timer = null;
-  file = null;
-  offset = 0;
-  partial = "";
-  ticking = false;
-  start() {
-    if (this.timer) return;
-    void this.tick();
-    this.timer = setInterval(() => void this.tick(), POLL_MS);
+  // Codex has a hook surface, but it will not run a hook it does not trust, and
+  // the only blanket override also un-trusts every other hook on the machine.
+  // Until directed has an install flow the user approves once, ownership here
+  // stays with locate().
+  async hookArgs() {
+    return null;
   }
-  stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
+  transcriptKey(path) {
+    const match = ROLLOUT_RE.exec(basename2(path));
+    return match ? match[1] : null;
   }
-  async tick() {
-    if (this.ticking) return;
-    this.ticking = true;
+  // Codex names a subagent's own thread the moment it starts one, so the
+  // parent's transcript is the only thing consulted. Two builds say it two ways:
+  // as an event of its own, or as a spawn item naming every thread that one call
+  // started. Both give exact ids, so nothing here scans or guesses. A thread the
+  // caller already knows is ignored, which is what makes repeats harmless.
+  transcriptChildren(line) {
+    let record;
     try {
-      if (this.file === null) {
-        await this.locate();
-      } else {
-        await this.tail();
-      }
-    } finally {
-      this.ticking = false;
+      record = JSON.parse(line);
+    } catch {
+      return [];
     }
-  }
-  async locate() {
-    const found = await this.adapter.locate(this.cwd, this.sinceMs, this.processId);
-    if (!found) return;
-    this.file = found;
-    this.onLocate?.(found);
-    await this.readAll(found);
-  }
-  async readAll(file) {
-    const buf = await readFile(file);
-    this.offset = buf.length;
-    this.consume(buf.toString("utf8"));
-  }
-  async tail() {
-    const file = this.file;
-    if (!file) return;
-    const { size } = await stat(file);
-    if (size <= this.offset) return;
-    const length = size - this.offset;
-    const handle = await open(file, "r");
-    try {
-      const buf = Buffer.alloc(length);
-      await handle.read(buf, 0, length, this.offset);
-      this.offset = size;
-      this.consume(buf.toString("utf8"));
-    } finally {
-      await handle.close();
+    if (!isRecord2(record)) return [];
+    const payload = record.payload;
+    if (!isRecord2(payload)) return [];
+    if (payload.type === "sub_agent_activity") {
+      const key = payload.agent_thread_id;
+      if (typeof key !== "string" || !SESSION_ID_RE2.test(key)) return [];
+      return [
+        {
+          key,
+          callKey: typeof payload.event_id === "string" ? payload.event_id : ""
+        }
+      ];
     }
+    if (payload.type === "item_completed") return spawned(payload.item);
+    return [];
   }
-  consume(text) {
-    const combined = this.partial + text;
-    const lines = combined.split("\n");
-    this.partial = lines.pop() ?? "";
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      let record;
-      try {
-        record = JSON.parse(trimmed);
-      } catch {
-        continue;
-      }
-      const turn = this.adapter.parse(record);
-      if (turn) this.onTurn(turn);
+  // A rollout's filename ends in its own thread id, so the child is found by
+  // matching that exactly. Filenames only: opening candidates to see whose they
+  // are is how a colleague's session ends up in this chat, and a near match is
+  // not this agent's file.
+  async transcriptChildLocate(_rootPath, child) {
+    return rolloutFind(child.key);
+  }
+  transcriptPath(key) {
+    return rolloutFind(key);
+  }
+  // `codex resume` reopens an existing rollout, whose filename keeps the
+  // original session uuid: the flag's own argument names it, and --last means
+  // the newest primary rollout in scope. A bare `codex resume` opens the
+  // interactive picker -- the target is unknowable, so it reads as a fresh session.
+  async resumeKey(command, cwd) {
+    const args = command.slice(1);
+    const subcommand = args.find((a) => !a.startsWith("-"));
+    if (subcommand !== "resume") return null;
+    const rest = args.slice(args.indexOf("resume") + 1);
+    const id = rest.find((a) => SESSION_ID_RE2.test(a));
+    if (id) return id;
+    if (rest.includes("--last")) {
+      const newest = await rolloutNewest(rest.includes("--all") ? null : cwd);
+      return newest ? this.transcriptKey(newest) : null;
     }
+    return null;
   }
 };
-
-// src/session.ts
-var BANNER = `
-                   \u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591
-                 \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591
-                \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591
-               \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
-               \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
-              \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
-              \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
-            \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591
- \u2591\u2591       \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
-\u2591\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591
-\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591
- \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
-  \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2591
-   \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2591
-     \u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591
-     \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
-    \u2591\u2588\u2588\u2588\u2591\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2591\u2591\u2591\u2591\u2588\u2588\u2591
-   \u2591\u2588\u2588\u2591\u2591 \u2591\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2588\u2588\u2588\u2591 \u2591\u2588\u2588\u2591  \u2591\u2588\u2588\u2591
-  \u2591\u2588\u2588\u2588\u2591  \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591 \u2591\u2588\u2588\u2591  \u2591\u2588\u2588\u2591  \u2591\u2588\u2588\u2591
-   \u2591\u2588\u2588\u2591   \u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2591  \u2591\u2588\u2588\u2591\u2591 \u2591\u2591  \u2591\u2591\u2588\u2588\u2591
-    \u2591\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2591  \u2591\u2591\u2591\u2591\u2591    \u2591\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2591
-     \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591             \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591
-       \u2591\u2591\u2591\u2591\u2591\u2591\u2591                 \u2591\u2591\u2591\u2591\u2591\u2591
-
-  Directed helps you collaborate with AI.
-`;
-var SPLASH_MS = 3e3;
-function bannerWrap(command, cols, rows) {
-  const lines = BANNER.replace(/^\n+|\n+$/g, "").split("\n");
-  const width = Math.max(...lines.map((l) => l.length));
-  const left = " ".repeat(Math.max(0, Math.floor((cols - width) / 2)));
-  const top = "\n".repeat(Math.max(0, Math.floor((rows - lines.length) / 2)));
-  const centered = top + lines.map((l) => l.length > 0 ? left + l : l).join("\n");
-  return ["sh", "-c", `clear; printf '%s
-' '${centered}'; sleep ${SPLASH_MS / 1e3}; exec "$@"`, "sh", ...command];
-}
-var Session = class {
-  constructor(config, conversation, recorder, tmux, adapter, remote = null, echoGuard = null, onTranscriptLocate = null) {
-    this.config = config;
-    this.conversation = conversation;
-    this.recorder = recorder;
-    this.tmux = tmux;
-    this.adapter = adapter;
-    this.remote = remote;
-    this.echoGuard = echoGuard;
-    this.onTranscriptLocate = onTranscriptLocate;
-  }
-  config;
-  conversation;
-  recorder;
-  tmux;
-  adapter;
-  remote;
-  echoGuard;
-  onTranscriptLocate;
-  async run() {
-    const sinceMs = Date.now();
-    const cols = process.stdout.columns || 80;
-    const rows = process.stdout.rows || 24;
-    await this.tmux.newSession(bannerWrap(this.config.command, cols, rows), cols, rows);
-    const fifo = join3(tmpdir2(), `directed-${process.pid}.fifo`);
-    rmSync2(fifo, { force: true });
-    await exited(spawn("mkfifo", [fifo]));
-    const reader = spawn("cat", [fifo]);
-    const decoder = new StringDecoder("utf8");
-    reader.stdout.on("data", (d) => {
-      this.recorder.output(decoder.write(d));
-    });
-    await this.tmux.pipePane(fifo);
-    let tailer = null;
-    if (this.adapter) {
-      const processId = await this.tmux.panePid();
-      tailer = new TranscriptTailer(
-        this.adapter,
-        process.cwd(),
-        sinceMs,
-        processId,
-        (t) => this.conversation.add(t),
-        this.onTranscriptLocate
-      );
-    }
-    tailer?.start();
-    this.remote?.start((m) => {
-      this.echoGuard?.record(m.text);
-      void this.steer(m.text, m.author).catch(() => {
-      });
-    });
-    const sizeTimer = this.startSizePolling();
-    const code = await new Promise((resolve) => {
-      this.tmux.attach().on("exit", (c) => resolve(c ?? 0));
-    });
-    await this.remote?.stop();
-    if (sizeTimer) clearInterval(sizeTimer);
-    tailer?.stop();
-    reader.kill();
-    await this.tmux.kill();
-    rmSync2(fifo, { force: true });
-    return code;
-  }
-  startSizePolling() {
-    let last = "";
-    return setInterval(async () => {
-      const { cols, rows } = await this.tmux.paneSize().catch(() => ({ cols: 0, rows: 0 }));
-      if (!cols) return;
-      const key = `${cols}x${rows}`;
-      if (key !== last) {
-        last = key;
-        this.recorder.resize(cols, rows);
-      }
-    }, 1e3);
+function spawned(item) {
+  if (!isRecord2(item)) return [];
+  if (item.type !== "CollabAgentToolCall" || item.tool !== "spawn_agent")
+    return [];
+  const receivers = item.receiver_thread_ids;
+  if (!Array.isArray(receivers)) return [];
+  const callKey = typeof item.id === "string" ? item.id : "";
+  const found = [];
+  for (const key of receivers) {
+    if (typeof key !== "string" || !SESSION_ID_RE2.test(key)) continue;
+    found.push({ key, callKey });
+  }
+  return found;
+}
+async function lockKey(sinceMs) {
+  const dir = join3(homedir2(), ".codex", "thread-writer-locks");
+  let entries;
+  try {
+    entries = await readdir2(dir);
+  } catch {
+    return null;
   }
-  async steer(text, who) {
-    await this.tmux.sendText(text, this.config.acceptMode === "send");
-    this.recorder.marker(`${who}: ${text}`);
+  const found = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".lock")) continue;
+    const key = entry.slice(0, -".lock".length);
+    if (!SESSION_ID_RE2.test(key)) continue;
+    if (!await isWrittenSince(join3(dir, entry), sinceMs)) continue;
+    found.push(key);
   }
-};
-function exited(child) {
-  return new Promise((resolve, reject) => {
-    child.on("error", reject);
-    child.on("exit", (c) => c === 0 ? resolve() : reject(new Error(`exit ${c}`)));
+  return found.length === 1 ? found[0] : null;
+}
+async function rolloutFind(key) {
+  const dir = join3(homedir2(), ".codex", "sessions");
+  const suffix = `-${key}.jsonl`;
+  let entries;
+  try {
+    entries = await readdir2(dir, { recursive: true });
+  } catch {
+    return null;
+  }
+  const found = entries.find((entry) => {
+    const name = basename2(entry);
+    return name.startsWith("rollout-") && name.endsWith(suffix);
   });
+  return found === void 0 ? null : join3(dir, found);
 }
-
-// src/tmux.ts
-import { spawn as spawn2 } from "child_process";
-function defaultRunner(bin) {
-  return (args) => new Promise((resolve, reject) => {
-    const p = spawn2(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
-    let out = "", err = "";
-    p.stdout.on("data", (d) => out += d);
-    p.stderr.on("data", (d) => err += d);
-    p.on("error", reject);
-    p.on("exit", (code) => code === 0 ? resolve(out) : reject(new Error(`tmux ${args.join(" ")} failed: ${err.trim()}`)));
+async function rolloutNewest(cwd, sinceMs = 0) {
+  const found = await rolloutList(cwd, sinceMs, 1);
+  return found[0] ?? null;
+}
+async function rolloutList(cwd, sinceMs, limit) {
+  const dir = join3(homedir2(), ".codex", "sessions");
+  let entries;
+  try {
+    entries = await readdir2(dir, { recursive: true });
+  } catch {
+    return [];
+  }
+  const rollouts = entries.filter((f) => {
+    const b = basename2(f);
+    return b.startsWith("rollout-") && b.endsWith(".jsonl");
   });
+  rollouts.sort();
+  rollouts.reverse();
+  const found = [];
+  for (const rollout of rollouts) {
+    const path = join3(dir, rollout);
+    if (sinceMs > 0 && !await isWrittenSince(path, sinceMs)) continue;
+    if (!await isPrimaryRollout(path, cwd)) continue;
+    found.push(path);
+    if (found.length >= limit) break;
+  }
+  return found;
 }
-var Tmux = class {
-  constructor(bin, session, runner) {
-    this.bin = bin;
-    this.session = session;
-    this.runner = runner ?? defaultRunner(bin);
+async function isWrittenSince(path, sinceMs) {
+  try {
+    return (await stat2(path)).mtimeMs >= sinceMs;
+  } catch {
+    return false;
   }
-  bin;
-  session;
-  runner;
-  inputBufferNumber = 0;
-  // Web and hub steers arrive independently; keep each paste and its submit
-  // key together so simultaneous messages cannot interleave in the pane.
-  inputWrite = Promise.resolve();
-  // Detached sessions default to 80x24 until a client attaches; sizing the
-  // pane up front means everything the child draws before attach (a resumed
-  // agent repaints its whole conversation immediately) wraps at the real
-  // terminal width, matching the recording header.
-  async newSession(command, cols, rows) {
-    await this.runner([
-      "new-session",
-      "-d",
-      "-s",
-      this.session,
-      "-x",
-      String(cols),
-      "-y",
-      String(rows),
-      "--",
-      ...command
-    ]);
-    await this.runner(["set-option", "-t", this.session, "status", "off"]);
+}
+async function isPrimaryRollout(path, cwd = null) {
+  const line = await firstLine(path);
+  if (line === null) return false;
+  let record;
+  try {
+    record = JSON.parse(line);
+  } catch {
+    return false;
   }
-  async paneSize() {
-    const out = (await this.runner(["display-message", "-p", "-t", this.session, "#{pane_width}x#{pane_height}"])).trim();
-    const [cols, rows] = out.split("x").map(Number);
-    return { cols, rows };
+  if (!isRecord2(record) || record.type !== "session_meta" || !isRecord2(record.payload))
+    return false;
+  const pathMatch = ROLLOUT_RE.exec(basename2(path));
+  if (record.payload.source !== "cli" || record.payload.id !== pathMatch?.[1])
+    return false;
+  return cwd === null || record.payload.cwd === cwd;
+}
+async function firstLine(path) {
+  let handle;
+  try {
+    handle = await open(path, "r");
+    const buffer = Buffer.alloc(SESSION_META_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const lineEnd = buffer.indexOf("\n", 0);
+    if (bytesRead === 0 || lineEnd === -1 || lineEnd >= bytesRead) return null;
+    return buffer.subarray(0, lineEnd).toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    await handle?.close();
   }
-  async panePid() {
-    const out = await this.runner(["display-message", "-p", "-t", this.session, "#{pane_pid}"]);
-    const processId = Number(out.trim());
-    if (!Number.isSafeInteger(processId) || processId <= 0) {
-      throw new Error(`tmux returned an invalid pane PID: ${out.trim()}`);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/agent.ts
+function agentResolve(command) {
+  const program = command[0];
+  if (program === void 0) return null;
+  const name = basename3(program);
+  if (name === "claude") return new ClaudeAgent();
+  if (name === "codex") return new CodexAgent();
+  return null;
+}
+
+// src/options.ts
+function helpText() {
+  return `directed - run an interactive coding agent in a Directed chat
+
+Usage:
+  directed [options] <command> [args...]
+  directed login
+  directed logout
+  directed whoami
+  directed upgrade
+
+Options:
+  --steer-mode <send|stage> Submit chat steers immediately or stage them
+  --chat                     Stream the session to a Directed chat
+  --no-chat                  Do not stream the session to a Directed chat
+  --into[=<URL or public id>] Choose a recent chat or give an exact target
+  --with <people>            Add @usernames or emails to the session chat
+  --invite <emails>          Open an email draft with the chat join link
+  --open                     Open the session chat in a browser
+  --no-open                  Do not open the session chat in a browser
+  --name <label>             Title the session chat
+  --tmux-bin <path>          Use a specific tmux executable
+  -h, --help                 Show this help
+
+Everything after <command> is passed to that command unchanged.
+
+Examples:
+  directed codex
+  directed --with @jane claude
+  directed codex --help`;
+}
+function isHelpRequest(argv) {
+  return argv[0] === "--help" || argv[0] === "-h";
+}
+function optionsParse(argv) {
+  let steerMode = "send";
+  let title = "";
+  let tmuxBin = "tmux";
+  let chatOpen = true;
+  let chatMembers = [];
+  let chatInviteEmails = [];
+  let chatTarget = { kind: "new" };
+  let chatFlag;
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === "--steer-mode") {
+      steerMode = steerModeParse(argv[i + 1]);
+      i += 2;
+    } else if (a === "--name") {
+      title = argv[i + 1] ?? "";
+      i += 2;
+    } else if (a === "--tmux-bin") {
+      tmuxBin = argv[i + 1] ?? tmuxBin;
+      i += 2;
+    } else if (a === "--chat") {
+      chatFlag = true;
+      i += 1;
+    } else if (a === "--no-chat") {
+      chatFlag = false;
+      i += 1;
+    } else if (a === "--into") {
+      chatTarget = { kind: "pick" };
+      i += 1;
+    } else if (a.startsWith("--into=")) {
+      chatTarget = { kind: "exact", query: a.slice("--into=".length) };
+      i += 1;
+    } else if (a === "--open") {
+      chatOpen = true;
+      i += 1;
+    } else if (a === "--no-open") {
+      chatOpen = false;
+      i += 1;
+    } else if (a === "--with") {
+      chatMembers = commaList(argv[i + 1]);
+      i += 2;
+    } else if (a === "--invite") {
+      chatInviteEmails = commaList(argv[i + 1]);
+      for (const email of chatInviteEmails) {
+        if (!email.includes("@") || email.startsWith("@")) {
+          throw new Error(`--invite takes emails only, got '${email}' (use --with for @usernames)`);
+        }
+      }
+      i += 2;
+    } else if (a.startsWith("-")) {
+      throw new Error(`unknown directed option '${a}'; run 'directed --help'`);
+    } else {
+      break;
     }
-    return processId;
   }
-  pipePane(fifo) {
-    return this.runner(["pipe-pane", "-o", "-t", this.session, `cat >> ${fifo}`]).then(() => {
+  const command = argv.slice(i);
+  if (command.length === 0) throw new Error("usage: directed [flags] <command> [args...]");
+  return {
+    command,
+    steerMode,
+    title,
+    tmuxBin,
+    chatEnabled: chatFlag ?? agentResolve(command) !== null,
+    chatTarget,
+    chatOpen,
+    chatMembers,
+    chatInviteEmails
+  };
+}
+function steerModeParse(value) {
+  if (value !== "send" && value !== "stage") {
+    throw new Error(`--steer-mode must be 'send' or 'stage', got '${value}'`);
+  }
+  return value;
+}
+function commaList(value) {
+  return (value ?? "").split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+
+// src/hub.ts
+import { gzip } from "zlib";
+import { promisify } from "util";
+var gzipAsync = promisify(gzip);
+if (false)
+  throw new Error("$HUB_URL is required, e.g. HUB_URL=https://hub.directed.ai");
+var HUB_URL = "https://hub.directed.ai";
+var TIMEOUT_MS = 15e3;
+var UPLOAD_TIMEOUT_MS = 6e4;
+var HubError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "HubError";
+  }
+  status;
+  // A 4xx will fail the same way forever, so the caller should stop retrying and
+  // move on. 401 is handled by a refresh before it ever reaches here; 408 and
+  // 429 are the timing exceptions and stay retryable.
+  get isPermanent() {
+    return this.status >= 400 && this.status < 500 && this.status !== 408 && this.status !== 429;
+  }
+};
+var TerminalHeldError = class extends HubError {
+  constructor(chatUrl) {
+    super("this conversation is already connected", 409);
+    this.chatUrl = chatUrl;
+    this.name = "TerminalHeldError";
+  }
+  chatUrl;
+};
+var Hub = class {
+  constructor(url = HUB_URL, fetchImpl = fetch) {
+    this.url = url;
+    this.fetchImpl = fetchImpl;
+  }
+  url;
+  fetchImpl;
+  auth = null;
+  // Once a session is signed in, every authenticated call gets its token from
+  // here -- and a 401 refreshes and retries once instead of being reported as a
+  // permanent rejection that silently drops the record.
+  authAttach(auth) {
+    this.auth = auth;
+  }
+  socketUrl(path) {
+    return `${this.url.replace(/^http/, "ws")}${path}`;
+  }
+  authUrl(redirectUri, challenge) {
+    const params = new URLSearchParams({
+      redirect_uri: redirectUri,
+      code_challenge: challenge,
+      code_challenge_method: "S256"
     });
+    return `${this.url}/users/social/auth/mobile/start/?${params.toString()}`;
   }
-  async capturePane() {
-    return Buffer.from(await this.runner(["capture-pane", "-p", "-e", "-t", this.session]), "utf8");
+  async authExchange(code, verifier) {
+    const body = await this.json("/api/auth/mobile/exchange/", {
+      method: "POST",
+      json: { code, code_verifier: verifier },
+      token: null
+    });
+    return tokenPairFrom(body);
   }
-  sendText(text, submit) {
-    const write = this.inputWrite.then(() => this.textWrite(text, submit));
-    this.inputWrite = write.catch(() => {
+  async authRefresh(refreshToken) {
+    const body = await this.json("/api/auth/mobile/refresh/", {
+      method: "POST",
+      json: { refresh_token: refreshToken },
+      token: null
     });
-    return write;
+    return tokenPairFrom(body);
   }
-  async textWrite(text, submit) {
-    const buffer = `${this.session}-input-${this.inputBufferNumber}`;
-    this.inputBufferNumber += 1;
-    await this.runner(["set-buffer", "-b", buffer, "--", text]);
-    await this.runner(["paste-buffer", "-dpr", "-b", buffer, "-t", this.session]);
-    if (submit) await this.runner(["send-keys", "-t", this.session, "Enter"]);
+  async identityFind(token) {
+    const body = await this.json("/api/auth/me/", { token });
+    return {
+      publicId: body.public_id,
+      email: body.email,
+      username: body.username,
+      fullName: body.full_name
+    };
   }
-  async hasSession() {
-    return this.runner(["has-session", "-t", this.session]).then(() => true).catch(() => false);
+  async chatList(query) {
+    const body = await this.json("/api/chats/lookup/", { query: { q: query, limit: "10" } });
+    return body.items.map((item) => ({
+      publicId: item.public_id,
+      title: item.display_title,
+      url: item.chat_url
+    }));
   }
-  attach() {
-    return spawn2(this.bin, ["attach", "-t", this.session], { stdio: "inherit" });
+  // Mint (or reuse) the chat's shareable join link. Redeeming it seats the
+  // visitor as a chat member, so it works for people outside the host's
+  // connections -- the email-invite path.
+  async chatLinkCreate(chatPublicId2) {
+    const body = await this.json(
+      `/api/chats/${chatPublicId2}/link/`,
+      {
+        method: "POST",
+        json: {}
+      }
+    );
+    return body.url;
   }
-  kill() {
-    return this.runner(["kill-session", "-t", this.session]).then(() => {
-    }).catch(() => {
+  async terminalCreate(input2) {
+    const response = await this.request("/api/terminal-sessions/", {
+      method: "POST",
+      expect: [409],
+      json: {
+        source: input2.source,
+        title: input2.title ?? "",
+        resume_key: input2.resumeKey ?? "",
+        destination_chat_public_id: input2.chatPublicId ?? "",
+        member_identifiers: input2.memberList ?? [],
+        git_start: gitSnapshotWire(input2.gitStart)
+      }
+    });
+    if (response.status === 409) {
+      const held = await response.json();
+      throw new TerminalHeldError(held.chat_url);
+    }
+    const body = await response.json();
+    return {
+      chatPublicId: body.chat_public_id,
+      terminalSessionPublicId: body.terminal_session_public_id,
+      chatUrl: body.chat_url,
+      agentActorPublicId: body.agent_actor_public_id,
+      reattached: body.reattached === true,
+      skippedMemberList: body.skipped_member_identifiers ?? [],
+      resumeSeq: body.resume_seq ?? 0
+    };
+  }
+  async terminalEnd(sessionId, state) {
+    await this.request(`/api/terminal-sessions/${sessionId}/end/`, {
+      method: "POST",
+      json: {
+        transcript_lost: state.transcriptLost,
+        recording_lost: state.recordingLost,
+        detached: state.isDetached,
+        git_end: gitSnapshotWire(state.gitEnd)
+      }
+    });
+  }
+  // Reports that this CLI is still attached, and hears whether ownership ended.
+  // Control health proves itself independently over the control socket.
+  async terminalHeartbeat(sessionId) {
+    const response = await this.request(
+      `/api/terminal-sessions/${sessionId}/heartbeat/`,
+      { method: "POST", expect: [409], json: {} }
+    );
+    return { isEnded: response.status === 409 };
+  }
+  // A contiguous slice of one agent's transcript file, sent as the file's own
+  // lines. Compressed: transcripts are JSON text and shrink about 5x, and this
+  // runs alongside the recording on the same uplink. A subagent's slice names
+  // the file that launched it, so lineage arrives with the data it describes.
+  async transcriptAppend(sessionId, batch) {
+    await this.request(`/api/terminal-sessions/${sessionId}/transcript/`, {
+      method: "POST",
+      query: {
+        file_key: batch.fileKey,
+        parent_key: batch.parentKey,
+        call_key: batch.callKey,
+        start_seq: String(batch.startSeq),
+        start_offset: String(batch.startOffset)
+      },
+      raw: {
+        body: await gzipAsync(Buffer.from(batch.body, "utf8")),
+        contentType: "application/x-ndjson"
+      },
+      timeoutMs: UPLOAD_TIMEOUT_MS
+    });
+  }
+  async recordingAppend(sessionId, chunk) {
+    await this.request(`/api/terminal-sessions/${sessionId}/recording/`, {
+      method: "POST",
+      json: {
+        seq: chunk.seq,
+        offset: chunk.offset,
+        events: chunk.events,
+        width: chunk.width,
+        height: chunk.height,
+        started_epoch: chunk.startedEpoch
+      }
+    });
+  }
+  // What the pane did with a steer, so the chat can show delivery rather than
+  // leaving the sender to guess.
+  async steerAck(sessionId, eventId, outcome) {
+    await this.request(
+      `/api/terminal-sessions/${sessionId}/steers/${eventId}/ack/`,
+      {
+        method: "POST",
+        json: { outcome }
+      }
+    );
+  }
+  async json(path, spec = {}) {
+    const response = await this.request(path, spec);
+    return await response.json();
+  }
+  // One timeout, one auth policy, one error shape. `token: null` means the call
+  // is unauthenticated; a string is an explicit token for the login path; absent
+  // means the attached session's token, refreshed once if the hub says it is bad.
+  async request(path, spec) {
+    const response = await this.send(path, spec, await this.tokenFor(spec));
+    if (response.status !== 401 || spec.token !== void 0 || this.auth === null) {
+      return this.checked(path, response, spec.expect);
+    }
+    return this.checked(
+      path,
+      await this.send(path, spec, await this.auth.refresh()),
+      spec.expect
+    );
+  }
+  async tokenFor(spec) {
+    if (spec.token !== void 0) return spec.token;
+    if (this.auth === null)
+      throw new Error("hub call needs a signed-in session");
+    return this.auth.token();
+  }
+  async send(path, spec, token) {
+    const query = spec.query ? `?${new URLSearchParams(spec.query).toString()}` : "";
+    const headers = {};
+    if (token) headers.Authorization = `Bearer ${token}`;
+    let body;
+    if (spec.raw) {
+      headers["Content-Type"] = spec.raw.contentType;
+      headers["Content-Encoding"] = "gzip";
+      body = spec.raw.body;
+    } else if (spec.json !== void 0) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(spec.json);
+    }
+    return this.fetchImpl(`${this.url}${path}${query}`, {
+      method: spec.method ?? "GET",
+      headers,
+      body,
+      signal: AbortSignal.timeout(spec.timeoutMs ?? TIMEOUT_MS)
+    });
+  }
+  async checked(path, response, expect) {
+    if (response.ok || expect?.includes(response.status)) return response;
+    let detail = "";
+    try {
+      const body = await response.clone().json();
+      if (typeof body.detail === "string") detail = ` (${body.detail})`;
+    } catch {
+      detail = "";
+    }
+    throw new HubError(
+      `${path} failed: ${response.status}${detail}`,
+      response.status
+    );
+  }
+};
+function gitSnapshotWire(snapshot) {
+  if (!snapshot) return null;
+  return {
+    sha: snapshot.sha,
+    branch: snapshot.branch,
+    root: snapshot.root,
+    dirty_paths: snapshot.dirtyPaths
+  };
+}
+function tokenPairFrom(body) {
+  return {
+    access: body.access_token,
+    refresh: body.refresh_token,
+    expiresAt: Date.now() + body.expires_in * 1e3
+  };
+}
+
+// src/auth.ts
+import { createHash, randomBytes as randomBytes2 } from "crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync as rmSync2, writeFileSync } from "fs";
+import http from "http";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join4 } from "path";
+var EXPIRY_SKEW_MS = 6e4;
+var LOGIN_TIMEOUT_MS = 3e5;
+function authPath(hubUrl) {
+  const home = process.env.DIRECTED_HOME ?? homedir3();
+  const url = new URL(hubUrl);
+  const key = url.port ? `${url.hostname}-${url.port}` : url.hostname;
+  return join4(home, ".directed", "auth", `${key}.json`);
+}
+function authLoad(hubUrl) {
+  try {
+    const stored = JSON.parse(readFileSync(authPath(hubUrl), "utf8"));
+    if (stored.hubUrl !== hubUrl) return null;
+    return stored;
+  } catch {
+    return null;
+  }
+}
+function authSave(state) {
+  const path = authPath(state.hubUrl);
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(state, null, 2), { mode: 384 });
+}
+function authClear(hubUrl) {
+  const path = authPath(hubUrl);
+  if (existsSync(path)) rmSync2(path);
+}
+var AuthSession = class {
+  constructor(hub, state) {
+    this.hub = hub;
+    this.state = state;
+  }
+  hub;
+  state;
+  refreshing = null;
+  get identity() {
+    return this.state.identity;
+  }
+  async token() {
+    if (this.state.expiresAt - EXPIRY_SKEW_MS > Date.now()) return this.state.access;
+    return this.refresh();
+  }
+  // Refreshes whatever the local clock believes, deduped against a concurrent
+  // call. For when the server has already said the token is bad -- a 401, or a
+  // socket close code 4002.
+  async refresh() {
+    if (!this.refreshing) this.refreshing = this.refreshOnce();
+    try {
+      return await this.refreshing;
+    } finally {
+      this.refreshing = null;
+    }
+  }
+  async refreshOnce() {
+    const pair = await this.hub.authRefresh(this.state.refresh);
+    this.state = {
+      ...this.state,
+      access: pair.access,
+      refresh: pair.refresh,
+      expiresAt: pair.expiresAt
+    };
+    authSave(this.state);
+    return this.state.access;
+  }
+};
+function authLogin(hub, open3) {
+  const { verifier, challenge } = pkce();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const server = http.createServer((req, res) => {
+      const code = codeFromRequestUrl(req.url);
+      if (!code) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Missing code");
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(SUCCESS_BODY);
+      onCode(code);
+    });
+    const timer = setTimeout(() => {
+      settle(() => reject(new Error("Login timed out after 300s")));
+    }, LOGIN_TIMEOUT_MS);
+    function settle(run) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      server.close();
+      run();
+    }
+    async function onCode(code) {
+      try {
+        const tok = await hub.authExchange(code, verifier);
+        const identity = await hub.identityFind(tok.access);
+        const stored = {
+          access: tok.access,
+          refresh: tok.refresh,
+          expiresAt: tok.expiresAt,
+          identity,
+          hubUrl: hub.url
+        };
+        authSave(stored);
+        settle(() => resolve(stored));
+      } catch (err) {
+        settle(() => reject(err instanceof Error ? err : new Error(String(err))));
+      }
+    }
+    server.on("error", (err) => {
+      settle(() => reject(err));
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        settle(() => reject(new Error("Failed to determine loopback server port")));
+        return;
+      }
+      const redirectUri = `http://127.0.0.1:${address.port}/cb`;
+      open3(hub.authUrl(redirectUri, challenge));
+    });
+  });
+}
+function pkce() {
+  const verifier = randomBytes2(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+function codeFromRequestUrl(url) {
+  const parsed = new URL(url ?? "/", "http://127.0.0.1");
+  return parsed.searchParams.get("code");
+}
+var SUCCESS_BODY = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="color-scheme" content="light dark" />
+    <title>Signed in - Directed AI</title>
+    <style>
+      :root {
+        color-scheme: light dark;
+      }
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-family: system-ui, sans-serif;
+        -webkit-font-smoothing: antialiased;
+        -moz-osx-font-smoothing: grayscale;
+        background: #fff;
+        color: #1a1a1a;
+      }
+      main {
+        text-align: center;
+        padding: 0 24px;
+      }
+      img {
+        display: block;
+        margin: 0 auto 12px;
+      }
+      h1 {
+        font-size: 24px;
+        font-weight: 600;
+        letter-spacing: -0.02em;
+        margin: 0 0 8px;
+      }
+      p {
+        margin: 0;
+        color: #6b6b6b;
+      }
+      @media (prefers-color-scheme: dark) {
+        body {
+          background: #1a1a1a;
+          color: #f5f5f5;
+        }
+        p {
+          color: #a0a0a0;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <img
+        src="https://res.cloudinary.com/dnriuttuy/image/upload/v1761205887/dino-black-with-white-outline_nk3vhs.svg"
+        alt="Dino"
+        width="40"
+        height="40"
+      />
+      <h1>You are signed in</h1>
+      <p>You can close this tab and return to your terminal.</p>
+    </main>
+  </body>
+</html>`;
+
+// src/chat.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+var TERMINAL = { input, output };
+function chatChoice(answer, count) {
+  const value = Number(answer.trim());
+  if (!Number.isInteger(value) || value < 1 || value > count) return null;
+  return value;
+}
+function chatPublicId(value) {
+  const trimmed = value.trim();
+  try {
+    const url = new URL(trimmed);
+    const match = url.pathname.match(/\/chat\/([^/]+)\/?$/);
+    return match ? decodeURIComponent(match[1]) : trimmed;
+  } catch {
+    return trimmed;
+  }
+}
+function chatMenu(chatList) {
+  const lines = ["", "Recent Directed chats:"];
+  for (const [index, chat] of chatList.entries()) {
+    lines.push(`${index + 1}. ${chat.title}`);
+    lines.push(`   ${chat.url}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function chatPick(hub, target, terminal = TERMINAL) {
+  if (target.kind === "new") return null;
+  if (target.kind === "exact") {
+    const wanted = chatPublicId(target.query);
+    const chatList2 = await hub.chatList(target.query.trim());
+    if (chatList2.some((chat) => chat.publicId === wanted)) return wanted;
+    throw new Error("--into=<value> must resolve to an exact Directed chat URL or public id");
+  }
+  if (!terminal.input.isTTY || !terminal.output.isTTY) {
+    throw new Error("--into needs an interactive terminal; use --into=<Directed chat URL or exact public id>");
+  }
+  const chatList = await hub.chatList("");
+  if (chatList.length === 0) {
+    throw new Error("No recent chats available; run without --into to start a new chat");
+  }
+  const prompt = createInterface({ input: terminal.input, output: terminal.output });
+  try {
+    terminal.output.write(chatMenu(chatList));
+    const answer = await prompt.question(`Choose a chat [1-${chatList.length}]: `);
+    const choice = chatChoice(answer, chatList.length);
+    if (choice === null) throw new Error("Choose a listed chat number");
+    return chatList[choice - 1].publicId;
+  } finally {
+    prompt.close();
+  }
+}
+function inviteMailto(emails, joinUrl, hostName) {
+  const subject = `${hostName} invited you to a live Directed session`;
+  const body = [
+    "Hi,",
+    "",
+    "I'm running a live coding session and want you in the chat -- follow along and jump in here:",
+    "",
+    joinUrl,
+    "",
+    "See you there,",
+    hostName
+  ].join("\n");
+  return `mailto:${emails.join(",")}?subject=${encodeURIComponent(subject)}&body=${encodeURIComponent(body)}`;
+}
+async function chatInvite(linkCreate, emails, hostName, note) {
+  try {
+    const joinUrl = await linkCreate();
+    note(`join link: ${joinUrl}`);
+    note(`opening mail draft to: ${emails.join(", ")}`);
+    return inviteMailto(emails, joinUrl, hostName);
+  } catch (e) {
+    note(`could not prepare the email invite (${e.message}); invite them from the chat instead.`);
+    return null;
+  }
+}
+
+// src/capture.ts
+import { execFile } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// src/outbox.ts
+var BACKOFF_MS = [500, 1500, 4e3, 1e4];
+var BYTES_MAX_DEFAULT = 32 * 1024 * 1024;
+var Outbox = class {
+  constructor(label, spec) {
+    this.label = label;
+    this.spec = spec;
+    this.bytesMax = spec.bytesMax ?? BYTES_MAX_DEFAULT;
+  }
+  label;
+  spec;
+  pending = [];
+  pendingBytes = 0;
+  inFlight = null;
+  lostCount = 0;
+  lastFailure = "";
+  isStopped = false;
+  worker = null;
+  wake = null;
+  bytesMax;
+  // Why the last send did not land, for the one summary printed once the
+  // terminal is the session's own again. Kept rather than narrated: a flapping
+  // hub produced 62 identical lines over the top of a live agent, and the count
+  // above is what actually matters.
+  get lastError() {
+    return this.lastFailure;
+  }
+  // What this stream produced that the hub never took, in the stream's own
+  // units. Zero means the hub has everything.
+  get unsentCount() {
+    const queued = this.pending.reduce((sum, record) => sum + this.lossOf(record), 0);
+    const flying = this.inFlight === null ? 0 : this.lossOf(this.inFlight);
+    return queued + flying + this.lostCount;
+  }
+  add(record) {
+    if (this.isStopped) return;
+    this.pending.push(record);
+    this.pendingBytes += this.spec.bytesOf(record);
+    while (this.pendingBytes > this.bytesMax && this.pending.length > 0) {
+      const dropped = this.pending.shift();
+      this.pendingBytes -= this.spec.bytesOf(dropped);
+      this.lostCount += this.lossOf(dropped);
+      this.lastFailure = "backlog full";
+    }
+    this.wake?.();
+    this.workerStart();
+  }
+  // Sends what is left, until `deadline` passes. Bounded on purpose: a hub that
+  // is down must never hold the terminal. Whatever is still queued is reported
+  // as loss, which is the session's integrity state, not a warning.
+  async flush(deadline) {
+    this.workerStart();
+    while ((this.pending.length > 0 || this.inFlight !== null) && Date.now() < deadline) {
+      await Promise.race([sleep(50), this.worker ?? Promise.resolve()]);
+    }
+    this.isStopped = true;
+    this.wake?.();
+  }
+  lossOf(record) {
+    return this.spec.lossOf ? this.spec.lossOf(record) : 1;
+  }
+  workerStart() {
+    if (this.worker) return;
+    this.worker = this.run().finally(() => {
+      this.worker = null;
     });
   }
-};
-
-// src/conversation-log.ts
-var ConversationLog = class {
-  turns = [];
-  subs = /* @__PURE__ */ new Set();
-  add(turn) {
-    this.turns.push(turn);
-    for (const s of this.subs) {
-      try {
-        s(turn);
-      } catch {
-        this.subs.delete(s);
+  // One record at a time, backing off on failure and resuming by itself. The
+  // old version returned after exhausting its retries and only woke when the
+  // next record arrived -- so an idle pane could sit on a parked retry forever.
+  async run() {
+    let attempt = 0;
+    while (!this.isStopped) {
+      const record = this.pending.shift();
+      if (record === void 0) return;
+      this.pendingBytes -= this.spec.bytesOf(record);
+      this.inFlight = record;
+      const outcome = await this.attempt(record);
+      this.inFlight = null;
+      if (outcome === "sent") {
+        attempt = 0;
+        continue;
+      }
+      if (outcome === "rejected") {
+        this.lostCount += this.lossOf(record);
+        attempt = 0;
+        continue;
       }
+      this.pending.unshift(record);
+      this.pendingBytes += this.spec.bytesOf(record);
+      await this.pause(backoffMs(attempt));
+      attempt += 1;
     }
   }
-  snapshot() {
-    return [...this.turns];
+  async attempt(record) {
+    try {
+      await this.spec.send(record);
+      return "sent";
+    } catch (e) {
+      this.lastFailure = String(e);
+      if (e instanceof HubError && e.isPermanent) return "rejected";
+      return "retry";
+    }
   }
-  subscribe(cb) {
-    this.subs.add(cb);
-    return () => this.subs.delete(cb);
+  // Sleeps, but returns early when a record arrives or the outbox stops, so a
+  // shutdown never waits out a full backoff.
+  pause(ms) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(finish, ms);
+      const self = this;
+      this.wake = finish;
+      function finish() {
+        clearTimeout(timer);
+        self.wake = null;
+        resolve();
+      }
+    });
   }
 };
+function backoffMs(attempt) {
+  return BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)];
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
-// src/recorder.ts
-var Recorder = class {
-  startMs;
+// src/recording.ts
+var FLUSH_INTERVAL_MS = 250;
+var FLUSH_BYTES_MAX = 16 * 1024;
+var BACKLOG_BYTES_MAX = 4 * 1024 * 1024;
+var Recording = class {
+  constructor(headerWidth, headerHeight) {
+    this.headerWidth = headerWidth;
+    this.headerHeight = headerHeight;
+    this.width = headerWidth;
+    this.height = headerHeight;
+  }
+  headerWidth;
+  headerHeight;
+  startMs = monotonicMs();
+  startedEpoch = Math.floor(Date.now() / 1e3);
+  buffer = [];
+  bufferBytes = 0;
+  droppedCount = 0;
+  sink = null;
+  timer = null;
+  isStopped = false;
+  // The pane's size now, for deciding whether a poll saw a change. The header
+  // size below is the asciicast's opening geometry and never moves -- every
+  // later size is an "r" event, and playback rebuilds from the two together.
   width;
   height;
-  subs = /* @__PURE__ */ new Set();
-  constructor(cols, rows) {
-    this.startMs = Date.now();
-    this.width = cols;
-    this.height = rows;
+  get header() {
+    return { width: this.headerWidth, height: this.headerHeight, startedEpoch: this.startedEpoch };
   }
-  output(data) {
+  // Events the pane produced that no stream ever took.
+  get droppedEventCount() {
+    return this.droppedCount;
+  }
+  write(data) {
     this.append([this.elapsed(), "o", data]);
   }
-  marker(label) {
+  mark(label) {
     this.append([this.elapsed(), "m", label]);
   }
-  header() {
-    return {
-      version: 2,
-      width: this.width,
-      height: this.height,
-      timestamp: Math.floor(this.startMs / 1e3)
-    };
-  }
-  subscribe(cb) {
-    this.subs.add(cb);
-    return () => this.subs.delete(cb);
-  }
   // Recorded as an "r" event so playback re-creates the pane geometry at the
-  // right point in time -- a replay against stale dims mis-wraps every line
-  // the app draws after the resize.
+  // right point in time -- a replay against stale dims mis-wraps every line the
+  // app draws after the resize.
   resize(cols, rows) {
     if (cols === this.width && rows === this.height) return;
+    const event = [this.elapsed(), "r", `${cols}x${rows}`];
     this.width = cols;
     this.height = rows;
-    this.append([this.elapsed(), "r", `${cols}x${rows}`]);
+    this.append(event);
   }
-  elapsed() {
-    return (Date.now() - this.startMs) / 1e3;
+  // Attach a stream. Whatever the pane recorded while waiting goes first, so a
+  // capture that opened three seconds late still has the whole session.
+  sinkAttach(sink) {
+    this.sink = sink;
+    this.flush();
   }
-  append(ev) {
-    for (const sub of this.subs) {
-      try {
-        sub(ev);
-      } catch {
-        this.subs.delete(sub);
+  sinkDetach() {
+    this.flush();
+    this.sink = null;
+  }
+  // The last flush. Anything the pane says afterwards is past the end of the
+  // recording and is dropped rather than published into a session already closed.
+  stop() {
+    this.flush();
+    this.isStopped = true;
+  }
+  elapsed() {
+    return (monotonicMs() - this.startMs) / 1e3;
+  }
+  append(event) {
+    if (this.isStopped) return;
+    this.buffer.push(event);
+    this.bufferBytes += event[2].length;
+    if (this.sink === null) {
+      while (this.bufferBytes > BACKLOG_BYTES_MAX && this.buffer.length > 0) {
+        const dropped = this.buffer.shift();
+        this.bufferBytes -= dropped[2].length;
+        this.droppedCount += 1;
       }
+      return;
+    }
+    if (this.bufferBytes >= FLUSH_BYTES_MAX) {
+      this.flush();
+      return;
+    }
+    if (!this.timer) this.timer = setTimeout(() => this.flush(), FLUSH_INTERVAL_MS);
+  }
+  flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
     }
+    if (this.buffer.length === 0 || this.sink === null) return;
+    const events = this.buffer;
+    this.buffer = [];
+    this.bufferBytes = 0;
+    this.sink(events);
+  }
+};
+var RecordingStream = class {
+  constructor(session, recording) {
+    this.session = session;
+    this.recording = recording;
+    recording.sinkAttach((events) => this.chunkAdd(events));
+  }
+  session;
+  recording;
+  seq = 0;
+  outbox = new Outbox("recording", {
+    send: (chunk) => this.chunkPost(chunk),
+    bytesOf: (chunk) => chunk.events.reduce((sum, event) => sum + event[2].length, 0)
+  });
+  // Chunks this session produced that the hub never took, plus events the pane
+  // recorded before any stream existed.
+  get lastError() {
+    return this.outbox.lastError;
+  }
+  get unsentCount() {
+    return this.outbox.unsentCount + this.recording.droppedEventCount;
+  }
+  async stop(deadline) {
+    this.recording.sinkDetach();
+    await this.outbox.flush(deadline);
+  }
+  chunkAdd(events) {
+    const seq = this.seq;
+    this.seq += 1;
+    this.outbox.add({ seq, offset: events[0][0], events });
+  }
+  // Throws on failure so the outbox retries: the token refresh and the POST are
+  // both worth another attempt, and a dropped chunk is a permanent gap.
+  //
+  // The header rides on every chunk because the hub keeps whichever arrives
+  // first, and a retry can make that any of them.
+  chunkPost(chunk) {
+    const header = this.recording.header;
+    return this.session.recordingAppend({
+      seq: chunk.seq,
+      offset: chunk.offset,
+      events: chunk.events,
+      width: header.width,
+      height: header.height,
+      startedEpoch: header.startedEpoch
+    });
   }
 };
+function monotonicMs() {
+  return Number(process.hrtime.bigint() / 1000000n);
+}
 
-// src/hub-recording.ts
-var FLUSH_INTERVAL_MS = 250;
-var FLUSH_BYTES_MAX = 16 * 1024;
-var HubRecordingPublisher = class {
-  constructor(hub, tokenRefresher, sessionId, recorder) {
-    this.hub = hub;
-    this.tokenRefresher = tokenRefresher;
-    this.sessionId = sessionId;
-    this.recorder = recorder;
+// src/transcript.ts
+import { open as open2, stat as stat3 } from "fs/promises";
+var POLL_MS = 400;
+var LOCATE_BACKOFF_MS = [400, 800, 1600, 3200, 5e3];
+var MISSING_DEADLINE_MS = 15e3;
+var CHILD_DEADLINE_MS = 12e4;
+var READ_BYTES_MAX = 256 * 1024;
+var NEWLINE = 10;
+var FileReader = class {
+  constructor(ref, path, emit) {
+    this.ref = ref;
+    this.path = path;
+    this.emit = emit;
+  }
+  ref;
+  path;
+  emit;
+  cursor = 0;
+  partial = Buffer.alloc(0);
+  lineSeq = 0;
+  lineOffset = 0;
+  // Bumped by every rewind, so a read that was awaiting the filesystem when one
+  // happened does not emit its old bytes under the new line numbering.
+  generation = 0;
+  hasData = false;
+  rewind() {
+    this.generation += 1;
+    this.cursor = 0;
+    this.partial = Buffer.alloc(0);
+    this.lineSeq = 0;
+    this.lineOffset = 0;
+  }
+  // One fixed-size read at a time until the file is caught up. Reading every
+  // byte written since the last poll would, on a resumed transcript, allocate
+  // the whole file at once.
+  async read() {
+    const size = await sizeOrNull(this.path);
+    if (size === null) return false;
+    if (size < this.cursor) this.rewind();
+    const generation = this.generation;
+    const handle = await open2(this.path, "r");
+    try {
+      while (this.cursor < size) {
+        const length = Math.min(READ_BYTES_MAX, size - this.cursor);
+        const buffer = Buffer.alloc(length);
+        await handle.read(buffer, 0, length, this.cursor);
+        if (this.generation !== generation) return this.hasData;
+        this.cursor += length;
+        this.hasData = true;
+        this.consume(buffer);
+      }
+    } finally {
+      await handle.close();
+    }
+    return this.hasData;
+  }
+  // Decoding happens per line, never per read: a multibyte character split
+  // across two reads would otherwise become replacement characters, which the
+  // hub would then store as the agent's own text.
+  consume(chunk) {
+    const buffer = this.partial.length > 0 ? Buffer.concat([this.partial, chunk]) : chunk;
+    let start = 0;
+    for (; ; ) {
+      const end = buffer.indexOf(NEWLINE, start);
+      if (end === -1) break;
+      const line = buffer.subarray(start, end);
+      this.emit(
+        this.ref.key,
+        line.toString("utf8"),
+        this.lineSeq,
+        this.lineOffset
+      );
+      this.lineSeq += 1;
+      this.lineOffset += line.length + 1;
+      start = end + 1;
+    }
+    this.partial = start === 0 ? buffer : Buffer.from(buffer.subarray(start));
   }
-  hub;
-  tokenRefresher;
-  sessionId;
-  recorder;
-  off = null;
-  buffer = [];
-  bufferBytes = 0;
+};
+var TranscriptReader = class {
+  constructor(agent, cwd, sinceMs, onMissing) {
+    this.agent = agent;
+    this.cwd = cwd;
+    this.sinceMs = sinceMs;
+    this.onMissing = onMissing;
+  }
+  agent;
+  cwd;
+  sinceMs;
+  onMissing;
   timer = null;
-  seq = 0;
-  width = 0;
-  height = 0;
-  startedEpoch = 0;
-  // Publishes chain through here so chunk N posts before N+1 -- flushes can
-  // otherwise race (a byte-triggered flush vs. a slow prior POST) and scramble seq order.
-  chain = Promise.resolve();
+  fileMap = /* @__PURE__ */ new Map();
+  pendingMap = /* @__PURE__ */ new Map();
+  unresolvedList = [];
+  rootPath = null;
+  rootKey = null;
+  rootListen = null;
+  ticking = false;
+  // The poll currently running, or a settled promise. tick() swallows its own
+  // errors, so awaiting this never rejects.
+  inFlight = Promise.resolve();
+  startedMs = 0;
+  locateFailures = 0;
+  nextLocateMs = 0;
+  isMissingReported = false;
+  isReadErrorReported = false;
+  sink = null;
+  // Off while the agent is expected to announce its own transcript. Guessing in
+  // the meantime can attach a concurrent session in the same workspace and post
+  // its conversation into this chat, which no later correction undoes.
+  isLocateAllowed = true;
+  // False once the session ends means the terminal was recorded but no
+  // conversation ever streamed. A file the agent announced but never wrote
+  // counts as missing: naming a path is not producing one.
+  get isReading() {
+    for (const file of this.fileMap.values()) {
+      if (file.hasData) return true;
+    }
+    return false;
+  }
+  // Subagents the transcripts said ran, whose own files never appeared. Their
+  // work is missing from the chat and nothing else would say so.
+  get unresolvedChildList() {
+    return [...this.unresolvedList, ...this.pendingMap.keys()];
+  }
+  // Attach a stream. Every file is read again from the top, because a stream
+  // that opened late still owes the hub the whole session and re-posting a line
+  // the hub already holds is a no-op.
+  sinkAttach(sink) {
+    this.sink = sink;
+    for (const file of this.fileMap.values()) {
+      file.rewind();
+      sink.fileOpen(file.ref);
+    }
+  }
+  sinkDetach() {
+    this.sink = null;
+  }
+  // Adopt a root transcript, overriding whatever transcriptLocate() may have
+  // settled on. A second root -- Claude's /clear opens one -- joins the set
+  // rather than replacing what came before.
+  //
+  // The key is passed in rather than read back off the path: where the agent
+  // announced itself, the key is what it called its own session, and that is
+  // the name a resume presents. Reading it off a filename works only for as
+  // long as a vendor keeps naming files after sessions.
+  fileAdd(path, key) {
+    if (this.fileMap.has(key)) return;
+    if (this.rootPath === null) {
+      this.rootPath = path;
+      this.rootKey = key;
+      this.rootListen?.(key, path);
+    }
+    this.fileOpen({ key, parentKey: "", callKey: "" }, path);
+  }
+  // Called once with the name of the first conversation this reader opens.
+  // Nothing else knows it: a fresh launch has no key until the agent writes one,
+  // and the pane needs it to say on its tmux session which conversation is
+  // running there -- which is what lets a later launch find this pane rather
+  // than starting a second agent on the same conversation.
+  onRootOpen(listen) {
+    this.rootListen = listen;
+    if (this.rootKey !== null && this.rootPath !== null) {
+      listen(this.rootKey, this.rootPath);
+    }
+  }
+  // Suppress guessing until locateAllow() -- called when the agent will report
+  // its own session, and released if that report never arrives.
+  locateDefer() {
+    this.isLocateAllowed = false;
+  }
+  locateAllow() {
+    this.isLocateAllowed = true;
+  }
   start() {
-    const header = this.recorder.header();
-    this.width = header.width;
-    this.height = header.height;
-    this.startedEpoch = header.timestamp;
-    this.off = this.recorder.subscribe((ev) => this.append(ev));
+    if (this.timer) return;
+    this.startedMs = Date.now();
+    this.tickStart();
+    this.timer = setInterval(() => this.tickStart(), POLL_MS);
   }
   async stop() {
-    this.off?.();
-    this.off = null;
-    this.flush();
-    await this.chain;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.inFlight;
+    if (this.fileMap.size > 0) await this.tick();
+  }
+  fileOpen(ref, path) {
+    const file = new FileReader(
+      ref,
+      path,
+      (key, text, seq, offset) => this.emit(key, text, seq, offset)
+    );
+    this.fileMap.set(ref.key, file);
+    this.sink?.fileOpen(ref);
   }
-  append(ev) {
-    this.buffer.push(ev);
-    this.bufferBytes += ev[2].length;
-    if (this.bufferBytes >= FLUSH_BYTES_MAX) {
-      this.flush();
+  // Starts a poll unless one is already running, and keeps its promise so stop()
+  // can wait the running one out.
+  tickStart() {
+    if (this.ticking) return;
+    this.inFlight = this.tick();
+  }
+  async tick() {
+    this.ticking = true;
+    try {
+      if (this.fileMap.size === 0) await this.locate();
+      for (const file of [...this.fileMap.values()]) {
+        if (!await file.read()) this.missingCheck();
+      }
+      await this.pendingResolve();
+    } catch (e) {
+      this.isReadErrorReported = true;
+    } finally {
+      this.ticking = false;
+    }
+  }
+  async locate() {
+    if (!this.isLocateAllowed) return;
+    if (Date.now() < this.nextLocateMs) return;
+    const found = await this.agent.transcriptLocate(this.cwd, this.sinceMs);
+    if (!found) {
+      const wait = LOCATE_BACKOFF_MS[Math.min(this.locateFailures, LOCATE_BACKOFF_MS.length - 1)];
+      this.locateFailures += 1;
+      this.nextLocateMs = Date.now() + wait;
+      this.missingCheck();
+      return;
+    }
+    const key = this.agent.transcriptKey(found);
+    if (key !== null) this.fileAdd(found, key);
+  }
+  // A child is opened only once its file exists, and only because a parent line
+  // named it. One that never appears is given up on and reported, rather than
+  // rescanning for the rest of the session.
+  async pendingResolve() {
+    const rootPath = this.rootPath;
+    if (rootPath === null) return;
+    for (const [key, pending] of [...this.pendingMap]) {
+      const path = await this.agent.transcriptChildLocate(
+        rootPath,
+        pending.child
+      );
+      if (path !== null) {
+        this.pendingMap.delete(key);
+        this.fileOpen(
+          { key, parentKey: pending.parentKey, callKey: pending.child.callKey },
+          path
+        );
+        continue;
+      }
+      if (Date.now() - pending.since > CHILD_DEADLINE_MS) {
+        this.pendingMap.delete(key);
+        this.unresolvedList.push(key);
+      }
+    }
+  }
+  // Fires once, after the deadline, so a launch that will never find its
+  // transcript stops looking identical to one whose agent is still starting.
+  missingCheck() {
+    if (this.isMissingReported) return;
+    if (this.fileMap.size > 0 && this.isReading) return;
+    if (Date.now() - this.startedMs < MISSING_DEADLINE_MS) return;
+    this.isMissingReported = true;
+    this.onMissing();
+  }
+  // One line's failure is that line's. Without this, a sink that throws would
+  // abandon every line already framed in the same read, from a cursor that has
+  // already moved past them.
+  emit(key, text, seq, offset) {
+    try {
+      this.sink?.line(key, text, seq, offset);
+    } catch (e) {
+      this.isReadErrorReported = true;
+    }
+    this.childrenNote(key, text);
+  }
+  childrenNote(parentKey, text) {
+    for (const child of this.agent.transcriptChildren(text)) {
+      if (this.fileMap.has(child.key) || this.pendingMap.has(child.key))
+        continue;
+      this.pendingMap.set(child.key, { child, parentKey, since: Date.now() });
+    }
+  }
+};
+var FLUSH_INTERVAL_MS2 = 250;
+var FLUSH_BYTES_MAX2 = 512 * 1024;
+var FLUSH_LINES_MAX = 100;
+var TranscriptStream = class {
+  constructor(session, reader) {
+    this.session = session;
+    this.reader = reader;
+    reader.sinkAttach(this);
+  }
+  session;
+  reader;
+  bufferMap = /* @__PURE__ */ new Map();
+  timer = null;
+  unnamedCount = 0;
+  outbox = new Outbox("transcript", {
+    send: (batch) => this.session.transcriptAppend(batch),
+    bytesOf: (batch) => batch.body.length,
+    lossOf: (batch) => batch.lineCount
+  });
+  // Lines this session produced that the hub never took. Zero means the hub has
+  // the whole transcript; anything else is a hole no derived view can see.
+  get lastError() {
+    return this.outbox.lastError;
+  }
+  get unsentCount() {
+    return this.outbox.unsentCount + this.unnamedCount;
+  }
+  fileOpen(ref) {
+    if (ref.parentKey) this.flushOne(ref.parentKey);
+    const nextSeq = ref.key === this.session.resumeKey ? this.session.resumeSeq : 0;
+    this.bufferMap.set(ref.key, {
+      ref,
+      lines: [],
+      startSeq: 0,
+      startOffset: 0,
+      bytes: 0,
+      nextSeq
+    });
+    this.outbox.add({
+      fileKey: ref.key,
+      parentKey: ref.parentKey,
+      callKey: ref.callKey,
+      startSeq: nextSeq,
+      startOffset: 0,
+      body: "",
+      lineCount: 0
+    });
+  }
+  line(key, text, seq, offset) {
+    const buffer = this.bufferMap.get(key);
+    if (buffer === void 0) {
+      this.unnamedCount += 1;
+      return;
+    }
+    if (seq < buffer.nextSeq) return;
+    if (buffer.lines.length === 0) {
+      buffer.startSeq = seq;
+      buffer.startOffset = offset;
+    }
+    buffer.lines.push(text);
+    buffer.bytes += Buffer.byteLength(text, "utf8") + 1;
+    if (buffer.bytes >= FLUSH_BYTES_MAX2 || buffer.lines.length >= FLUSH_LINES_MAX) {
+      this.flushOne(key);
       return;
     }
     if (!this.timer) {
-      this.timer = setTimeout(() => this.flush(), FLUSH_INTERVAL_MS);
+      this.timer = setTimeout(() => this.flush(), FLUSH_INTERVAL_MS2);
+      this.timer.unref();
     }
   }
+  async stop(deadline) {
+    this.reader.sinkDetach();
+    this.flush();
+    await this.outbox.flush(deadline);
+  }
   flush() {
     if (this.timer) {
       clearTimeout(this.timer);
       this.timer = null;
     }
-    if (this.buffer.length === 0) return;
-    const events = this.buffer;
-    const offset = events[0][0];
-    this.buffer = [];
-    this.bufferBytes = 0;
-    const seq = this.seq;
-    this.seq += 1;
-    this.chain = this.chain.then(async () => {
-      let token;
-      try {
-        token = await this.tokenRefresher.current();
-      } catch (e) {
-        process.stderr.write(`terminal session token refresh failed: ${String(e)}
-`);
-        return;
-      }
-      return this.hub.chunkAppend(token, this.sessionId, {
-        seq,
-        offset,
-        events,
-        width: this.width,
-        height: this.height,
-        startedEpoch: this.startedEpoch
-      }).catch((e) => {
-        process.stderr.write(`terminal session chunk post failed: ${String(e)}
-`);
-      });
+    for (const key of this.bufferMap.keys()) this.flushOne(key);
+  }
+  flushOne(key) {
+    const buffer = this.bufferMap.get(key);
+    if (buffer === void 0 || buffer.lines.length === 0) return;
+    this.outbox.add({
+      fileKey: key,
+      parentKey: buffer.ref.parentKey,
+      callKey: buffer.ref.callKey,
+      startSeq: buffer.startSeq,
+      startOffset: buffer.startOffset,
+      // The trailing newline matters: the body is a slice of the file, and every
+      // line in the file is terminated.
+      body: `${buffer.lines.join("\n")}
+`,
+      lineCount: buffer.lines.length
     });
+    buffer.lines = [];
+    buffer.bytes = 0;
   }
 };
-
-// src/hub-mentions.ts
-function wsCtor() {
-  const g = globalThis;
-  return typeof g.WebSocket === "function" ? g.WebSocket : null;
-}
-var NON_WORD_RUN_RE = /^[^\w]*/;
-function agentMentionStrip(text, hits) {
-  let out = text;
-  for (const r of [...hits].sort((a, b) => b.start - a.start)) {
-    if (r.start >= 0 && r.start <= r.end && r.end <= out.length) {
-      const tail = NON_WORD_RUN_RE.exec(out.slice(r.end));
-      const tailEnd = r.end + (tail ? tail[0].length : 0);
-      out = out.slice(0, r.start) + out.slice(tailEnd);
-    }
-  }
-  return out;
-}
-function mentionPrompt(blocks, agentActorId) {
-  let mentioned = false;
-  const parts = [];
-  for (const b of blocks) {
-    if (b.kind !== "text" || typeof b.text !== "string") continue;
-    const hits = (b.mentions ?? []).filter((m) => m.actor_public_id === agentActorId);
-    if (hits.length > 0) mentioned = true;
-    const stripped = agentMentionStrip(b.text, hits).trim();
-    if (stripped) parts.push(stripped);
-  }
-  if (!mentioned) return null;
-  const text = parts.join("\n").trim();
-  return text.length > 0 ? text : null;
+async function sizeOrNull(path) {
+  try {
+    return (await stat3(path)).size;
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  }
 }
+
+// src/steering.ts
 var RECONNECT_MAX_MS = 8e3;
-var HubMentions = class {
-  constructor(hubUrl, tokenRefresher, chatId, agentActorId, sinceMs) {
-    this.hubUrl = hubUrl;
-    this.tokenRefresher = tokenRefresher;
-    this.chatId = chatId;
-    this.agentActorId = agentActorId;
-    this.sinceMs = sinceMs;
+var OPEN_TIMEOUT_MS = 15e3;
+var PING_INTERVAL_MS = 1e4;
+var PONG_STALE_MS = 25e3;
+var Steering = class {
+  constructor(session, auth) {
+    this.session = session;
+    this.auth = auth;
   }
-  hubUrl;
-  tokenRefresher;
-  chatId;
-  agentActorId;
-  sinceMs;
+  session;
+  auth;
   ws = null;
-  stopped = false;
-  handler = null;
+  isStopped = false;
+  inject = null;
   reconnectTimer = null;
+  openTimer = null;
+  pingTimer = null;
+  pongAt = 0;
   attempts = 0;
-  // Upsert protocol: the same message re-broadcasts as it streams or gets a
-  // reaction. Fire an @-mention once by remembering the ids we've injected.
-  seen = /* @__PURE__ */ new Set();
+  isOpened = false;
+  lastFailure = "";
+  // Steers already typed into the pane, and what happened to each -- null while
+  // one is still being typed. A reconnect replays what the hub still considers
+  // undelivered, so the same steer arrives more than once: typing it again would
+  // put the person's words into the agent twice, and staying silent would leave
+  // the hub replaying it forever. The outcome is kept so a repeat is answered
+  // with the same one.
+  deliveredMap = /* @__PURE__ */ new Map();
   start(inject) {
-    this.handler = inject;
+    this.inject = inject;
     this.connect();
   }
+  // Empty when steering worked. Otherwise why the chat could not reach this
+  // pane, which is invisible from the chat's side: with no socket, no steer ever
+  // arrives, so there is no undelivered row to look at.
+  get failure() {
+    if (this.isOpened && !this.lastFailure) return "";
+    if (!this.lastFailure) return "";
+    return `chat steers could not reach this terminal: ${this.lastFailure}`;
+  }
   async stop() {
-    this.stopped = true;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    this.ws?.close(1e3);
-    this.ws = null;
+    this.isStopped = true;
+    this.timersClear();
+    this.socketDrop();
   }
   connect() {
-    if (this.stopped) return;
-    const Ctor = wsCtor();
-    if (!Ctor) {
-      process.stderr.write(
-        "[directed] this Node has no WebSocket (needs >=22); @-mentions won't reach the CLI.\n"
-      );
+    if (this.isStopped) return;
+    const ctor = globalThis.WebSocket;
+    if (typeof ctor !== "function") {
+      this.lastFailure = "this Node has no WebSocket";
       return;
     }
-    this.tokenRefresher.current().then((token) => this.openSocket(Ctor, token)).catch((e) => {
-      process.stderr.write(`[directed] could not fetch a token for the mentions socket: ${String(e)}
-`);
-      this.scheduleReconnect();
+    this.auth.token().then((token) => this.socketOpen(ctor, token)).catch((e) => {
+      this.lastFailure = `could not authenticate the socket (${String(e)})`;
+      this.reconnectSchedule();
     });
   }
-  openSocket(Ctor, token) {
-    if (this.stopped) return;
-    const base = this.hubUrl.replace(/^http/, "ws");
-    const ws = new Ctor(`${base}/ws/chats/${this.chatId}/`, ["jwt", token]);
+  socketOpen(ctor, token) {
+    if (this.isStopped) return;
+    this.openTimerClear();
+    this.pingTimerClear();
+    this.socketDrop();
+    const ws = new ctor(this.session.socketUrl, ["jwt", token]);
     this.ws = ws;
+    this.openTimer = setTimeout(() => {
+      this.socketLost(ws, "the socket did not open");
+    }, OPEN_TIMEOUT_MS);
     ws.onopen = () => {
       this.attempts = 0;
+      this.isOpened = true;
+      this.lastFailure = "";
+      this.openTimerClear();
+      this.pongAt = Date.now();
+      this.pingSend();
+      this.pingTimer = setInterval(() => this.pingSend(), PING_INTERVAL_MS);
+      this.pingTimer.unref();
     };
     ws.onmessage = (ev) => this.onFrame(ev.data);
-    ws.onerror = () => {
+    ws.onerror = (ev) => {
+      this.socketLost(ws, `the control socket errored (${String(ev)})`);
     };
     ws.onclose = (ev) => {
-      this.ws = null;
-      if (this.stopped) return;
-      if (ev.code === 4001 || ev.code === 4003 || ev.code === 4004) {
-        process.stderr.write(
-          `[directed] chat socket closed (${ev.code}); @-mentions to the CLI are off.
-`
-        );
+      if (this.isStopped || this.ws !== ws) return;
+      if (ev.code === 4004) {
+        this.socketRetire(ws);
+        this.lastFailure = "the hub says this session has ended";
+        this.session.endedReceive();
         return;
       }
-      if (ev.code === 4002) {
-        this.tokenRefresher.refreshNow().then(() => this.scheduleReconnect()).catch((e) => {
-          process.stderr.write(`[directed] could not refresh the mentions socket token: ${String(e)}
-`);
-          this.scheduleReconnect();
-        });
+      if (ev.code === 4001 || ev.code === 4002 || ev.code === 4003) {
+        this.socketRetire(ws);
+        this.auth.refresh().catch((e) => {
+          this.lastFailure = `could not refresh the socket token (${String(e)})`;
+        }).finally(() => this.reconnectSchedule());
         return;
       }
-      this.scheduleReconnect();
+      this.socketLost(ws, `the hub closed the control socket (${ev.code})`);
     };
   }
-  scheduleReconnect() {
-    if (this.stopped || this.reconnectTimer) return;
+  // Every non-terminal transport failure comes through here. Error and close
+  // commonly arrive for the same failure; socket identity makes the second a
+  // no-op, and reconnectSchedule makes the first exactly one backed-off retry.
+  socketLost(ws, failure) {
+    if (this.isStopped || !this.socketRetire(ws)) return;
+    this.lastFailure = failure;
+    this.reconnectSchedule();
+  }
+  socketRetire(ws) {
+    if (this.ws !== ws) return false;
+    this.isOpened = false;
+    this.openTimerClear();
+    this.pingTimerClear();
+    this.socketDrop();
+    return true;
+  }
+  reconnectSchedule() {
+    if (this.isStopped || this.reconnectTimer) return;
     const delay = Math.min(1e3 * 2 ** this.attempts, RECONNECT_MAX_MS);
     this.attempts += 1;
     this.reconnectTimer = setTimeout(() => {
@@ -831,1096 +2019,1136 @@ var HubMentions = class {
   }
   onFrame(raw) {
     if (typeof raw !== "string") return;
-    let env;
+    let frame;
     try {
-      env = JSON.parse(raw);
+      frame = JSON.parse(raw);
     } catch {
       return;
     }
-    if (env.kind !== "message_upsert") return;
-    const m = env.data;
-    if (!m || typeof m.public_id !== "string" || this.seen.has(m.public_id)) return;
-    if (m.actor?.public_id === this.agentActorId) return;
-    const createdMs = m.created_at ? Date.parse(m.created_at) : NaN;
-    if (Number.isFinite(createdMs) && createdMs <= this.sinceMs) return;
-    const text = mentionPrompt(m.blocks ?? [], this.agentActorId);
-    if (text === null) return;
-    this.seen.add(m.public_id);
-    this.handler?.({
-      text,
-      author: m.actor?.display_name ?? "someone",
-      seed: m.actor?.public_id ?? m.public_id,
-      ts: Number.isFinite(createdMs) ? createdMs : Date.now()
-    });
-  }
-};
-
-// src/echo-guard.ts
-var ECHO_TTL_MS = 3e4;
-function normalize(text) {
-  return text.trim();
-}
-var EchoGuard = class {
-  pending = [];
-  record(text) {
-    const norm = normalize(text);
-    if (!norm) return;
-    this.pending.push({ text: norm, at: Date.now() });
-  }
-  // True (and removes the entry) if `text` matches a still-live injected mention.
-  // Prunes expired entries on the way so they never suppress a real message.
-  consume(text) {
-    const now = Date.now();
-    this.pending = this.pending.filter((p) => now - p.at < ECHO_TTL_MS);
-    const norm = normalize(text);
-    const idx = this.pending.findIndex((p) => p.text === norm);
-    if (idx === -1) return false;
-    this.pending.splice(idx, 1);
-    return true;
-  }
-};
-
-// src/transcript/adapter.ts
-import { basename as basename3 } from "path";
-
-// src/transcript/claude.ts
-import { readdir, stat as stat2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { basename, join as join4 } from "path";
-function encodeProjectDir(cwd) {
-  return cwd.replace(/[/.]/g, "-");
-}
-var SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var ClaudeAdapter = class {
-  async locate(cwd, sinceMs, _processId) {
-    const newest = await newestTranscript(projectDir(cwd));
-    if (!newest || newest.mtimeMs < sinceMs) return null;
-    return newest.path;
-  }
-  refFromPath(path) {
-    const name = basename(path);
-    if (!name.endsWith(".jsonl")) return null;
-    return name.slice(0, -".jsonl".length);
-  }
-  // Claude Code appends to the same <sessionId>.jsonl on --resume/--continue,
-  // so the resumed session's id is knowable before launch: from the flag's own
-  // argument, or from the newest transcript on disk for --continue. A bare
-  // --resume opens claude's interactive picker -- the target is unknowable, so
-  // it reads as a fresh session. --fork-session branches into a new id.
-  async resumeRef(command, cwd) {
-    const args = command.slice(1);
-    if (args.includes("--fork-session")) return null;
-    for (let i = 0; i < args.length; i++) {
-      const [flag, inline] = flagSplit(args[i]);
-      if (flag === "--resume" || flag === "-r" || flag === "--session-id") {
-        const candidate = inline ?? args[i + 1];
-        if (candidate !== void 0 && SESSION_ID_RE.test(candidate)) return candidate;
-      } else if (flag === "--continue" || flag === "-c") {
-        const newest = await newestTranscript(projectDir(cwd));
-        return newest ? this.refFromPath(newest.path) : null;
-      }
+    if (frame.kind === "pong") {
+      this.pongAt = Date.now();
+      return;
     }
-    return null;
-  }
-  parse(record) {
-    const r = record;
-    if (r.type === "user") return this.parseUser(r);
-    if (r.type === "assistant") return this.parseAssistant(r);
-    return null;
-  }
-  parseUser(r) {
-    const content = r.message?.content;
-    if (typeof content !== "string") return null;
-    return { id: r.uuid, role: "user", ts: Date.parse(r.timestamp), parts: [{ kind: "text", text: content }] };
-  }
-  parseAssistant(r) {
-    const content = r.message?.content;
-    if (!Array.isArray(content)) return null;
-    const parts = [];
-    for (const block of content) {
-      if (block.type === "text" && block.text !== void 0) parts.push({ kind: "text", text: block.text });
-      else if (block.type === "thinking" && block.thinking !== void 0) parts.push({ kind: "thinking", text: block.thinking });
-      else if (block.type === "tool_use" && block.name !== void 0) parts.push({ kind: "tool", name: block.name });
+    if (frame.kind !== "steer") return;
+    const steer = steerParse(frame.data);
+    if (steer === null) return;
+    const done = this.deliveredMap.get(steer.eventId);
+    if (done !== void 0) {
+      if (done !== null)
+        void this.session.steerAck(steer.eventId, done).catch(() => {
+        });
+      return;
     }
-    if (parts.length === 0) return null;
-    return { id: r.uuid, role: "assistant", ts: Date.parse(r.timestamp), parts };
+    this.deliveredMap.set(steer.eventId, null);
+    void this.deliver(steer);
   }
-};
-function projectDir(cwd) {
-  return join4(homedir2(), ".claude/projects", encodeProjectDir(cwd));
-}
-function flagSplit(arg) {
-  const at = arg.indexOf("=");
-  if (at === -1) return [arg, void 0];
-  return [arg.slice(0, at), arg.slice(at + 1)];
-}
-async function newestTranscript(dir) {
-  let entries;
-  try {
-    entries = await readdir(dir);
-  } catch {
-    return null;
+  // Detaches the current socket's handlers before closing it, so its own close
+  // event cannot clear a socket that has already replaced it.
+  socketDrop() {
+    const ws = this.ws;
+    this.ws = null;
+    if (ws === null) return;
+    ws.onopen = null;
+    ws.onclose = null;
+    ws.onmessage = null;
+    ws.onerror = null;
+    ws.close(1e3);
+  }
+  // The control path proves itself over the control path. A durable "opened"
+  // timestamp cannot notice a hub process disappearing before disconnect runs.
+  pingSend() {
+    const ws = this.ws;
+    if (ws === null) return;
+    if (Date.now() - this.pongAt > PONG_STALE_MS) {
+      this.socketLost(ws, "the control socket stopped answering");
+      return;
+    }
+    try {
+      ws.send(JSON.stringify({ kind: "ping" }));
+    } catch (e) {
+      this.socketLost(
+        ws,
+        `could not ping the control socket (${String(e)})`
+      );
+    }
   }
-  let newest = null;
-  for (const entry of entries) {
-    if (!entry.endsWith(".jsonl")) continue;
-    const path = join4(dir, entry);
-    const info = await stat2(path);
-    if (!newest || info.mtimeMs > newest.mtimeMs) newest = { path, mtimeMs: info.mtimeMs };
+  // The hub hears what happened either way. A steer the pane could not type is
+  // the failure that used to be invisible: the sender saw their own message in
+  // the chat and had no way to know it never arrived.
+  async deliver(steer) {
+    let outcome = "failed";
+    try {
+      outcome = await this.inject?.(steer) ?? "failed";
+    } catch (e) {
+      this.lastFailure = `could not type a steer into the pane (${String(e)})`;
+    }
+    this.deliveredMap.set(steer.eventId, outcome);
+    try {
+      await this.session.steerAck(steer.eventId, outcome);
+    } catch (e) {
+      this.lastFailure = `could not acknowledge a steer (${String(e)})`;
+    }
   }
-  return newest;
-}
-
-// src/transcript/codex.ts
-import { execFile } from "child_process";
-import { open as open2, readdir as readdir2, readlink } from "fs/promises";
-import { homedir as homedir3, platform } from "os";
-import { basename as basename2, join as join5 } from "path";
-var SESSION_ID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var ROLLOUT_RE = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
-var SESSION_META_BYTES = 1024 * 1024;
-var CodexAdapter = class {
-  constructor(processRolloutPaths = rolloutPathsForProcess) {
-    this.processRolloutPaths = processRolloutPaths;
+  timersClear() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.openTimerClear();
+    this.pingTimerClear();
   }
-  processRolloutPaths;
-  async locate(_cwd, _sinceMs, processId) {
-    const paths = await this.processRolloutPaths(processId);
-    const primaryPaths = [];
-    for (const path of paths) {
-      if (await isPrimaryRollout(path)) primaryPaths.push(path);
+  openTimerClear() {
+    if (this.openTimer) {
+      clearTimeout(this.openTimer);
+      this.openTimer = null;
     }
-    return primaryPaths.length === 1 ? primaryPaths[0] : null;
   }
-  refFromPath(path) {
-    const match = ROLLOUT_RE.exec(basename2(path));
-    return match ? match[1] : null;
+  pingTimerClear() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
   }
-  // `codex resume` reopens an existing rollout, whose filename keeps the
-  // original session uuid: the flag's own argument names it, and --last means
-  // the newest primary rollout in scope. A bare `codex resume` opens the
-  // interactive picker -- the target is unknowable, so it reads as a fresh session.
-  async resumeRef(command, cwd) {
-    const args = command.slice(1);
-    const subcommand = args.find((a) => !a.startsWith("-"));
-    if (subcommand !== "resume") return null;
-    const rest = args.slice(args.indexOf("resume") + 1);
-    const id = rest.find((a) => SESSION_ID_RE2.test(a));
-    if (id) return id;
-    if (rest.includes("--last")) {
-      const newest = await newestRollout(rest.includes("--all") ? null : cwd);
-      return newest ? this.refFromPath(newest) : null;
+};
+function steerParse(data) {
+  if (!data) return null;
+  const { eventId, messageId, text, author } = data;
+  if (typeof eventId !== "string" || !eventId) return null;
+  if (typeof text !== "string" || !text.trim()) return null;
+  return {
+    eventId,
+    messageId: typeof messageId === "string" ? messageId : "",
+    text,
+    author: typeof author === "string" && author ? author : "someone"
+  };
+}
+
+// src/capture.ts
+var exec = promisify2(execFile);
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var SHUTDOWN_MS = 8e3;
+var GIT_TIMEOUT_MS = 5e3;
+var Capture = class _Capture {
+  constructor(note, session, reader, recordingStream, transcriptStream, steering, chatUrl, reattached, skippedMemberList) {
+    this.note = note;
+    this.session = session;
+    this.reader = reader;
+    this.recordingStream = recordingStream;
+    this.transcriptStream = transcriptStream;
+    this.steering = steering;
+    this.chatUrl = chatUrl;
+    this.reattached = reattached;
+    this.skippedMemberList = skippedMemberList;
+  }
+  note;
+  session;
+  reader;
+  recordingStream;
+  transcriptStream;
+  steering;
+  chatUrl;
+  reattached;
+  skippedMemberList;
+  stopWork = null;
+  get chatPublicId() {
+    return this.session.chatPublicId;
+  }
+  // Opens the chat and attaches to what the pane is already producing. Returns
+  // null for every reason capture cannot run -- not signed in, hub unreachable,
+  // a command with no transcript -- because none of them is the pane's problem.
+  static async start(hub, auth, recording, reader, options, note) {
+    let session;
+    try {
+      session = await HubSession.open(hub, options);
+    } catch (e) {
+      if (e instanceof TerminalHeldError) throw e;
+      note(
+        `could not open the chat (${e.message}); this session stays local.`
+      );
+      return null;
     }
-    return null;
+    const recordingStream = new RecordingStream(session, recording);
+    const transcriptStream = new TranscriptStream(session, reader);
+    const steering = new Steering(session, auth);
+    const capture = new _Capture(
+      note,
+      session,
+      reader,
+      recordingStream,
+      transcriptStream,
+      steering,
+      session.chatUrl,
+      session.reattached,
+      session.skippedMemberList
+    );
+    session.endedWatch(() => void capture.remoteStop());
+    return capture;
+  }
+  steerListen(inject) {
+    this.steering.start(inject);
+  }
+  // Mint the chat's join link, for an email invite.
+  linkCreate() {
+    return this.session.linkCreate();
+  }
+  // One deadline for both streams: stop the producers, drain in parallel with
+  // the time that remains, then post the end state. `isDetached` means the agent
+  // ran on unwatched, which no loss count can show, so the session says so.
+  async stop(isDetached) {
+    if (this.stopWork === null) this.stopWork = this.localStop(isDetached);
+    await this.stopWork;
+  }
+  async localStop(isDetached) {
+    const gitEnd = await gitSnapshot(process.cwd());
+    const deadline = Date.now() + SHUTDOWN_MS;
+    await this.steering.stop();
+    await Promise.all([
+      this.recordingStream.stop(deadline),
+      this.transcriptStream.stop(deadline)
+    ]);
+    this.lossReport();
+    await this.session.close({
+      transcriptLost: this.transcriptStream.unsentCount,
+      recordingLost: this.recordingStream.unsentCount,
+      isDetached,
+      gitEnd
+    });
   }
-  parse(record) {
-    const r = record;
-    if (r.type !== "response_item" || !r.payload) return null;
-    const p = r.payload;
-    const ts = Date.parse(r.timestamp);
-    const id = p.id ?? `codex-${ts}`;
-    if (p.type === "message") {
-      const role = p.role === "assistant" ? "assistant" : p.role === "user" ? "user" : null;
-      if (role === null) return null;
-      const parts = [];
-      for (const b of p.content ?? []) {
-        if ((b.type === "input_text" || b.type === "output_text") && typeof b.text === "string") {
-          parts.push({ kind: "text", text: b.text });
-        }
-      }
-      if (parts.length === 0) return null;
-      return { id, role, ts, parts };
+  // Ownership can end while the pane is still running. Stop only collaboration:
+  // the local tmux session and coding agent remain entirely outside this path.
+  async remoteStop() {
+    if (this.stopWork === null) this.stopWork = this.remoteStopWrite();
+    await this.stopWork;
+  }
+  async remoteStopWrite() {
+    await this.steering.stop();
+    await Promise.all([
+      this.recordingStream.stop(Date.now()),
+      this.transcriptStream.stop(Date.now())
+    ]);
+    await this.session.close({
+      transcriptLost: this.transcriptStream.unsentCount,
+      recordingLost: this.recordingStream.unsentCount,
+      isDetached: true,
+      gitEnd: null
+    });
+    this.note("this chat connection ended; the local agent is still running");
+  }
+  // Said once, after the streams have drained and the pane has already given the
+  // terminal back. The counts are the session's integrity state; the last error
+  // is the only part a person can act on.
+  lossReport() {
+    const lostList = [
+      [
+        "transcript lines",
+        this.transcriptStream.unsentCount,
+        this.transcriptStream.lastError
+      ],
+      [
+        "recording chunks",
+        this.recordingStream.unsentCount,
+        this.recordingStream.lastError
+      ]
+    ];
+    for (const [unit, count, why] of lostList) {
+      if (count === 0) continue;
+      this.note(
+        `${count} ${unit} never reached the hub${why ? ` (${why})` : ""}`
+      );
     }
-    if (p.type === "function_call" && typeof p.name === "string") {
-      return { id, role: "assistant", ts, parts: [{ kind: "tool", name: p.name }] };
+    const unresolved = this.reader.unresolvedChildList;
+    if (unresolved.length > 0) {
+      this.note(
+        `${unresolved.length} subagent transcript(s) never appeared, so their work is not in the chat`
+      );
     }
-    return null;
+    const failure = this.steering.failure;
+    if (failure) this.note(failure);
   }
 };
-async function newestRollout(cwd) {
-  const dir = join5(homedir3(), ".codex", "sessions");
-  let entries;
-  try {
-    entries = await readdir2(dir, { recursive: true });
-  } catch {
-    return null;
+var HubSession = class _HubSession {
+  constructor(hub, publicId, chatPublicId2, agentActorPublicId, chatUrl, reattached, skippedMemberList, resumeKey, resumeSeq) {
+    this.hub = hub;
+    this.publicId = publicId;
+    this.chatPublicId = chatPublicId2;
+    this.agentActorPublicId = agentActorPublicId;
+    this.chatUrl = chatUrl;
+    this.reattached = reattached;
+    this.skippedMemberList = skippedMemberList;
+    this.resumeKey = resumeKey;
+    this.resumeSeq = resumeSeq;
   }
-  const rollouts = entries.filter((f) => {
-    const b = basename2(f);
-    return b.startsWith("rollout-") && b.endsWith(".jsonl");
-  });
-  rollouts.sort();
-  rollouts.reverse();
-  for (const rollout of rollouts) {
-    const path = join5(dir, rollout);
-    if (await isPrimaryRollout(path, cwd)) return path;
+  hub;
+  publicId;
+  chatPublicId;
+  agentActorPublicId;
+  chatUrl;
+  reattached;
+  skippedMemberList;
+  resumeKey;
+  resumeSeq;
+  heartbeatTimer = null;
+  endedListener = null;
+  isEnded = false;
+  static async open(hub, options) {
+    const started = await hub.terminalCreate({
+      source: options.source,
+      title: options.title,
+      resumeKey: options.resumeKey ?? void 0,
+      chatPublicId: options.chatPublicId ?? void 0,
+      memberList: options.memberList,
+      gitStart: options.gitStart
+    });
+    const session = new _HubSession(
+      hub,
+      started.terminalSessionPublicId,
+      started.chatPublicId,
+      started.agentActorPublicId,
+      started.chatUrl,
+      started.reattached,
+      started.skippedMemberList,
+      options.resumeKey ?? "",
+      started.resumeSeq
+    );
+    session.heartbeatTimer = setInterval(
+      () => void session.heartbeat(),
+      HEARTBEAT_INTERVAL_MS
+    );
+    session.heartbeatTimer.unref();
+    return session;
   }
-  return null;
-}
-async function rolloutPathsForProcess(processId) {
-  if (platform() === "darwin") return macosRolloutPaths(processId);
-  if (platform() === "linux") return linuxRolloutPaths(processId);
-  return [];
-}
-async function macosRolloutPaths(processId) {
-  return new Promise((resolve) => {
-    execFile(
-      "/usr/sbin/lsof",
-      ["-a", "-p", String(processId), "-Fn"],
-      { encoding: "utf8", maxBuffer: 4 * 1024 * 1024 },
-      (error, stdout) => {
-        if (error) {
-          resolve([]);
-          return;
-        }
-        const paths = [];
-        for (const line of stdout.split("\n")) {
-          if (!line.startsWith("n")) continue;
-          const path = line.slice(1);
-          if (isRolloutPath(path)) paths.push(path);
-        }
-        resolve([...new Set(paths)]);
-      }
+  async recordingAppend(chunk) {
+    await this.liveRequest(
+      () => this.hub.recordingAppend(this.publicId, chunk)
     );
-  });
-}
-async function linuxRolloutPaths(processId) {
-  const fdDir = `/proc/${processId}/fd`;
-  let entries;
-  try {
-    entries = await readdir2(fdDir);
-  } catch {
-    return [];
   }
-  const paths = [];
-  for (const entry of entries) {
-    let path;
+  // A batch names its own file, and a subagent's names the parent that launched
+  // it, so lineage arrives with the data it describes and the outbox retries
+  // both together.
+  async transcriptAppend(batch) {
+    await this.liveRequest(
+      () => this.hub.transcriptAppend(this.publicId, batch)
+    );
+  }
+  async linkCreate() {
+    return this.hub.chatLinkCreate(this.chatPublicId);
+  }
+  get socketUrl() {
+    return this.hub.socketUrl(`/ws/terminal-sessions/${this.publicId}/`);
+  }
+  async steerAck(eventId, outcome) {
+    await this.liveRequest(
+      () => this.hub.steerAck(this.publicId, eventId, outcome)
+    );
+  }
+  // Best-effort, like the heartbeat: the pane is already gone by the time this
+  // runs, and a failed close is recovered by the hub's own staleness window.
+  async close(state) {
+    this.isEnded = true;
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+    await this.hub.terminalEnd(this.publicId, state).catch(() => {
+    });
+  }
+  endedWatch(listener) {
+    this.endedListener = listener;
+    if (this.isEnded) listener();
+  }
+  endedReceive() {
+    if (this.isEnded) return;
+    this.isEnded = true;
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+    this.endedListener?.();
+  }
+  async liveRequest(request) {
+    try {
+      await request();
+    } catch (e) {
+      if (e instanceof HubError && e.status === 409) this.endedReceive();
+      throw e;
+    }
+  }
+  // A missed beat is recovered by the next one, and a hub that is unreachable
+  // must never interrupt the local terminal.
+  async heartbeat() {
+    let state;
     try {
-      path = await readlink(join5(fdDir, entry));
+      state = await this.hub.terminalHeartbeat(this.publicId);
     } catch {
-      continue;
+      return;
+    }
+    if (state.isEnded) {
+      this.endedReceive();
     }
-    if (isRolloutPath(path)) paths.push(path);
   }
-  return [...new Set(paths)];
-}
-function isRolloutPath(path) {
-  return ROLLOUT_RE.test(basename2(path));
+};
+async function gitSnapshot(cwd) {
+  const sha = await git(["rev-parse", "HEAD"], cwd);
+  if (sha === null) return null;
+  const branch = await git(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+  const root = await git(["rev-parse", "--show-toplevel"], cwd);
+  const status = await git(["status", "--porcelain", "-z"], cwd);
+  return {
+    sha: sha.trim(),
+    branch: (branch ?? "").trim(),
+    root: (root ?? "").trim(),
+    dirtyPaths: dirtyPaths(status ?? "")
+  };
 }
-async function isPrimaryRollout(path, cwd = null) {
-  const line = await firstLine(path);
-  if (line === null) return false;
-  let record;
-  try {
-    record = JSON.parse(line);
-  } catch {
-    return false;
+function dirtyPaths(status) {
+  const entries = status.split("\0");
+  const paths = [];
+  for (let i = 0; i < entries.length; i += 1) {
+    const entry = entries[i];
+    if (entry.length < 4) continue;
+    paths.push(entry.slice(3));
+    if (entry[0] === "R" || entry[1] === "R") i += 1;
   }
-  if (!isRecord(record) || record.type !== "session_meta" || !isRecord(record.payload)) return false;
-  const pathMatch = ROLLOUT_RE.exec(basename2(path));
-  if (record.payload.source !== "cli" || record.payload.id !== pathMatch?.[1]) return false;
-  return cwd === null || record.payload.cwd === cwd;
+  return paths;
 }
-async function firstLine(path) {
-  let handle;
+async function git(args, cwd) {
   try {
-    handle = await open2(path, "r");
-    const buffer = Buffer.alloc(SESSION_META_BYTES);
-    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-    const lineEnd = buffer.indexOf("\n", 0);
-    if (bytesRead === 0 || lineEnd === -1 || lineEnd >= bytesRead) return null;
-    return buffer.subarray(0, lineEnd).toString("utf8");
+    const { stdout } = await exec("git", args, {
+      cwd,
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: 8 * 1024 * 1024
+    });
+    return stdout;
   } catch {
     return null;
-  } finally {
-    await handle?.close();
   }
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
 
-// src/transcript/adapter.ts
-function adapterFor(command) {
-  const program = command[0];
-  if (program === void 0) return null;
-  const name = basename3(program);
-  if (name === "claude") return new ClaudeAdapter();
-  if (name === "codex") return new CodexAdapter();
-  return null;
-}
-function sourceFor(command) {
-  const program = command[0];
-  if (program === void 0) return null;
-  const name = basename3(program);
-  if (name === "claude") return "claude_code";
-  if (name === "codex") return "codex";
-  return null;
-}
+// src/pane.ts
+import { spawn } from "child_process";
+import { rmSync as rmSync3 } from "fs";
+import { join as join5 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { StringDecoder } from "string_decoder";
+var BANNER = `
+                   \u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591
+                 \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591
+                \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591
+               \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+               \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+              \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+              \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+            \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591
+ \u2591\u2591       \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+\u2591\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591
+\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591
+ \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+  \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2591
+   \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2591
+     \u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591
+     \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+    \u2591\u2588\u2588\u2588\u2591\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2591\u2591\u2591\u2591\u2588\u2588\u2591
+   \u2591\u2588\u2588\u2591\u2591 \u2591\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2588\u2588\u2588\u2591 \u2591\u2588\u2588\u2591  \u2591\u2588\u2588\u2591
+  \u2591\u2588\u2588\u2588\u2591  \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591 \u2591\u2588\u2588\u2591  \u2591\u2588\u2588\u2591  \u2591\u2588\u2588\u2591
+   \u2591\u2588\u2588\u2591   \u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2591  \u2591\u2588\u2588\u2591\u2591 \u2591\u2591  \u2591\u2591\u2588\u2588\u2591
+    \u2591\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2591  \u2591\u2591\u2591\u2591\u2591    \u2591\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2591
+     \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591             \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591
+       \u2591\u2591\u2591\u2591\u2591\u2591\u2591                 \u2591\u2591\u2591\u2591\u2591\u2591
 
-// src/auth/hub.ts
-var HubClient = class {
-  constructor(hubUrl, fetchImpl = fetch) {
-    this.hubUrl = hubUrl;
-    this.fetchImpl = fetchImpl;
-  }
-  hubUrl;
-  fetchImpl;
-  get url() {
-    return this.hubUrl;
-  }
-  startUrl(redirectUri, challenge) {
-    const params = `redirect_uri=${encodeURIComponent(redirectUri)}&code_challenge=${encodeURIComponent(challenge)}&code_challenge_method=S256`;
-    return `${this.hubUrl}/users/social/auth/mobile/start/?${params}`;
-  }
-  async exchange(code, verifier) {
-    const body = await this.postJson("/api/auth/mobile/exchange/", {
-      code,
-      code_verifier: verifier
-    });
-    return tokenPairFrom(body);
-  }
-  async refresh(refreshToken) {
-    const body = await this.postJson("/api/auth/mobile/refresh/", {
-      refresh_token: refreshToken
-    });
-    return tokenPairFrom(body);
+  Directed helps you collaborate with AI.
+`;
+var BIND_DEADLINE_MS = 2e4;
+var READER_DRAIN_MS = 1e3;
+var HOOK_SETUP_MS = 2e3;
+var TRANSCRIPT_MISSING_NOTE = "no transcript found for this session; the terminal is recording but no messages are posting";
+function bannerWrap(command, cols, rows) {
+  const lines = BANNER.replace(/^\n+|\n+$/g, "").split("\n");
+  const width = Math.max(...lines.map((l) => l.length));
+  const left = " ".repeat(Math.max(0, Math.floor((cols - width) / 2)));
+  const top = "\n".repeat(Math.max(0, Math.floor((rows - lines.length) / 2)));
+  const centered = top + lines.map((l) => l.length > 0 ? left + l : l).join("\n");
+  return [
+    "sh",
+    "-c",
+    `clear; printf '%s
+' '${centered}'; exec "$@"`,
+    "sh",
+    ...command
+  ];
+}
+var PaneSession = class {
+  constructor(options, recording, tmux, agent, isCapturing = true) {
+    this.options = options;
+    this.recording = recording;
+    this.tmux = tmux;
+    this.agent = agent;
+    this.isCapturing = isCapturing;
   }
-  async me(accessToken) {
-    const res = await this.fetchImpl(`${this.hubUrl}/api/auth/me/`, {
-      headers: { Authorization: `Bearer ${accessToken}` }
-    });
-    if (!res.ok) {
-      throw new Error(`GET /api/auth/me/ failed: ${res.status}`);
+  options;
+  recording;
+  tmux;
+  agent;
+  isCapturing;
+  fifo = join5(tmpdir2(), `directed-${process.pid}.fifo`);
+  decoder = new StringDecoder("utf8");
+  tap = null;
+  sizeTimer = null;
+  bindTimer = null;
+  hook = null;
+  reader = null;
+  isTapped = false;
+  // The transcript this pane is reading, for capture to attach a stream to.
+  // Null when the command is not an agent directed can follow.
+  get transcript() {
+    return this.reader;
+  }
+  // Brings the pane up. Only tmux failing throws; everything else warns and the
+  // session runs with less capture than it hoped for.
+  //
+  // `running` names a conversation already going in a tmux session this launch
+  // is joining. Then nothing is started: the agent is where it was left, still
+  // writing the transcript it names, and starting a second one on the same
+  // conversation is what the vendor refuses anyway.
+  async start(running = null) {
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    const sinceMs = Date.now();
+    let command = this.options.command;
+    let isHooked = false;
+    if (this.agent && running === null) {
+      const agent = this.agent;
+      try {
+        this.hook = await TranscriptHook.open();
+        const hook = this.hook;
+        const hookArgs = await withDeadline(
+          agent.hookArgs(hook),
+          HOOK_SETUP_MS
+        );
+        if (hookArgs) {
+          command = [command[0], ...hookArgs, ...command.slice(1)];
+          isHooked = true;
+        }
+      } catch (e) {
+        process.stderr.write(
+          `[directed] transcript hook unavailable (${String(e)}); falling back to search.
+`
+        );
+      }
     }
-    const body = await res.json();
-    return {
-      publicId: body.public_id,
-      email: body.email,
-      username: body.username,
-      fullName: body.full_name
-    };
-  }
-  async sessionStart(accessToken, input2) {
-    const res = await this.fetchImpl(`${this.hubUrl}/api/terminal-sessions/`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
-      body: JSON.stringify({
-        source: input2.source,
-        title: input2.title ?? "",
-        external_ref: input2.externalRef ?? "",
-        destination_chat_public_id: input2.destinationChatPublicId ?? "",
-        member_identifiers: input2.memberIdentifiers ?? []
-      })
-    });
-    if (!res.ok) {
-      const detail = await errorDetail(res);
-      throw new Error(`POST /api/terminal-sessions/ failed: ${res.status}${detail ? ` (${detail})` : ""}`);
+    if (running === null) {
+      await this.tmux.newSession(bannerWrap(command, cols, rows), cols, rows);
     }
-    const b = await res.json();
-    return {
-      chatPublicId: b.chat_public_id,
-      terminalSessionPublicId: b.terminal_session_public_id,
-      chatUrl: b.chat_url,
-      agentActorPublicId: b.agent_actor_public_id,
-      reattached: b.reattached === true,
-      lastClientTurnId: typeof b.last_client_turn_id === "string" ? b.last_client_turn_id : "",
-      skippedMemberIdentifiers: Array.isArray(b.skipped_member_identifiers) ? b.skipped_member_identifiers : []
-    };
-  }
-  // Mint (or reuse) the chat's shareable join link. Redeeming it seats the
-  // visitor as a chat member, so it works for people outside the host's
-  // connections -- the email-invite path.
-  async chatLinkCreate(accessToken, chatPublicId) {
-    const res = await this.fetchImpl(`${this.hubUrl}/api/chats/${chatPublicId}/link/`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
-      body: "{}"
-    });
-    if (!res.ok) throw new Error(`POST /api/chats/${chatPublicId}/link/ failed: ${res.status}`);
-    const b = await res.json();
-    return b.url;
-  }
-  async chatLookup(accessToken, query) {
-    const params = new URLSearchParams({ q: query, limit: "10" });
-    const res = await this.fetchImpl(`${this.hubUrl}/api/chats/lookup/?${params.toString()}`, {
-      headers: { Authorization: `Bearer ${accessToken}` }
-    });
-    if (!res.ok) throw new Error(`GET /api/chats/lookup/ failed: ${res.status}`);
-    const body = await res.json();
-    const rows = [];
-    for (const item of body.items) {
-      rows.push({
-        publicId: item.public_id,
-        title: item.display_title,
-        url: item.chat_url
+    if (this.isCapturing && running === null) await this.captureStart();
+    if (this.agent) {
+      const agent = this.agent;
+      this.reader = new TranscriptReader(
+        agent,
+        process.cwd(),
+        sinceMs,
+        () => this.recording.mark(TRANSCRIPT_MISSING_NOTE)
+      );
+      this.reader.onRootOpen((key, path) => {
+        void this.tmux.conversationMark(agent.kind, key, path);
       });
+      if (running !== null) {
+        this.reader.fileAdd(running.path, running.key);
+      } else if (isHooked) {
+        this.reader.locateDefer();
+      }
+      this.reader.start();
+      if (running === null) this.announceBind();
     }
-    return rows;
+    this.sizeTimer = this.sizePoll();
   }
-  async sessionEnd(accessToken, sessionId) {
-    const res = await this.fetchImpl(`${this.hubUrl}/api/terminal-sessions/${sessionId}/end/`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
-      body: "{}"
-    });
-    if (!res.ok) throw new Error(`POST .../end/ failed: ${res.status}`);
+  // Install the terminal tap only after this wrapper owns hub capture. An
+  // attach-only wrapper must not replace or compete with the pipe feeding the
+  // wrapper that already owns the conversation.
+  async captureStart() {
+    if (this.isTapped) return;
+    try {
+      rmSync3(this.fifo, { force: true });
+      await exited(spawn("mkfifo", [this.fifo]));
+      this.tap = spawn("cat", [this.fifo]);
+      this.tap.stdout?.on(
+        "data",
+        (chunk) => this.recording.write(this.decoder.write(chunk))
+      );
+      await this.tmux.pipePane(this.fifo);
+      this.isTapped = true;
+    } catch (e) {
+      this.tap?.kill();
+      this.tap = null;
+      rmSync3(this.fifo, { force: true });
+      process.stderr.write(
+        `[directed] terminal recording unavailable (${String(e)}).
+`
+      );
+    }
   }
-  // Stamp the tool's own session id on a hub session that started without one
-  // (a fresh launch learns it only once the transcript file appears). Pairs a
-  // later resume of the same agent session back to the same chat.
-  async sessionRefSet(accessToken, sessionId, externalRef) {
-    const res = await this.fetchImpl(`${this.hubUrl}/api/terminal-sessions/${sessionId}/external-ref/`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
-      body: JSON.stringify({ external_ref: externalRef })
+  // Hands the terminal to the pane and waits. Returns the child's exit code.
+  async attach() {
+    return new Promise((resolve) => {
+      this.tmux.attach().on("exit", (code) => resolve(code ?? 0));
     });
-    if (!res.ok) throw new Error(`POST .../external-ref/ failed: ${res.status}`);
   }
-  async turnAppend(accessToken, sessionId, turn) {
-    const res = await this.fetchImpl(`${this.hubUrl}/api/terminal-sessions/${sessionId}/turns/`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
-      body: JSON.stringify({ role: turn.role, text: turn.text, client_turn_id: turn.clientTurnId })
-    });
-    if (!res.ok) throw new Error(`POST .../turns/ failed: ${res.status}`);
-    const b = await res.json();
-    return { messagePublicId: b.message_public_id };
+  // Whether the tmux session outlived the attach -- the person detached rather
+  // than the agent exiting. Their work is still running, so it must not be killed.
+  async isDetached() {
+    return this.tmux.hasSession();
   }
-  async chunkAppend(accessToken, sessionId, chunk) {
-    const res = await this.fetchImpl(`${this.hubUrl}/api/terminal-sessions/${sessionId}/chunks/`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
-      body: JSON.stringify({
-        seq: chunk.seq,
-        offset: chunk.offset,
-        events: chunk.events,
-        width: chunk.width,
-        height: chunk.height,
-        started_epoch: chunk.startedEpoch
-      })
-    });
-    if (!res.ok) throw new Error(`POST .../chunks/ failed: ${res.status}`);
+  async steer(text, who) {
+    await this.tmux.sendText(text, this.options.steerMode === "send");
+    this.recording.mark(`${who}: ${text}`);
+  }
+  // Unwinds everything acquired in start(), in reverse. `isDetached` decides
+  // whether the agent keeps running: killing a session someone detached from
+  // destroys work they expected to come back to.
+  async stop(isDetached) {
+    if (this.sizeTimer) clearInterval(this.sizeTimer);
+    if (this.bindTimer) clearTimeout(this.bindTimer);
+    await this.reader?.stop();
+    if (!isDetached) await this.tmux.kill();
+    if (this.tap) await tapDrain(this.tap);
+    const tail = this.decoder.end();
+    if (tail) this.recording.write(tail);
+    this.tap?.kill();
+    rmSync3(this.fifo, { force: true });
+    this.hook?.close();
+    this.recording.stop();
+    if (this.reader && !this.reader.isReading) {
+      process.stderr.write(`[directed] ${TRANSCRIPT_MISSING_NOTE}
+`);
+    }
+    if (isDetached) {
+      process.stdout.write(
+        `[directed] detached; your agent is still running. Reattach with: tmux attach -t ${this.tmux.session}
+`
+      );
+    }
   }
-  async postJson(path, payload) {
-    const res = await this.fetchImpl(`${this.hubUrl}${path}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload)
+  announceBind() {
+    const hook = this.hook;
+    const reader = this.reader;
+    if (!hook || !reader) return;
+    let isBound = false;
+    hook.onAnnounce((announced) => {
+      isBound = true;
+      reader.fileAdd(announced.transcriptPath, announced.sessionId);
     });
-    if (!res.ok) {
-      throw new Error(`POST ${path} failed: ${res.status}`);
-    }
-    return await res.json();
+    this.bindTimer = setTimeout(() => {
+      if (!isBound) reader.locateAllow();
+    }, BIND_DEADLINE_MS);
+  }
+  sizePoll() {
+    let last = "";
+    return setInterval(async () => {
+      const { cols, rows } = await this.tmux.paneSize().catch(() => ({ cols: 0, rows: 0 }));
+      if (!cols) return;
+      const key = `${cols}x${rows}`;
+      if (key !== last) {
+        last = key;
+        this.recording.resize(cols, rows);
+      }
+    }, 1e3);
   }
 };
-async function errorDetail(res) {
+function tapDrain(tap) {
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(done, READER_DRAIN_MS);
+    tap.stdout?.once("end", done);
+    tap.once("exit", done);
+  });
+}
+async function withDeadline(work, ms) {
+  let timer;
   try {
-    const body = await res.json();
-    return typeof body.detail === "string" ? body.detail : "";
-  } catch {
-    return "";
+    return await Promise.race([
+      work,
+      new Promise((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`timed out after ${ms}ms`)),
+          ms
+        );
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
   }
 }
-function tokenPairFrom(body) {
-  return {
-    access: body.access_token,
-    refresh: body.refresh_token,
-    expiresAt: Date.now() + body.expires_in * 1e3
-  };
+function exited(child) {
+  return new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on(
+      "exit",
+      (c) => c === 0 ? resolve() : reject(new Error(`exit ${c}`))
+    );
+  });
 }
 
-// src/auth/store.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname2, join as join6 } from "path";
-function authPath() {
-  const home = process.env.DIRECTED_HOME ?? homedir4();
-  return join6(home, ".directed", "auth.json");
-}
-function authLoad(hubUrl) {
+// src/tmux.ts
+import { spawn as spawn2 } from "child_process";
+var SESSION_OPTIONS = [
+  ["status", "off"],
+  ["mouse", "on"],
+  ["history-limit", "50000"]
+];
+var TAG_SOURCE = "@directed-source";
+var TAG_KEY = "@directed-key";
+var TAG_PATH = "@directed-path";
+async function conversationSession(bin, source, key, runner) {
+  const run = runner ?? defaultRunner(bin);
+  let listed;
   try {
-    const raw = readFileSync2(authPath(), "utf8");
-    const stored = JSON.parse(raw);
-    if (stored.hubUrl !== hubUrl) return null;
-    return stored;
+    listed = await run([
+      "list-sessions",
+      "-F",
+      `#{session_name}	#{${TAG_SOURCE}}	#{${TAG_KEY}}	#{${TAG_PATH}}`
+    ]);
   } catch {
     return null;
   }
-}
-function authSave(a) {
-  const path = authPath();
-  mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync3(path, JSON.stringify(a, null, 2), { mode: 384 });
-}
-function authClear() {
-  const path = authPath();
-  if (existsSync(path)) {
-    rmSync3(path);
+  for (const line of listed.split("\n")) {
+    const [name, taggedSource, taggedKey, taggedPath] = line.split("	");
+    if (taggedSource === source && taggedKey === key && name) {
+      return { session: name, path: taggedPath || null };
+    }
   }
+  return null;
 }
-
-// src/auth/login.ts
-import http from "http";
-
-// src/auth/pkce.ts
-import { createHash, randomBytes } from "crypto";
-function pkce() {
-  const verifier = randomBytes(32).toString("base64url");
-  const challenge = createHash("sha256").update(verifier).digest("base64url");
-  return { verifier, challenge };
-}
-
-// src/auth/login.ts
-var LOGIN_TIMEOUT_MS = 3e5;
-var SUCCESS_BODY = `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta name="color-scheme" content="light dark" />
-    <title>Signed in - Directed AI</title>
-    <style>
-      :root {
-        color-scheme: light dark;
-      }
-      body {
-        margin: 0;
-        min-height: 100vh;
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        font-family: system-ui, sans-serif;
-        -webkit-font-smoothing: antialiased;
-        -moz-osx-font-smoothing: grayscale;
-        background: #fff;
-        color: #1a1a1a;
-      }
-      main {
-        text-align: center;
-        padding: 0 24px;
-      }
-      img {
-        display: block;
-        margin: 0 auto 12px;
-      }
-      h1 {
-        font-size: 24px;
-        font-weight: 600;
-        letter-spacing: -0.02em;
-        margin: 0 0 8px;
-      }
-      p {
-        margin: 0;
-        color: #6b6b6b;
-      }
-      @media (prefers-color-scheme: dark) {
-        body {
-          background: #1a1a1a;
-          color: #f5f5f5;
-        }
-        p {
-          color: #a0a0a0;
-        }
-      }
-    </style>
-  </head>
-  <body>
-    <main>
-      <img
-        src="https://res.cloudinary.com/dnriuttuy/image/upload/v1761205887/dino-black-with-white-outline_nk3vhs.svg"
-        alt="Dino"
-        width="40"
-        height="40"
-      />
-      <h1>You are signed in</h1>
-      <p>You can close this tab and return to your terminal.</p>
-    </main>
-  </body>
-</html>`;
-function codeFromRequestUrl(url) {
-  const parsed = new URL(url ?? "/", "http://127.0.0.1");
-  return parsed.searchParams.get("code");
-}
-function loginFlow(hub, open3) {
-  const { verifier, challenge } = pkce();
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const server = http.createServer((req, res) => {
-      const code = codeFromRequestUrl(req.url);
-      if (!code) {
-        res.writeHead(400, { "Content-Type": "text/plain" });
-        res.end("Missing code");
-        return;
-      }
-      res.writeHead(200, { "Content-Type": "text/html" });
-      res.end(SUCCESS_BODY);
-      onCode(code);
-    });
-    const timer = setTimeout(() => {
-      settle(() => reject(new Error("Login timed out after 300s")));
-    }, LOGIN_TIMEOUT_MS);
-    function settle(run) {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timer);
-      server.close();
-      run();
-    }
-    async function onCode(code) {
-      try {
-        const tok = await hub.exchange(code, verifier);
-        const identity = await hub.me(tok.access);
-        const stored = {
-          access: tok.access,
-          refresh: tok.refresh,
-          expiresAt: tok.expiresAt,
-          identity,
-          hubUrl: hub.url
-        };
-        authSave(stored);
-        settle(() => resolve(stored));
-      } catch (err) {
-        settle(() => reject(err instanceof Error ? err : new Error(String(err))));
-      }
-    }
-    server.on("error", (err) => {
-      settle(() => reject(err));
-    });
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (address === null || typeof address === "string") {
-        settle(() => reject(new Error("Failed to determine loopback server port")));
-        return;
-      }
-      const redirectUri = `http://127.0.0.1:${address.port}/cb`;
-      open3(hub.startUrl(redirectUri, challenge));
-    });
+function defaultRunner(bin) {
+  return (args) => new Promise((resolve, reject) => {
+    const p = spawn2(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let out = "", err = "";
+    p.stdout.on("data", (d) => out += d);
+    p.stderr.on("data", (d) => err += d);
+    p.on("error", reject);
+    p.on("exit", (code) => code === 0 ? resolve(out) : reject(new Error(`tmux ${args.join(" ")} failed: ${err.trim()}`)));
   });
 }
-
-// src/auth/ensure.ts
-var EXPIRY_SKEW_MS = 6e4;
-async function ensureAuth(hub, opts) {
-  const stored = authLoad(hub.url);
-  if (stored && stored.expiresAt - EXPIRY_SKEW_MS > Date.now()) {
-    return stored.identity;
+var Tmux = class {
+  constructor(bin, session, runner) {
+    this.bin = bin;
+    this.session = session;
+    this.runner = runner ?? defaultRunner(bin);
   }
-  if (stored) {
-    try {
-      const tok = await hub.refresh(stored.refresh);
-      const identity = await hub.me(tok.access);
-      authSave({
-        access: tok.access,
-        refresh: tok.refresh,
-        expiresAt: tok.expiresAt,
-        identity,
-        hubUrl: hub.url
-      });
-      return identity;
-    } catch {
+  bin;
+  session;
+  runner;
+  inputBufferNumber = 0;
+  // Web and hub steers arrive independently; keep each paste and its submit
+  // key together so simultaneous messages cannot interleave in the pane.
+  inputWrite = Promise.resolve();
+  // Detached sessions default to 80x24 until a client attaches; sizing the
+  // pane up front means everything the child draws before attach (a resumed
+  // agent repaints its whole conversation immediately) wraps at the real
+  // terminal width, matching the recording header.
+  async newSession(command, cols, rows) {
+    await this.runner([
+      "new-session",
+      "-d",
+      "-s",
+      this.session,
+      "-x",
+      String(cols),
+      "-y",
+      String(rows),
+      "--",
+      ...command
+    ]);
+    for (const [name, value] of SESSION_OPTIONS) {
+      await this.runner(["set-option", "-t", this.session, name, value]).catch(() => "");
     }
   }
-  if (opts.autoLogin) {
-    const fresh = await loginFlow(hub, opts.open);
-    return fresh.identity;
+  // Names this pane's conversation on the tmux session itself, so a later launch
+  // can find it. tmux outlives directed -- closing the terminal kills the
+  // wrapper and leaves the agent running -- so the pane is the only place this
+  // can be written where it will still be there to read.
+  async conversationMark(source, key, path) {
+    await this.runner(["set-option", "-t", this.session, TAG_SOURCE, source]).catch(() => "");
+    await this.runner(["set-option", "-t", this.session, TAG_KEY, key]).catch(() => "");
+    await this.runner(["set-option", "-t", this.session, TAG_PATH, path]).catch(() => "");
   }
-  throw new Error("Not signed in. Run `directed login` first.");
-}
-
-// src/auth/browser.ts
-import { spawn as spawn3 } from "child_process";
-var OPENERS = {
-  darwin: (url) => ["open", [url]],
-  linux: (url) => ["xdg-open", [url]],
-  win32: (url) => ["cmd", ["/c", "start", "", url]]
-};
-function openBrowser(url) {
-  const opener = OPENERS[process.platform];
-  if (!opener) {
-    return;
+  async paneSize() {
+    const out = (await this.runner(["display-message", "-p", "-t", this.session, "#{pane_width}x#{pane_height}"])).trim();
+    const [cols, rows] = out.split("x").map(Number);
+    return { cols, rows };
   }
-  const [command, args] = opener(url);
-  try {
-    const child = spawn3(command, args, { detached: true, stdio: "ignore" });
-    child.on("error", () => {
+  pipePane(fifo) {
+    return this.runner(["pipe-pane", "-t", this.session, `cat >> ${fifo}`]).then(() => {
     });
-    child.unref();
-  } catch {
   }
-}
-
-// src/auth/token-refresher.ts
-var EXPIRY_SKEW_MS2 = 6e4;
-var TokenRefresher = class {
-  constructor(hub, stored) {
-    this.hub = hub;
-    this.stored = stored;
+  sendText(text, submit) {
+    const write = this.inputWrite.then(() => this.textWrite(text, submit));
+    this.inputWrite = write.catch(() => {
+    });
+    return write;
   }
-  hub;
-  stored;
-  refreshing = null;
-  async current() {
-    if (this.stored.expiresAt - EXPIRY_SKEW_MS2 > Date.now()) {
-      return this.stored.access;
-    }
-    return this.refreshNow();
+  // A person who scrolled is in copy-mode, and a pane in copy-mode swallows the
+  // paste and keeps the Enter: the steer never reaches the agent, and the next
+  // one runs into it as one garbled line. Leaving copy-mode costs a scroll
+  // position; staying in it costs the message.
+  async modeExit() {
+    const mode = await this.runner([
+      "display-message",
+      "-p",
+      "-t",
+      this.session,
+      "#{pane_in_mode}"
+    ]);
+    if (mode.trim() !== "1") return;
+    await this.runner(["send-keys", "-X", "-t", this.session, "cancel"]);
   }
-  // Unconditionally refreshes (deduped against a concurrent call), for when
-  // the server has already said the token is bad -- a 401, or a chat-socket
-  // close code 4002 -- regardless of what our local clock thinks.
-  async refreshNow() {
-    if (!this.refreshing) {
-      this.refreshing = this.refresh();
-    }
-    try {
-      return await this.refreshing;
-    } finally {
-      this.refreshing = null;
-    }
+  async textWrite(text, submit) {
+    await this.modeExit().catch(() => {
+    });
+    const buffer = `${this.session}-input-${this.inputBufferNumber}`;
+    this.inputBufferNumber += 1;
+    await this.runner(["set-buffer", "-b", buffer, "--", text]);
+    await this.runner(["paste-buffer", "-dpr", "-b", buffer, "-t", this.session]);
+    if (submit) await this.runner(["send-keys", "-t", this.session, "Enter"]);
+  }
+  async hasSession() {
+    return this.runner(["has-session", "-t", this.session]).then(() => true).catch(() => false);
   }
-  async refresh() {
-    const tok = await this.hub.refresh(this.stored.refresh);
-    this.stored = { ...this.stored, access: tok.access, refresh: tok.refresh, expiresAt: tok.expiresAt };
-    authSave(this.stored);
-    return this.stored.access;
+  attach() {
+    return spawn2(this.bin, ["attach", "-t", this.session], { stdio: "inherit" });
+  }
+  kill() {
+    return this.runner(["kill-session", "-t", this.session]).then(() => {
+    }).catch(() => {
+    });
   }
 };
 
-// src/chat-target.ts
-import { createInterface } from "readline/promises";
-import { stdin as input, stdout as output } from "process";
-var DEFAULT_TERMINAL = { input, output };
-function chatTargetChoice(answer, count) {
-  const value = Number(answer.trim());
-  if (!Number.isInteger(value) || value < 1 || value > count) return null;
-  return value;
+// src/update.ts
+import { mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, readFileSync as readFileSync2, rmSync as rmSync4, writeFileSync as writeFileSync2 } from "fs";
+import { spawnSync } from "child_process";
+import { homedir as homedir4, tmpdir as tmpdir3 } from "os";
+import { dirname as dirname3, join as join6 } from "path";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function statePath() {
+  const home = process.env.DIRECTED_HOME ?? homedir4();
+  return join6(home, ".directed", "state.json");
 }
-function chatTargetPublicId(value) {
-  const trimmed = value.trim();
+function stateLoad() {
   try {
-    const url = new URL(trimmed);
-    const match = url.pathname.match(/\/chat\/([^/]+)\/?$/);
-    return match ? decodeURIComponent(match[1]) : trimmed;
+    return JSON.parse(readFileSync2(statePath(), "utf8"));
   } catch {
-    return trimmed;
-  }
-}
-function chatTargetExact(query, chatList) {
-  const publicId = chatTargetPublicId(query);
-  return chatList.some((chat) => chat.publicId === publicId) ? publicId : null;
-}
-function chatTargetMenu(chatList) {
-  const lines = ["", "Recent Directed chats:"];
-  for (const [index, chat] of chatList.entries()) {
-    lines.push(`${index + 1}. ${chat.title}`);
-    lines.push(`   ${chat.url}`);
+    return null;
   }
-  return `${lines.join("\n")}
-`;
 }
-async function chatTargetPick(hub, accessToken, query, terminal = DEFAULT_TERMINAL) {
-  let prompt = null;
+function stateSave(state) {
   try {
-    const search = query.trim();
-    if (search) {
-      const chats2 = await hub.chatLookup(accessToken, search);
-      const exactPublicId = chatTargetExact(search, chats2);
-      if (exactPublicId) return exactPublicId;
-      throw new Error("--into=<value> must resolve to an exact Directed chat URL or public id");
-    }
-    if (!terminal.input.isTTY || !terminal.output.isTTY) {
-      throw new Error("--into needs an interactive terminal; use --into=<Directed chat URL or exact public id>");
-    }
-    const chats = await hub.chatLookup(accessToken, "");
-    if (chats.length === 0) {
-      throw new Error("No recent chats available; run without --into to start a new chat");
-    }
-    prompt = createInterface({ input: terminal.input, output: terminal.output });
-    terminal.output.write(chatTargetMenu(chats));
-    const answer = await prompt.question(`Choose a chat [1-${chats.length}]: `);
-    const choice = chatTargetChoice(answer, chats.length);
-    if (choice === null) throw new Error("Choose a listed chat number");
-    return chats[choice - 1].publicId;
-  } finally {
-    prompt?.close();
+    const path = statePath();
+    mkdirSync2(dirname3(path), { recursive: true });
+    writeFileSync2(path, JSON.stringify(state));
+  } catch {
   }
 }
-
-// src/cli.ts
-var require2 = createRequire(import.meta.url);
-var CLI_VERSION = require2("../package.json").version;
-function helpText() {
-  return `directed - run an interactive coding agent in a Directed chat
-
-Usage:
-  directed [options] <command> [args...]
-  directed login
-  directed logout
-  directed upgrade
-
-Options:
-  --accept-mode <send|stage> Submit chat steers immediately or stage them
-  --chat                     Stream the session to a Directed chat
-  --no-chat                  Do not stream the session to a Directed chat
-  --into[=<URL or public id>] Choose a recent chat or give an exact target
-  --with <people>            Add @usernames or emails to the session chat
-  --invite <emails>          Open an email draft with the chat join link
-  --open                     Open the session chat in a browser
-  --no-open                  Do not open the session chat in a browser
-  --name <label>             Set the session label
-  --tmux-bin <path>          Use a specific tmux executable
-  -h, --help                 Show this help
-
-Everything after <command> is passed to that command unchanged.
-
-Examples:
-  directed codex
-  directed --with @jane claude
-  directed codex --help`;
-}
-function isHelpRequest(argv) {
-  return argv[0] === "--help" || argv[0] === "-h";
-}
-function asMode(v) {
-  if (v !== "send" && v !== "stage") throw new Error(`--accept-mode must be 'send' or 'stage', got '${v}'`);
-  return v;
+function versionIsNewer(latest, current) {
+  const a = latest.split(".").map(Number);
+  const b = current.split(".").map(Number);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    if (x !== y) return x > y;
+  }
+  return false;
 }
-function commandSplit(argv) {
-  let acceptMode = DEFAULTS.acceptMode;
-  let sessionName = "", tmuxBin = DEFAULTS.tmuxBin, openOnStart = DEFAULTS.openOnStart, invitees = DEFAULTS.invitees, inviteEmails = DEFAULTS.inviteEmails;
-  let toChatFlag;
-  let chatTargetQuery = null;
-  let i = 0;
-  while (i < argv.length) {
-    const a = argv[i];
-    if (a === "--accept-mode") {
-      acceptMode = asMode(argv[i + 1]);
-      i += 2;
-    } else if (a === "--name") {
-      sessionName = argv[i + 1];
-      i += 2;
-    } else if (a === "--tmux-bin") {
-      tmuxBin = argv[i + 1];
-      i += 2;
-    } else if (a === "--chat") {
-      toChatFlag = true;
-      i += 1;
-    } else if (a === "--no-chat") {
-      toChatFlag = false;
-      i += 1;
-    } else if (a === "--into") {
-      chatTargetQuery = "";
-      i += 1;
-    } else if (a.startsWith("--into=")) {
-      chatTargetQuery = a.slice("--into=".length);
-      i += 1;
-    } else if (a === "--open") {
-      openOnStart = true;
-      i += 1;
-    } else if (a === "--no-open") {
-      openOnStart = false;
-      i += 1;
-    } else if (a === "--with") {
-      invitees = (argv[i + 1] ?? "").split(",").map((e) => e.trim()).filter(Boolean);
-      i += 2;
-    } else if (a === "--invite") {
-      inviteEmails = (argv[i + 1] ?? "").split(",").map((e) => e.trim()).filter(Boolean);
-      for (const email of inviteEmails) {
-        if (!email.includes("@") || email.startsWith("@")) {
-          throw new Error(`--invite takes emails only, got '${email}' (use --with for @usernames)`);
-        }
+async function updateCheck(currentVersion, hubUrl, note, fetchImpl = fetch) {
+  const cached = stateLoad();
+  const now = Date.now();
+  let latest = cached?.latestKnownVersion;
+  if (!cached || now - cached.lastCheckedAt > CHECK_INTERVAL_MS) {
+    try {
+      const res = await fetchImpl(`${hubUrl}/cli/version`, { signal: AbortSignal.timeout(1500) });
+      if (res.ok) {
+        latest = (await res.json()).version;
+        stateSave({ lastCheckedAt: now, latestKnownVersion: latest });
       }
-      i += 2;
-    } else if (a.startsWith("-")) {
-      throw new Error(`unknown directed option '${a}'; run 'directed --help'`);
-    } else {
-      break;
+    } catch {
     }
   }
-  const command = argv.slice(i);
-  if (command.length === 0) throw new Error("usage: directed [flags] <command> [args...]");
-  const toChat = toChatFlag ?? sourceFor(command) !== null;
-  const chatTitle = sessionName;
-  if (!sessionName) sessionName = command.join(" ");
-  return {
-    command,
-    acceptMode,
-    sessionName,
-    chatTitle,
-    tmuxBin,
-    hubUrl: DEFAULTS.hubUrl,
-    toChat,
-    chatTargetQuery,
-    openOnStart,
-    invitees,
-    inviteEmails
-  };
-}
-function inviteMailto(emails, joinUrl, hostName) {
-  const subject = `${hostName} invited you to a live Directed session`;
-  const body = [
-    "Hi,",
-    "",
-    "I'm running a live coding session and want you in the chat -- follow along and jump in here:",
-    "",
-    joinUrl,
-    "",
-    "See you there,",
-    hostName
-  ].join("\n");
-  return `mailto:${emails.join(",")}?subject=${encodeURIComponent(subject)}&body=${encodeURIComponent(body)}`;
-}
-async function inviteDraftOpen(hub, hubChat, emails, hostName) {
-  try {
-    const token = await hubChat.tokenRefresher.current();
-    const joinUrl = await hub.chatLinkCreate(token, hubChat.chatId);
-    process.stdout.write(`[directed] join link: ${joinUrl}
-[directed] opening mail draft to: ${emails.join(", ")}
-`);
-    openBrowser(inviteMailto(emails, joinUrl, hostName));
-  } catch (err) {
-    process.stderr.write(`[directed] could not prepare the email invite (${err.message}); invite them from the chat instead.
-`);
+  if (latest && versionIsNewer(latest, currentVersion)) {
+    note(`a new version is available (${currentVersion} -> ${latest}). Run 'directed upgrade' to update.`);
   }
 }
-async function hubChatStart(hub, config, conversation, echoGuard, externalRef, destinationChatPublicId, recorder) {
-  const source = sourceFor(config.command);
-  if (!source) {
-    process.stderr.write("[directed] chat streaming only works for claude and codex sessions; this tool has no transcript, skipping the chat.\n");
-    return null;
-  }
-  const stored = authLoad(config.hubUrl);
-  if (!stored) {
-    process.stderr.write("[directed] no signed-in session; run 'directed login' to stream this session to a chat. Continuing without one.\n");
-    return null;
+async function updateInstall(hubUrl, fetchImpl = fetch) {
+  const scriptUrl = `${hubUrl}/cli/install.sh`;
+  process.stdout.write(`[directed] fetching installer from ${scriptUrl}
+`);
+  const res = await fetchImpl(scriptUrl);
+  if (!res.ok) {
+    console.error(`[directed] could not fetch installer: ${res.status} ${res.statusText}`);
+    return 1;
   }
-  const tokenRefresher = new TokenRefresher(hub, stored);
-  const who = stored.identity.fullName || stored.identity.username;
-  const chat = new HubTransport(
-    hub,
-    tokenRefresher,
-    source,
-    conversation,
-    config.chatTitle,
-    echoGuard,
-    externalRef,
-    destinationChatPublicId,
-    config.invitees,
-    (text) => recorder.marker(`${who}: ${text}`)
-  );
+  const script = await res.text();
+  const dir = mkdtempSync2(join6(tmpdir3(), "directed-upgrade-"));
   try {
-    const url = await chat.start();
-    const sessionId = chat.sessionId;
-    const chatId = chat.chatId;
-    const agentActorId = chat.agentActorId;
-    if (sessionId === null || chatId === null || agentActorId === null) {
-      throw new Error("terminal session ids missing after start");
-    }
-    const verb = chat.reattached ? "re-attached this session to its chat" : "streaming this session to a chat";
-    process.stdout.write(`[directed] ${verb}: ${url}
-`);
-    if (chat.skippedInvitees.length > 0) {
-      process.stderr.write(`[directed] not added (not your active connections): ${chat.skippedInvitees.join(", ")}
-`);
-    }
-    if (config.openOnStart) setTimeout(() => openBrowser(url), SPLASH_MS);
-    return { transport: chat, sessionId, chatId, agentActorId, tokenRefresher };
-  } catch (err) {
-    process.stderr.write(`[directed] could not open the chat (${err.message}); continuing locally.
-`);
-    return null;
+    const scriptPath = join6(dir, "install.sh");
+    writeFileSync2(scriptPath, script, { mode: 493 });
+    const result = spawnSync("bash", [scriptPath], {
+      stdio: "inherit",
+      env: { ...process.env, DIRECTED_CLI_BASE_URL: hubUrl }
+    });
+    return result.status ?? 1;
+  } finally {
+    rmSync4(dir, { recursive: true, force: true });
   }
 }
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var CLI_VERSION = require2("../package.json").version;
 async function main(argv = process.argv.slice(2)) {
   if (isHelpRequest(argv)) {
     process.stdout.write(`${helpText()}
 `);
     return 0;
   }
-  if (argv[0] === "upgrade") {
-    return upgradeRun(DEFAULTS.hubUrl);
-  }
-  await updateCheckRun(CLI_VERSION, DEFAULTS.hubUrl);
+  if (argv[0] === "__hook") return hookRun();
+  if (argv[0] === "upgrade") return updateInstall(HUB_URL);
   if (argv[0] === "login") {
-    const hub2 = new HubClient(DEFAULTS.hubUrl);
-    const auth = await loginFlow(hub2, openBrowser);
-    process.stdout.write(`[directed] signed in as ${auth.identity.email}
-`);
+    const state = await authLogin(new Hub(), browserOpen);
+    process.stdout.write(
+      `[directed] signed in as ${state.identity.email} (${HUB_URL})
+`
+    );
     return 0;
   }
   if (argv[0] === "logout") {
-    authClear();
-    process.stdout.write(`[directed] signed out
+    authClear(HUB_URL);
+    process.stdout.write(`[directed] signed out of ${HUB_URL}
+`);
+    return 0;
+  }
+  if (argv[0] === "whoami") {
+    const state = authLoad(HUB_URL);
+    if (state === null) {
+      process.stdout.write(
+        `[directed] signed out (${HUB_URL}); run '${binName()} login'
+`
+      );
+      return 1;
+    }
+    process.stdout.write(`[directed] ${state.identity.email} (${HUB_URL})
 `);
     return 0;
   }
-  const config = commandSplit(argv);
-  const hub = new HubClient(config.hubUrl);
-  let identity;
+  const options = optionsParse(argv);
   try {
-    identity = await ensureAuth(hub, { autoLogin: true, open: openBrowser });
-  } catch (err) {
-    console.error(`[directed] ${err.message}`);
+    execFileSync(options.tmuxBin, ["-V"], { stdio: "ignore" });
+  } catch {
+    console.error(
+      "directed needs tmux on PATH (or pass --tmux-bin <path>). Install it, e.g. 'brew install tmux'."
+    );
     return 1;
   }
-  process.stdout.write(`[directed] signed in as ${identity.email}
+  return sessionRun(options);
+}
+async function sessionRun(options) {
+  const hub = new Hub();
+  const agent = agentResolve(options.command);
+  const auth = authSessionLoad(hub);
+  const isCapturing = options.chatEnabled && agent !== null && auth !== null;
+  let localOnly = null;
+  if (options.chatEnabled && agent === null) {
+    localOnly = "chat streaming only works for claude and codex sessions; this tool has no transcript.";
+  } else if (options.chatEnabled && auth === null) {
+    localOnly = `not signed in to ${HUB_URL}; run '${binName()} login' to share a session.`;
+  }
+  if (localOnly !== null)
+    process.stderr.write(`[directed] ${localOnly} Running locally.
 `);
-  let destinationChatPublicId = null;
-  if (config.toChat && config.chatTargetQuery !== null) {
-    const stored = authLoad(config.hubUrl);
-    if (!stored) {
-      console.error("[directed] signed-in token missing after authentication");
-      return 1;
-    }
+  let chatPublicId2 = null;
+  if (isCapturing && options.chatTarget.kind !== "new") {
     try {
-      const token = await new TokenRefresher(hub, stored).current();
-      destinationChatPublicId = await chatTargetPick(hub, token, config.chatTargetQuery);
-    } catch (err) {
-      console.error(`[directed] could not choose a chat target: ${err.message}`);
+      hub.authAttach(auth);
+      chatPublicId2 = await chatPick(hub, options.chatTarget);
+    } catch (e) {
+      console.error(`[directed] ${e.message}`);
       return 1;
     }
   }
-  try {
-    execFileSync(config.tmuxBin, ["-V"], { stdio: "ignore" });
-  } catch {
-    console.error(`directed needs tmux on PATH (or pass --tmux-bin <path>). Install it, e.g. 'brew install tmux'.`);
-    return 1;
-  }
   const cols = process.stdout.columns || 80;
   const rows = process.stdout.rows || 24;
-  const conversation = new ConversationLog();
-  const recorder = new Recorder(cols, rows);
-  const adapter = adapterFor(config.command);
-  const tmux = new Tmux(config.tmuxBin, `directed-${randomBytes2(4).toString("hex")}`);
-  const echoGuard = config.toChat ? new EchoGuard() : null;
-  const resumeRef = config.toChat && adapter ? await adapter.resumeRef(config.command, process.cwd()) : null;
-  const hubChat = config.toChat ? await hubChatStart(hub, config, conversation, echoGuard, resumeRef, destinationChatPublicId, recorder) : null;
-  if (config.inviteEmails.length > 0) {
-    if (hubChat) {
-      await inviteDraftOpen(hub, hubChat, config.inviteEmails, identity.fullName || identity.username);
-    } else {
-      process.stderr.write("[directed] --invite needs a hub chat; no invite sent.\n");
+  const recording = new Recording(cols, rows);
+  const running = agent === null ? null : await runningFind(agent, options);
+  const tmux = new Tmux(
+    options.tmuxBin,
+    running?.session ?? `directed-${randomBytes3(4).toString("hex")}`
+  );
+  const pane = new PaneSession(
+    options,
+    recording,
+    tmux,
+    isCapturing ? agent : null,
+    isCapturing
+  );
+  await pane.start(running?.pane ?? null);
+  const held = [];
+  let isTerminalFree = false;
+  const note = (text) => {
+    recording.mark(`directed: ${text}`);
+    if (isTerminalFree) process.stderr.write(`[directed] ${text}
+`);
+    else held.push(text);
+  };
+  void updateCheck(CLI_VERSION, HUB_URL, note);
+  const captureAbort = new AbortController();
+  const capturing = isCapturing && auth !== null && agent !== null ? captureStart(
+    hub,
+    auth,
+    agent,
+    options,
+    recording,
+    pane,
+    chatPublicId2,
+    note,
+    running !== null,
+    captureAbort.signal
+  ) : Promise.resolve(null);
+  try {
+    return await pane.attach();
+  } finally {
+    const isDetached = await pane.isDetached();
+    captureAbort.abort();
+    const capture = await capturing;
+    await pane.stop(isDetached);
+    isTerminalFree = true;
+    for (const text of held) process.stderr.write(`[directed] ${text}
+`);
+    held.length = 0;
+    if (capture) await capture.stop(isDetached);
+    if (localOnly !== null) process.stderr.write(`[directed] ${localOnly}
+`);
+  }
+}
+async function runningFind(agent, options) {
+  const key = await agent.resumeKey(options.command, process.cwd());
+  if (key === null) return null;
+  const found = await conversationSession(options.tmuxBin, agent.kind, key);
+  if (found === null) return null;
+  const path = found.path ?? await agent.transcriptPath(key);
+  if (path === null) return null;
+  return { session: found.session, pane: { key, path } };
+}
+function binName() {
+  return basename4(process.argv[1] ?? "directed");
+}
+async function captureStart(hub, auth, agent, options, recording, pane, chatPublicId2, note, shouldRetryHeld, signal) {
+  const reader = pane.transcript;
+  if (reader === null) return null;
+  const gitStart = await gitSnapshot(process.cwd());
+  const resumeKey = await agent.resumeKey(options.command, process.cwd());
+  let isHeldReported = false;
+  while (!signal.aborted) {
+    try {
+      hub.authAttach(auth);
+      const capture = await Capture.start(
+        hub,
+        auth,
+        recording,
+        reader,
+        {
+          source: agent.kind,
+          title: options.title,
+          resumeKey,
+          chatPublicId: chatPublicId2,
+          memberList: options.chatMembers,
+          gitStart
+        },
+        note
+      );
+      if (capture === null) return null;
+      await pane.captureStart();
+      note(
+        capture.reattached ? `re-attached to its chat: ${capture.chatUrl}` : `streaming to a chat: ${capture.chatUrl}`
+      );
+      if (capture.skippedMemberList.length > 0) {
+        note(
+          `not added (not your active connections): ${capture.skippedMemberList.join(", ")}`
+        );
+      }
+      if (options.chatOpen) browserOpen(capture.chatUrl);
+      if (options.chatInviteEmails.length > 0) {
+        const mailto = await chatInvite(
+          () => capture.linkCreate(),
+          options.chatInviteEmails,
+          auth.identity.fullName || auth.identity.username,
+          note
+        );
+        if (mailto) browserOpen(mailto);
+      }
+      capture.steerListen(async (steer) => {
+        await pane.steer(steer.text, steer.author);
+        return options.steerMode === "send" ? "sent" : "staged";
+      });
+      return capture;
+    } catch (e) {
+      if (e instanceof TerminalHeldError && shouldRetryHeld) {
+        if (!isHeldReported) {
+          isHeldReported = true;
+          note(
+            `this conversation is already connected: ${e.chatUrl}. This terminal is attached without replacing its capture.`
+          );
+        }
+        if (!await retryWait(signal)) return null;
+        continue;
+      }
+      if (e instanceof TerminalHeldError) {
+        note(
+          `this conversation is already connected: ${e.chatUrl}. Messages there reach it through the run that has it.`
+        );
+        return null;
+      }
+      note(
+        `could not start capture (${e.message}); this session stays local.`
+      );
+      return null;
     }
   }
-  const mentions = hubChat ? new HubMentions(config.hubUrl, hubChat.tokenRefresher, hubChat.chatId, hubChat.agentActorId, Date.now()) : null;
-  const refStamp = hubChat && adapter && !resumeRef ? (file) => {
-    const ref = adapter.refFromPath(file);
-    if (!ref) return;
-    hubChat.tokenRefresher.current().then((token) => hub.sessionRefSet(token, hubChat.sessionId, ref)).catch((e) => {
-      process.stderr.write(`terminal session ref post failed: ${String(e)}
-`);
+  return null;
+}
+function retryWait(signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve(false);
+      return;
+    }
+    const timer = setTimeout(() => finish(true), 5e3);
+    const abort = () => finish(false);
+    signal.addEventListener("abort", abort, { once: true });
+    function finish(shouldRetry) {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", abort);
+      resolve(shouldRetry);
+    }
+  });
+}
+function authSessionLoad(hub) {
+  const state = authLoad(hub.url);
+  return state === null ? null : new AuthSession(hub, state);
+}
+var OPENERS = {
+  darwin: (url) => ["open", [url]],
+  linux: (url) => ["xdg-open", [url]],
+  win32: (url) => ["cmd", ["/c", "start", "", url]]
+};
+function browserOpen(url) {
+  const opener = OPENERS[process.platform];
+  if (!opener) {
+    return;
+  }
+  const [command, args] = opener(url);
+  try {
+    const child = spawn3(command, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
     });
-  } : null;
-  const session = new Session(config, conversation, recorder, tmux, adapter, mentions, echoGuard, refStamp);
-  const recording = hubChat ? new HubRecordingPublisher(hub, hubChat.tokenRefresher, hubChat.sessionId, recorder) : null;
-  recording?.start();
-  const code = await session.run();
-  if (recording) await recording.stop();
-  if (hubChat) await hubChat.transport.stop();
-  return code;
+    child.unref();
+  } catch {
+    return;
+  }
 }
 var argv1 = process.argv[1] ? realpathSync(process.argv[1]) : "";
 if (import.meta.url === pathToFileURL(argv1).href) {
@@ -1930,9 +3158,5 @@ if (import.meta.url === pathToFileURL(argv1).href) {
   });
 }
 export {
-  commandSplit,
-  helpText,
-  inviteMailto,
-  isHelpRequest,
   main
 };