@directed/cli 0.1.3 → 0.1.4

package/dist/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { realpathSync } from "fs";
+import { realpathSync as realpathSync2 } from "fs";
 import { basename as basename4 } from "path";
 import { pathToFileURL } from "url";
 import { randomBytes as randomBytes3 } from "crypto";
-import { execFileSync, spawn as spawn3 } from "child_process";
-import { createRequire } from "module";
+import { execFileSync, spawn as spawn2 } from "child_process";
+import { createRequire as createRequire2 } from "module";
 
 // src/agent.ts
 import { basename as basename3 } from "path";
@@ -666,12 +666,15 @@ function commaList(value) {
 }
 
 // src/hub.ts
+import { createRequire } from "module";
 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 require2 = createRequire(import.meta.url);
+var CLI_VERSION = require2("../package.json").version;
 var TIMEOUT_MS = 15e3;
 var UPLOAD_TIMEOUT_MS = 6e4;
 var HubError = class extends Error {
@@ -688,6 +691,12 @@ var HubError = class extends Error {
     return this.status >= 400 && this.status < 500 && this.status !== 408 && this.status !== 429;
   }
 };
+var AuthenticationRequiredError = class extends HubError {
+  constructor(detail) {
+    super(detail, 401);
+    this.name = "AuthenticationRequiredError";
+  }
+};
 var TerminalHeldError = class extends HubError {
   constructor(chatUrl) {
     super("this conversation is already connected", 409);
@@ -696,6 +705,14 @@ var TerminalHeldError = class extends HubError {
   }
   chatUrl;
 };
+var UpgradeRequiredError = class extends HubError {
+  constructor(detail, minimumVersion) {
+    super(detail, 426);
+    this.minimumVersion = minimumVersion;
+    this.name = "UpgradeRequiredError";
+  }
+  minimumVersion;
+};
 var Hub = class {
   constructor(url = HUB_URL, fetchImpl = fetch) {
     this.url = url;
@@ -770,20 +787,25 @@ var Hub = class {
   async terminalCreate(input2) {
     const response = await this.request("/api/terminal-sessions/", {
       method: "POST",
-      expect: [409],
+      expect: [409, 426],
       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)
+        git_start: gitSnapshotWire(input2.gitStart),
+        client_version: CLI_VERSION
       }
     });
     if (response.status === 409) {
       const held = await response.json();
       throw new TerminalHeldError(held.chat_url);
     }
+    if (response.status === 426) {
+      const stale = await response.json();
+      throw new UpgradeRequiredError(stale.detail, stale.minimum_version);
+    }
     const body = await response.json();
     return {
       chatPublicId: body.chat_public_id,
@@ -800,7 +822,6 @@ var Hub = class {
       method: "POST",
       json: {
         transcript_lost: state.transcriptLost,
-        recording_lost: state.recordingLost,
         detached: state.isDetached,
         git_end: gitSnapshotWire(state.gitEnd)
       }
@@ -816,9 +837,9 @@ var Hub = class {
     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.
+  // lines. Compressed: transcripts are JSON text and shrink about 5x. 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",
@@ -836,19 +857,6 @@ var Hub = class {
       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) {
@@ -868,15 +876,31 @@ var Hub = class {
   // 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));
+    let token;
+    try {
+      token = await this.tokenFor(spec);
+    } catch (error) {
+      if (spec.token === void 0 && this.auth !== null) {
+        authenticationRequired(error);
+      }
+      throw error;
+    }
+    const response = await this.send(path, spec, token);
     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
-    );
+    let refreshedToken;
+    try {
+      refreshedToken = await this.auth.refresh();
+    } catch (error) {
+      authenticationRequired(error);
+    }
+    const retried = await this.send(path, spec, refreshedToken);
+    try {
+      return await this.checked(path, retried, spec.expect);
+    } catch (error) {
+      authenticationRequired(error);
+    }
   }
   async tokenFor(spec) {
     if (spec.token !== void 0) return spec.token;
@@ -919,6 +943,12 @@ var Hub = class {
     );
   }
 };
+function authenticationRequired(error) {
+  if (error instanceof HubError && error.status === 401) {
+    throw new AuthenticationRequiredError(error.message);
+  }
+  throw error;
+}
 function gitSnapshotWire(snapshot) {
   if (!snapshot) return null;
   return {
@@ -942,6 +972,57 @@ import { existsSync, mkdirSync, readFileSync, rmSync as rmSync2, writeFileSync }
 import http from "http";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname2, join as join4 } from "path";
+
+// src/prompt.ts
+import { stdin, stderr } from "process";
+var PROMPT_TERMINAL = { input: stdin, output: stderr };
+var PromptCancelledError = class extends Error {
+  constructor() {
+    super("cancelled");
+    this.name = "PromptCancelledError";
+  }
+};
+function promptIsInteractive(terminal = PROMPT_TERMINAL) {
+  return terminal.input.isTTY === true && terminal.output.isTTY === true && typeof terminal.input.setRawMode === "function";
+}
+function promptAction(action, hasColors) {
+  const line = `> ${action}`;
+  return hasColors ? `\x1B[1;36m${line}\x1B[0m` : line;
+}
+function promptConfirm(title, action, terminal = PROMPT_TERMINAL) {
+  if (!promptIsInteractive(terminal)) {
+    throw new Error("an interactive terminal is required to continue");
+  }
+  const input2 = terminal.input;
+  const wasRaw = input2.isRaw === true;
+  terminal.output.write(
+    `${title}
+
+${promptAction(action, terminal.output.hasColors?.() === true)}
+`
+  );
+  return new Promise((resolve, reject) => {
+    function finish(run) {
+      input2.removeListener("data", keyRead);
+      input2.setRawMode?.(wasRaw);
+      input2.pause();
+      run();
+    }
+    function keyRead(chunk) {
+      const text = chunk.toString();
+      if (text.includes("")) {
+        finish(() => reject(new PromptCancelledError()));
+      } else if (text.includes("\r") || text.includes("\n")) {
+        finish(resolve);
+      }
+    }
+    input2.setRawMode?.(true);
+    input2.resume();
+    input2.on("data", keyRead);
+  });
+}
+
+// src/auth.ts
 var EXPIRY_SKEW_MS = 6e4;
 var LOGIN_TIMEOUT_MS = 3e5;
 function authPath(hubUrl) {
@@ -968,6 +1049,14 @@ function authClear(hubUrl) {
   const path = authPath(hubUrl);
   if (existsSync(path)) rmSync2(path);
 }
+async function authPrompt(hub, open3, terminal) {
+  await promptConfirm(
+    `[directed] Sign in to ${hub.url} to share this session.`,
+    "Press Enter to sign in and continue. Ctrl-C to exit.",
+    terminal
+  );
+  return authLogin(hub, open3);
+}
 var AuthSession = class {
   constructor(hub, state) {
     this.hub = hub;
@@ -1223,6 +1312,9 @@ async function chatInvite(linkCreate, emails, hostName, note) {
 import { execFile } from "child_process";
 import { promisify as promisify2 } from "util";
 
+// src/transcript.ts
+import { open as open2, stat as stat3 } from "fs/promises";
+
 // src/outbox.ts
 var BACKOFF_MS = [500, 1500, 4e3, 1e4];
 var BYTES_MAX_DEFAULT = 32 * 1024 * 1024;
@@ -1349,157 +1441,7 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// 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;
-  get header() {
-    return { width: this.headerWidth, height: this.headerHeight, startedEpoch: this.startedEpoch };
-  }
-  // Events the pane produced that no stream ever took.
-  get droppedEventCount() {
-    return this.droppedCount;
-  }
-  write(data) {
-    this.append([this.elapsed(), "o", data]);
-  }
-  mark(label) {
-    this.append([this.elapsed(), "m", label]);
-  }
-  // 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.
-  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(event);
-  }
-  // 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();
-  }
-  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/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;
@@ -1782,8 +1724,8 @@ var TranscriptReader = class {
     }
   }
 };
-var FLUSH_INTERVAL_MS2 = 250;
-var FLUSH_BYTES_MAX2 = 512 * 1024;
+var FLUSH_INTERVAL_MS = 250;
+var FLUSH_BYTES_MAX = 512 * 1024;
 var FLUSH_LINES_MAX = 100;
 var TranscriptStream = class {
   constructor(session, reader) {
@@ -1843,12 +1785,12 @@ var TranscriptStream = class {
     }
     buffer.lines.push(text);
     buffer.bytes += Buffer.byteLength(text, "utf8") + 1;
-    if (buffer.bytes >= FLUSH_BYTES_MAX2 || buffer.lines.length >= FLUSH_LINES_MAX) {
+    if (buffer.bytes >= FLUSH_BYTES_MAX || buffer.lines.length >= FLUSH_LINES_MAX) {
       this.flushOne(key);
       return;
     }
     if (!this.timer) {
-      this.timer = setTimeout(() => this.flush(), FLUSH_INTERVAL_MS2);
+      this.timer = setTimeout(() => this.flush(), FLUSH_INTERVAL_MS);
       this.timer.unref();
     }
   }
@@ -2129,11 +2071,10 @@ 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) {
+  constructor(note, session, reader, 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;
@@ -2143,7 +2084,6 @@ var Capture = class _Capture {
   note;
   session;
   reader;
-  recordingStream;
   transcriptStream;
   steering;
   chatUrl;
@@ -2153,28 +2093,19 @@ var Capture = class _Capture {
   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;
-    }
-    const recordingStream = new RecordingStream(session, recording);
+  // Binds an already-open chat to what the pane is now producing.
+  //
+  // Opening is separate and happens first, before tmux owns the screen: every
+  // reason a chat cannot be opened -- signed out, too old for this hub, hub
+  // unreachable -- is a question for the person, and by here there is nowhere
+  // left to ask it.
+  static attach(session, auth, reader, note) {
     const transcriptStream = new TranscriptStream(session, reader);
     const steering = new Steering(session, auth);
     const capture = new _Capture(
       note,
       session,
       reader,
-      recordingStream,
       transcriptStream,
       steering,
       session.chatUrl,
@@ -2191,9 +2122,9 @@ var Capture = class _Capture {
   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.
+  // Stop the producers, drain the stream 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;
@@ -2202,14 +2133,10 @@ var Capture = class _Capture {
     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)
-    ]);
+    await this.transcriptStream.stop(deadline);
     this.lossReport();
     await this.session.close({
       transcriptLost: this.transcriptStream.unsentCount,
-      recordingLost: this.recordingStream.unsentCount,
       isDetached,
       gitEnd
     });
@@ -2222,38 +2149,23 @@ var Capture = class _Capture {
   }
   async remoteStopWrite() {
     await this.steering.stop();
-    await Promise.all([
-      this.recordingStream.stop(Date.now()),
-      this.transcriptStream.stop(Date.now())
-    ]);
+    await 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
+  // Said once, after the stream has drained and the pane has already given the
+  // terminal back. The count is 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;
+    const lost = this.transcriptStream.unsentCount;
+    if (lost > 0) {
+      const why = this.transcriptStream.lastError;
       this.note(
-        `${count} ${unit} never reached the hub${why ? ` (${why})` : ""}`
+        `${lost} transcript lines never reached the hub${why ? ` (${why})` : ""}`
       );
     }
     const unresolved = this.reader.unresolvedChildList;
@@ -2317,11 +2229,6 @@ var HubSession = class _HubSession {
     session.heartbeatTimer.unref();
     return session;
   }
-  async recordingAppend(chunk) {
-    await this.liveRequest(
-      () => this.hub.recordingAppend(this.publicId, chunk)
-    );
-  }
   // 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.
@@ -2421,11 +2328,6 @@ async function git(args, cwd) {
 }
 
 // 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
@@ -2454,9 +2356,8 @@ var BANNER = `
   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";
+var TRANSCRIPT_MISSING_NOTE = "no transcript found; nothing reaches the chat. The agent runs normally.";
 function bannerWrap(command, cols, rows) {
   const lines = BANNER.replace(/^\n+|\n+$/g, "").split("\n");
   const width = Math.max(...lines.map((l) => l.length));
@@ -2473,26 +2374,20 @@ function bannerWrap(command, cols, rows) {
   ];
 }
 var PaneSession = class {
-  constructor(options, recording, tmux, agent, isCapturing = true) {
+  constructor(options, tmux, agent, note) {
     this.options = options;
-    this.recording = recording;
     this.tmux = tmux;
     this.agent = agent;
-    this.isCapturing = isCapturing;
+    this.note = note;
   }
   options;
-  recording;
   tmux;
   agent;
-  isCapturing;
-  fifo = join5(tmpdir2(), `directed-${process.pid}.fifo`);
-  decoder = new StringDecoder("utf8");
-  tap = null;
-  sizeTimer = null;
+  note;
   bindTimer = null;
   hook = null;
   reader = null;
-  isTapped = false;
+  isMissingNoted = 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() {
@@ -2534,14 +2429,13 @@ var PaneSession = class {
     if (running === null) {
       await this.tmux.newSession(bannerWrap(command, cols, rows), cols, rows);
     }
-    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.transcriptMissingNote()
       );
       this.reader.onRootOpen((key, path) => {
         void this.tmux.conversationMark(agent.kind, key, path);
@@ -2554,32 +2448,6 @@ var PaneSession = class {
       this.reader.start();
       if (running === null) this.announceBind();
     }
-    this.sizeTimer = this.sizePoll();
-  }
-  // 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)}).
-`
-      );
-    }
   }
   // Hands the terminal to the pane and waits. Returns the child's exit code.
   async attach() {
@@ -2592,29 +2460,18 @@ var PaneSession = class {
   async isDetached() {
     return this.tmux.hasSession();
   }
-  async steer(text, who) {
+  async steer(text) {
     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 (this.reader && !this.reader.isReading) this.transcriptMissingNote();
     if (isDetached) {
       process.stdout.write(
         `[directed] detached; your agent is still running. Reattach with: tmux attach -t ${this.tmux.session}
@@ -2622,6 +2479,13 @@ var PaneSession = class {
       );
     }
   }
+  // Once: the reader says it after its deadline, and stop() says it for a
+  // session that ended before the deadline came.
+  transcriptMissingNote() {
+    if (this.isMissingNoted) return;
+    this.isMissingNoted = true;
+    this.note(TRANSCRIPT_MISSING_NOTE);
+  }
   announceBind() {
     const hook = this.hook;
     const reader = this.reader;
@@ -2635,30 +2499,7 @@ var PaneSession = class {
       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);
-  }
 };
-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 {
@@ -2675,18 +2516,9 @@ async function withDeadline(work, ms) {
     clearTimeout(timer);
   }
 }
-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/tmux.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn } from "child_process";
 var SESSION_OPTIONS = [
   ["status", "off"],
   ["mouse", "on"],
@@ -2717,7 +2549,7 @@ async function conversationSession(bin, source, key, runner) {
 }
 function defaultRunner(bin) {
   return (args) => new Promise((resolve, reject) => {
-    const p = spawn2(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const p = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
     let out = "", err = "";
     p.stdout.on("data", (d) => out += d);
     p.stderr.on("data", (d) => err += d);
@@ -2741,7 +2573,7 @@ var Tmux = class {
   // 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.
+  // terminal width.
   async newSession(command, cols, rows) {
     await this.runner([
       "new-session",
@@ -2768,15 +2600,6 @@ var Tmux = class {
     await this.runner(["set-option", "-t", this.session, TAG_KEY, key]).catch(() => "");
     await this.runner(["set-option", "-t", this.session, TAG_PATH, path]).catch(() => "");
   }
-  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 };
-  }
-  pipePane(fifo) {
-    return this.runner(["pipe-pane", "-t", this.session, `cat >> ${fifo}`]).then(() => {
-    });
-  }
   sendText(text, submit) {
     const write = this.inputWrite.then(() => this.textWrite(text, submit));
     this.inputWrite = write.catch(() => {
@@ -2811,7 +2634,7 @@ var Tmux = class {
     return this.runner(["has-session", "-t", this.session]).then(() => true).catch(() => false);
   }
   attach() {
-    return spawn2(this.bin, ["attach", "-t", this.session], { stdio: "inherit" });
+    return spawn(this.bin, ["attach", "-t", this.session], { stdio: "inherit" });
   }
   kill() {
     return this.runner(["kill-session", "-t", this.session]).then(() => {
@@ -2821,59 +2644,65 @@ var Tmux = class {
 };
 
 // src/update.ts
-import { mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, readFileSync as readFileSync2, rmSync as rmSync4, writeFileSync as writeFileSync2 } from "fs";
+import { mkdtempSync as mkdtempSync2, realpathSync, rmSync as rmSync3, 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 stateLoad() {
+import { homedir as homedir4, tmpdir as tmpdir2 } from "os";
+import { join as join5 } from "path";
+function installRoot() {
+  return process.env.DIRECTED_CLI_INSTALL_ROOT ?? join5(homedir4(), ".directed");
+}
+function installChannel(entry = process.argv[1] ?? "") {
+  let resolved;
   try {
-    return JSON.parse(readFileSync2(statePath(), "utf8"));
+    resolved = realpathSync(entry);
   } catch {
-    return null;
+    return "unknown";
   }
+  if (resolved.startsWith(`${realpathOr(installRoot())}/`)) return "curl";
+  if (resolved.includes("/node_modules/")) return "npm";
+  return "unknown";
 }
-function stateSave(state) {
+function realpathOr(path) {
   try {
-    const path = statePath();
-    mkdirSync2(dirname3(path), { recursive: true });
-    writeFileSync2(path, JSON.stringify(state));
+    return realpathSync(path);
   } catch {
+    return path;
   }
 }
-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;
+async function updatePrompt(currentVersion, minimumVersion, terminal) {
+  await promptConfirm(
+    `[directed] Directed ${minimumVersion} or newer is required (you have ${currentVersion}).`,
+    "Press Enter to upgrade and continue. Ctrl-C to exit.",
+    terminal
+  );
 }
-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 });
-      }
-    } catch {
-    }
-  }
-  if (latest && versionIsNewer(latest, currentVersion)) {
-    note(`a new version is available (${currentVersion} -> ${latest}). Run 'directed upgrade' to update.`);
+function updateInstructions(channel) {
+  if (channel === "npm") return "npm install -g @directed/cli@latest";
+  return "curl -fsSL https://hub.directed.ai/cli/install.sh | bash";
+}
+async function updateInstall(hubUrl, channel = installChannel(), fetchImpl = fetch) {
+  if (channel === "npm") return npmInstall();
+  if (channel === "curl") return curlInstall(hubUrl, fetchImpl);
+  process.stderr.write(
+    `[directed] this build was not installed by npm or the installer, so it cannot upgrade itself.
+           Install a current one with: ${updateInstructions("curl")}
+`
+  );
+  return 1;
+}
+function npmInstall() {
+  process.stdout.write("[directed] installing @directed/cli@latest from npm\n");
+  const result = spawnSync("npm", ["install", "-g", "@directed/cli@latest"], {
+    stdio: "inherit"
+  });
+  if (result.error) {
+    process.stderr.write(`[directed] npm could not run (${result.error.message}).
+`);
+    return 1;
   }
+  return result.status ?? 1;
 }
-async function updateInstall(hubUrl, fetchImpl = fetch) {
+async function curlInstall(hubUrl, fetchImpl) {
   const scriptUrl = `${hubUrl}/cli/install.sh`;
   process.stdout.write(`[directed] fetching installer from ${scriptUrl}
 `);
@@ -2883,23 +2712,35 @@ async function updateInstall(hubUrl, fetchImpl = fetch) {
     return 1;
   }
   const script = await res.text();
-  const dir = mkdtempSync2(join6(tmpdir3(), "directed-upgrade-"));
+  const dir = mkdtempSync2(join5(tmpdir2(), "directed-upgrade-"));
   try {
-    const scriptPath = join6(dir, "install.sh");
+    const scriptPath = join5(dir, "install.sh");
     writeFileSync2(scriptPath, script, { mode: 493 });
     const result = spawnSync("bash", [scriptPath], {
       stdio: "inherit",
-      env: { ...process.env, DIRECTED_CLI_BASE_URL: hubUrl }
+      env: {
+        ...process.env,
+        DIRECTED_CLI_BASE_URL: hubUrl,
+        DIRECTED_CLI_UPGRADE: "1"
+      }
     });
     return result.status ?? 1;
   } finally {
-    rmSync4(dir, { recursive: true, force: true });
+    rmSync3(dir, { recursive: true, force: true });
   }
 }
+function updateLaunch(argv, channel = installChannel()) {
+  const spawn3 = channel === "curl" ? { command: join5(installRoot(), "bin", "directed"), args: argv } : { command: process.execPath, args: [process.argv[1] ?? "", ...argv] };
+  const result = spawnSync(spawn3.command, spawn3.args, {
+    stdio: "inherit",
+    env: { ...process.env, DIRECTED_CLI_RELAUNCHED: "1" }
+  });
+  if (result.error) throw result.error;
+  return result.status ?? 1;
+}
 
 // src/cli.ts
-var require2 = createRequire(import.meta.url);
-var CLI_VERSION = require2("../package.json").version;
+var require3 = createRequire2(import.meta.url);
 async function main(argv = process.argv.slice(2)) {
   if (isHelpRequest(argv)) {
     process.stdout.write(`${helpText()}
@@ -2944,68 +2785,105 @@ async function main(argv = process.argv.slice(2)) {
     );
     return 1;
   }
-  return sessionRun(options);
+  return sessionRun(options, argv);
 }
-async function sessionRun(options) {
+async function sessionRun(options, argv) {
   const hub = new Hub();
   const agent = agentResolve(options.command);
-  const auth = authSessionLoad(hub);
-  const isCapturing = options.chatEnabled && agent !== null && auth !== null;
+  const shouldShare = options.chatEnabled && agent !== null;
+  let auth = shouldShare ? authSessionLoad(hub) : null;
+  if (shouldShare && auth === null) {
+    if (!promptIsInteractive()) {
+      process.stderr.write(
+        `[directed] sign-in is required to share this session; use an interactive terminal.
+`
+      );
+      return 1;
+    }
+    try {
+      const state = await authPrompt(hub, browserOpen, PROMPT_TERMINAL);
+      auth = new AuthSession(hub, state);
+      process.stderr.write(`[directed] signed in as ${state.identity.email}
+`);
+    } catch (error) {
+      if (error instanceof PromptCancelledError) return 130;
+      process.stderr.write(
+        `[directed] sign-in failed (${error.message}); the shared session was not started.
+`
+      );
+      return 1;
+    }
+  }
+  const isCapturing = shouldShare && 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 chatPublicId2 = null;
-  if (isCapturing && options.chatTarget.kind !== "new") {
-    try {
-      hub.authAttach(auth);
-      chatPublicId2 = await chatPick(hub, options.chatTarget);
-    } catch (e) {
-      console.error(`[directed] ${e.message}`);
+  if (isCapturing && auth !== null && options.chatTarget.kind !== "new") {
+    const selected = await authRetry(hub, auth, async (currentAuth) => {
+      hub.authAttach(currentAuth);
+      return chatPick(hub, options.chatTarget);
+    });
+    if (selected.kind === "exit") return selected.code;
+    auth = selected.auth;
+    if (selected.kind === "failed") {
+      console.error(`[directed] ${selected.error.message}`);
       return 1;
     }
+    chatPublicId2 = selected.value;
   }
-  const cols = process.stdout.columns || 80;
-  const rows = process.stdout.rows || 24;
-  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 running = agent === null ? null : await runningFind(agent, options);
+  let session = null;
+  let isHeldRetrying = false;
+  if (isCapturing && auth !== null && agent !== null) {
+    const opened = await sessionOpen(
+      hub,
+      auth,
+      agent,
+      options,
+      chatPublicId2,
+      argv,
+      running !== null
+    );
+    if (opened.kind === "exit") return opened.code;
+    if (opened.kind === "opened") {
+      auth = opened.auth;
+      session = opened.session;
+    }
+    if (opened.kind === "held") {
+      auth = opened.auth;
+      isHeldRetrying = true;
+    }
+    if (opened.kind === "local") localOnly = opened.why;
+  }
+  const isSharing = session !== null || isHeldRetrying;
+  if (localOnly !== null)
+    process.stderr.write(`[directed] ${localOnly} Running locally.
+`);
+  const tmux = new Tmux(
+    options.tmuxBin,
+    running?.session ?? `directed-${randomBytes3(4).toString("hex")}`
+  );
+  const pane = new PaneSession(options, tmux, isSharing ? agent : null, note);
+  await pane.start(running?.pane ?? null);
   const captureAbort = new AbortController();
-  const capturing = isCapturing && auth !== null && agent !== null ? captureStart(
+  const capturing = isSharing && auth !== null && agent !== null ? captureBind(
+    session,
     hub,
     auth,
     agent,
     options,
-    recording,
     pane,
     chatPublicId2,
     note,
-    running !== null,
     captureAbort.signal
   ) : Promise.resolve(null);
   try {
@@ -3036,79 +2914,188 @@ async function runningFind(agent, options) {
 function binName() {
   return basename4(process.argv[1] ?? "directed");
 }
-async function captureStart(hub, auth, agent, options, recording, pane, chatPublicId2, note, shouldRetryHeld, signal) {
+async function sessionOpen(hub, auth, agent, options, chatPublicId2, argv, isRejoiningPane) {
+  const opened = await authRetry(
+    hub,
+    auth,
+    (currentAuth) => sessionOpenOnce(hub, currentAuth, agent, options, chatPublicId2)
+  );
+  if (opened.kind === "exit") return opened;
+  if (opened.kind === "succeeded") {
+    return { kind: "opened", session: opened.value, auth: opened.auth };
+  }
+  const error = opened.error;
+  if (error instanceof UpgradeRequiredError) return upgradeRun(error, argv);
+  if (error instanceof TerminalHeldError) {
+    if (isRejoiningPane) {
+      process.stderr.write(
+        `[directed] joined the session streaming to ${error.chatUrl}; the original connection keeps posting.
+`
+      );
+      return { kind: "held", auth: opened.auth };
+    }
+    return {
+      kind: "local",
+      why: `already streaming to ${error.chatUrl} from another terminal.`
+    };
+  }
+  return sharingFailed(error.message);
+}
+async function authRetry(hub, auth, operation) {
+  try {
+    return { kind: "succeeded", value: await operation(auth), auth };
+  } catch (error) {
+    if (!(error instanceof AuthenticationRequiredError)) {
+      return { kind: "failed", error, auth };
+    }
+  }
+  authClear(hub.url);
+  if (!promptIsInteractive()) {
+    process.stderr.write(
+      `[directed] the saved sign-in is no longer valid; run '${binName()} login' from an interactive terminal, or use --no-chat.
+`
+    );
+    return { kind: "exit", code: 1 };
+  }
+  let replacement;
+  try {
+    process.stderr.write(`[directed] the saved sign-in is no longer valid.
+`);
+    const state = await authPrompt(hub, browserOpen, PROMPT_TERMINAL);
+    replacement = new AuthSession(hub, state);
+    process.stderr.write(`[directed] signed in as ${state.identity.email}
+`);
+  } catch (error) {
+    if (error instanceof PromptCancelledError) return { kind: "exit", code: 130 };
+    process.stderr.write(
+      `[directed] sign-in failed (${error.message}); the shared session was not started.
+`
+    );
+    return { kind: "exit", code: 1 };
+  }
+  try {
+    return {
+      kind: "succeeded",
+      value: await operation(replacement),
+      auth: replacement
+    };
+  } catch (error) {
+    if (!(error instanceof AuthenticationRequiredError)) {
+      return { kind: "failed", error, auth: replacement };
+    }
+    authClear(hub.url);
+    process.stderr.write(
+      `[directed] sign-in rejected. Try '${binName()} login', or --no-chat.
+`
+    );
+    return { kind: "exit", code: 1 };
+  }
+}
+async function sessionOpenOnce(hub, auth, agent, options, chatPublicId2) {
+  hub.authAttach(auth);
+  return HubSession.open(hub, {
+    source: agent.kind,
+    title: options.title,
+    resumeKey: await agent.resumeKey(options.command, process.cwd()),
+    chatPublicId: chatPublicId2,
+    memberList: options.chatMembers,
+    gitStart: await gitSnapshot(process.cwd())
+  });
+}
+async function sharingFailed(reason) {
+  const cause = /fetch failed|abort|timeout/i.test(reason) ? "can't reach the hub" : `could not start a shared session (${reason})`;
+  const why = `${cause}; nothing will be shared or steerable.`;
+  if (!promptIsInteractive()) {
+    process.stderr.write(`[directed] ${why} Run with --no-chat to work locally.
+`);
+    return { kind: "exit", code: 1 };
+  }
+  try {
+    await promptConfirm(
+      `[directed] ${why}`,
+      "Press Enter to run locally. Ctrl-C to exit.",
+      PROMPT_TERMINAL
+    );
+  } catch (e) {
+    if (e instanceof PromptCancelledError) return { kind: "exit", code: 130 };
+    throw e;
+  }
+  return { kind: "local", why };
+}
+async function upgradeRun(refusal, argv) {
+  const channel = installChannel();
+  const version = CLI_VERSION.split("+")[0];
+  if (process.env.DIRECTED_CLI_RELAUNCHED === "1") {
+    process.stderr.write(
+      `[directed] still running ${version} after upgrading, and this hub needs ${refusal.minimumVersion}.
+           Install it with: ${updateInstructions(channel)}
+`
+    );
+    return { kind: "exit", code: 1 };
+  }
+  if (!promptIsInteractive() || channel === "unknown") {
+    process.stderr.write(
+      `[directed] ${refusal.message}
+           Upgrade with: ${updateInstructions(channel)}
+`
+    );
+    return { kind: "exit", code: 1 };
+  }
+  try {
+    await updatePrompt(version, refusal.minimumVersion, PROMPT_TERMINAL);
+  } catch (e) {
+    if (e instanceof PromptCancelledError) return { kind: "exit", code: 130 };
+    throw e;
+  }
+  if (await updateInstall(HUB_URL, channel) !== 0) {
+    process.stderr.write(
+      `[directed] the upgrade did not finish; the shared session was not started.
+`
+    );
+    return { kind: "exit", code: 1 };
+  }
+  process.stderr.write(`[directed] restarting on the new version
+`);
+  return { kind: "exit", code: updateLaunch(argv, channel) };
+}
+async function captureBind(opened, hub, auth, agent, options, pane, chatPublicId2, note, 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) {
+  let session = opened;
+  while (session === null) {
+    if (signal.aborted || !await retryWait(signal)) return null;
     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;
+      session = await sessionOpenOnce(hub, auth, agent, options, chatPublicId2);
     } 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.`
-      );
+      if (e instanceof TerminalHeldError) continue;
+      note(`could not open the chat (${e.message}); this session stays local.`);
       return null;
     }
   }
-  return null;
+  const capture = Capture.attach(session, auth, reader, note);
+  note(
+    capture.reattached ? `re-attached to its chat: ${capture.chatUrl}` : `streaming to a chat: ${capture.chatUrl}`
+  );
+  if (capture.skippedMemberList.length > 0) {
+    note(
+      `not connections yet, so not added: ${capture.skippedMemberList.join(", ")}. Use --invite instead.`
+    );
+  }
+  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);
+    return options.steerMode === "send" ? "sent" : "staged";
+  });
+  return capture;
 }
 function retryWait(signal) {
   return new Promise((resolve) => {
@@ -3142,7 +3129,7 @@ function browserOpen(url) {
   }
   const [command, args] = opener(url);
   try {
-    const child = spawn3(command, args, { detached: true, stdio: "ignore" });
+    const child = spawn2(command, args, { detached: true, stdio: "ignore" });
     child.on("error", () => {
     });
     child.unref();
@@ -3150,7 +3137,7 @@ function browserOpen(url) {
     return;
   }
 }
-var argv1 = process.argv[1] ? realpathSync(process.argv[1]) : "";
+var argv1 = process.argv[1] ? realpathSync2(process.argv[1]) : "";
 if (import.meta.url === pathToFileURL(argv1).href) {
   main().then((code) => process.exit(code)).catch((err) => {
     console.error(err?.message ?? err);