@halfwhey/claudraband-core 0.1.0

package/dist/index.js

@@ -0,0 +1,2491 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/terminal/activity.ts
+async function awaitPaneIdle(capture, options) {
+  const intervalMs = options?.intervalMs ?? 250;
+  const stableCount = options?.stableCount ?? 3;
+  const timeoutMs = options?.timeoutMs ?? 60000;
+  const signal = options?.signal;
+  if (signal?.aborted)
+    return "aborted";
+  const deadline = Date.now() + timeoutMs;
+  let previous = await capture();
+  let consecutiveStable = 0;
+  while (Date.now() < deadline) {
+    if (signal?.aborted)
+      return "aborted";
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(resolve, intervalMs);
+      if (signal) {
+        const onAbort = () => {
+          clearTimeout(timer);
+          reject(new DOMException("Aborted", "AbortError"));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        const origResolve = resolve;
+        resolve = () => {
+          signal.removeEventListener("abort", onAbort);
+          origResolve();
+        };
+      }
+    }).catch((err) => {
+      if (err instanceof DOMException && err.name === "AbortError")
+        return;
+      throw err;
+    });
+    if (signal?.aborted)
+      return "aborted";
+    const current = await capture();
+    if (current === previous) {
+      consecutiveStable++;
+      if (consecutiveStable >= stableCount) {
+        return "idle";
+      }
+    } else {
+      consecutiveStable = 0;
+      previous = current;
+    }
+  }
+  return "timeout";
+}
+
+// src/tmuxctl/tmux.ts
+import { spawn, spawnSync } from "child_process";
+async function tmux(...args) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("bash", ["-lc", shellCommand("tmux", ...args)]);
+    const out = [];
+    const err = [];
+    proc.stdout.on("data", (d) => out.push(d.toString()));
+    proc.stderr.on("data", (d) => err.push(d.toString()));
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve({ stdout: out.join(""), stderr: err.join("") });
+      } else {
+        reject(new Error(`tmux ${args.join(" ")}: exit ${code} (stderr=${err.join("")})`));
+      }
+    });
+    proc.on("error", reject);
+  });
+}
+function shellCommand(...args) {
+  return args.map(shellQuote).join(" ");
+}
+function shellQuote(arg) {
+  return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+function hasSession(name) {
+  return spawnSync("bash", ["-lc", shellCommand("tmux", "has-session", "-t", name)], {
+    stdio: "pipe"
+  }).status === 0;
+}
+function hasPane(id) {
+  return spawnSync("bash", ["-lc", shellCommand("tmux", "display-message", "-p", "-t", id, "#{pane_id}")], { stdio: "pipe" }).status === 0;
+}
+async function killSession(name) {
+  if (!hasSession(name))
+    return;
+  await tmux("kill-session", "-t", name);
+}
+async function listWindows(name) {
+  if (!hasSession(name))
+    return [];
+  const result = await tmux("list-windows", "-t", name, "-F", "#{window_id}\t#{pane_id}\t#{window_name}\t#{pane_current_path}\t#{window_activity}\t#{pane_pid}");
+  return result.stdout.trim().split(`
+`).filter(Boolean).map((line) => {
+    const [
+      windowId,
+      paneId,
+      windowName,
+      paneCurrentPath,
+      windowActivity,
+      panePid
+    ] = line.split("\t", 6);
+    return {
+      windowId,
+      paneId,
+      windowName,
+      paneCurrentPath: paneCurrentPath || undefined,
+      windowActivity: windowActivity || undefined,
+      panePid: panePid ? parseInt(panePid, 10) : undefined
+    };
+  }).filter((window) => window.windowId && window.paneId && window.windowName);
+}
+
+class Session {
+  name;
+  command;
+  windowId;
+  paneId;
+  constructor(name, command, windowId, paneId) {
+    this.name = name;
+    this.command = command;
+    this.windowId = windowId;
+    this.paneId = paneId;
+  }
+  static async newSession(name, width, height, workingDir, command, windowName) {
+    if (command.length === 0) {
+      throw new Error("tmuxctl: command is required");
+    }
+    const format = "#{window_id}\t#{pane_id}";
+    const result = hasSession(name) ? await tmux("new-window", "-P", "-F", format, "-t", name, "-n", windowName, ...workingDir ? ["-c", workingDir] : [], ...command) : await tmux("new-session", "-d", "-P", "-F", format, "-s", name, "-n", windowName, "-x", String(width), "-y", String(height), ...workingDir ? ["-c", workingDir] : [], ...command);
+    const [windowId, paneId] = result.stdout.trim().split(/\s+/, 2);
+    if (!windowId || !paneId) {
+      throw new Error(`tmuxctl: failed to parse tmux target ids: ${result.stdout}`);
+    }
+    try {
+      await tmux("set-option", "-t", name, "status", "off");
+    } catch {}
+    await tmux("resize-window", "-t", windowId, "-x", String(width), "-y", String(height));
+    return new Session(name, command, windowId, paneId);
+  }
+  static async find(sessionName, windowName) {
+    if (!hasSession(sessionName))
+      return null;
+    try {
+      const result = await tmux("list-windows", "-t", sessionName, "-F", "#{window_id}\t#{pane_id}\t#{window_name}");
+      for (const line of result.stdout.trim().split(`
+`)) {
+        const [windowId, paneId, name] = line.split("\t", 3);
+        if (name === windowName && windowId && paneId) {
+          const session = new Session(sessionName, [], windowId, paneId);
+          if (session.isAlive)
+            return session;
+        }
+      }
+    } catch {}
+    return null;
+  }
+  async kill() {
+    if (!this.isAlive)
+      return;
+    await tmux("kill-window", "-t", this.windowId);
+  }
+  get isAlive() {
+    return hasPane(this.paneId);
+  }
+  async resize(width, height) {
+    await tmux("resize-window", "-t", this.windowId, "-x", String(width), "-y", String(height));
+  }
+  async sendKeys(input) {
+    if (!input)
+      return;
+    await tmux("send-keys", "-t", this.paneId, "-l", "--", input);
+  }
+  async sendLine(input) {
+    if (input) {
+      await this.sendKeys(input);
+    }
+    await this.sendSpecial("Enter");
+  }
+  async sendSpecial(...keys) {
+    if (keys.length === 0)
+      return;
+    await tmux("send-keys", "-t", this.paneId, ...keys);
+  }
+  async interrupt() {
+    await this.sendSpecial("C-c");
+  }
+  async capturePane(opts = {}) {
+    const args = ["capture-pane", "-p", "-t", this.paneId];
+    if (opts.withEscapes) {
+      args.push("-e");
+    }
+    if (opts.includeScrollback) {
+      args.push("-S", "-");
+    }
+    args.push("-J");
+    const result = await tmux(...args);
+    return result.stdout;
+  }
+  async awaitIdle(options) {
+    return awaitPaneIdle(() => this.capturePane(), options);
+  }
+  async panePID() {
+    const result = await tmux("display-message", "-p", "-t", this.paneId, "#{pane_pid}");
+    return parseInt(result.stdout.trim(), 10);
+  }
+}
+var init_tmux = () => {};
+
+// src/tmuxctl/index.ts
+var exports_tmuxctl = {};
+__export(exports_tmuxctl, {
+  listWindows: () => listWindows,
+  killSession: () => killSession,
+  hasSession: () => hasSession,
+  Session: () => Session
+});
+var init_tmuxctl = __esm(() => {
+  init_tmux();
+});
+
+// src/index.ts
+import { open as open2, readFile as readFile3, stat as stat2 } from "node:fs/promises";
+import { request as httpRequest } from "node:http";
+
+// src/claude/claude.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync2, statSync } from "node:fs";
+
+// src/claude/parser.ts
+import { stat, open } from "node:fs/promises";
+
+// src/wrap/event.ts
+var EventKind;
+((EventKind2) => {
+  EventKind2["UserMessage"] = "user_message";
+  EventKind2["AssistantText"] = "assistant_text";
+  EventKind2["AssistantThinking"] = "assistant_thinking";
+  EventKind2["ToolCall"] = "tool_call";
+  EventKind2["ToolResult"] = "tool_result";
+  EventKind2["System"] = "system";
+  EventKind2["Error"] = "error";
+  EventKind2["SessionStart"] = "session_start";
+  EventKind2["TurnStart"] = "turn_start";
+  EventKind2["TurnEnd"] = "turn_end";
+})(EventKind ||= {});
+function makeEvent(partial) {
+  return {
+    time: new Date,
+    text: "",
+    toolName: "",
+    toolID: "",
+    toolInput: "",
+    role: "",
+    ...partial
+  };
+}
+
+// src/claude/parser.ts
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function truncate(s, n) {
+  if (s.length <= n)
+    return s;
+  return s.slice(0, n) + "...";
+}
+function extractToolResultText(b) {
+  const raw = b.content;
+  if (raw != null) {
+    if (typeof raw === "string")
+      return raw;
+    if (Array.isArray(raw)) {
+      const parts = [];
+      for (const bb of raw) {
+        if (bb.text)
+          parts.push(bb.text);
+      }
+      if (parts.length > 0)
+        return parts.join(`
+`);
+    }
+    return JSON.stringify(raw);
+  }
+  return "(no output)";
+}
+function parseProgress(env, ts) {
+  if (!env.data || typeof env.data !== "object")
+    return null;
+  const d = env.data;
+  let text = d.type ?? "";
+  if (d.query)
+    text += ": " + d.query;
+  return makeEvent({ kind: "system" /* System */, time: ts, text, role: "system" });
+}
+function parseMessageLineEvents(env, ts) {
+  if (!env.message)
+    return [];
+  const msg = env.message;
+  if (!msg.content) {
+    return msg.role === "assistant" && msg.stop_reason === "end_turn" ? [makeEvent({ kind: "turn_end" /* TurnEnd */, time: ts, role: "assistant" })] : [];
+  }
+  if (typeof msg.content === "string") {
+    const kind = msg.role === "assistant" ? "assistant_text" /* AssistantText */ : "user_message" /* UserMessage */;
+    return [
+      makeEvent({ kind, time: ts, text: msg.content, role: msg.role }),
+      ...msg.role === "assistant" && msg.stop_reason === "end_turn" ? [makeEvent({ kind: "turn_end" /* TurnEnd */, time: ts, role: "assistant" })] : []
+    ];
+  }
+  if (!Array.isArray(msg.content))
+    return [];
+  const blocks = msg.content;
+  const events = [];
+  for (const b of blocks) {
+    switch (b.type) {
+      case "text": {
+        const kind = msg.role === "user" ? "user_message" /* UserMessage */ : "assistant_text" /* AssistantText */;
+        events.push(makeEvent({ kind, time: ts, text: b.text ?? "", role: msg.role }));
+        break;
+      }
+      case "thinking":
+        if (b.thinking) {
+          events.push(makeEvent({
+            kind: "assistant_thinking" /* AssistantThinking */,
+            time: ts,
+            text: b.thinking,
+            role: "assistant"
+          }));
+        }
+        break;
+      case "tool_use": {
+        const inp = b.input ? JSON.stringify(b.input) : "{}";
+        events.push(makeEvent({
+          kind: "tool_call" /* ToolCall */,
+          time: ts,
+          text: `${b.name}(${truncate(inp, 80)})`,
+          toolName: b.name ?? "",
+          toolID: b.id ?? "",
+          toolInput: inp,
+          role: "assistant"
+        }));
+        break;
+      }
+      case "tool_result": {
+        const text = extractToolResultText(b);
+        events.push(makeEvent({
+          kind: "tool_result" /* ToolResult */,
+          time: ts,
+          text: truncate(text, 200),
+          toolID: b.tool_use_id ?? "",
+          role: "user"
+        }));
+        break;
+      }
+    }
+  }
+  if (msg.role === "assistant" && msg.stop_reason === "end_turn") {
+    events.push(makeEvent({ kind: "turn_end" /* TurnEnd */, time: ts, role: "assistant" }));
+  }
+  return events;
+}
+function parseLineEvents(line) {
+  let env;
+  try {
+    env = JSON.parse(line);
+  } catch {
+    return [];
+  }
+  const ts = env.timestamp ? new Date(env.timestamp) : new Date;
+  switch (env.type) {
+    case "user":
+      return parseMessageLineEvents(env, ts);
+    case "system":
+      if (env.content) {
+        return [
+          makeEvent({
+            kind: "system" /* System */,
+            time: ts,
+            text: env.content,
+            role: "system"
+          })
+        ];
+      }
+      return [];
+    case "progress": {
+      const ev = parseProgress(env, ts);
+      return ev ? [ev] : [];
+    }
+    default:
+      if (env.message) {
+        return parseMessageLineEvents(env, ts);
+      }
+      return [];
+  }
+}
+async function readAppended(path, offset) {
+  try {
+    const fi = await stat(path);
+    if (fi.size < offset)
+      offset = 0;
+    if (fi.size === offset)
+      return { data: "", offset };
+    const f = await open(path, "r");
+    try {
+      const buf = Buffer.alloc(fi.size - offset);
+      await f.read(buf, 0, buf.length, offset);
+      return { data: buf.toString(), offset: fi.size };
+    } finally {
+      await f.close();
+    }
+  } catch {
+    return { data: "", offset };
+  }
+}
+
+class Tailer {
+  path;
+  abortController;
+  eventQueue = [];
+  resolvers = [];
+  done = false;
+  startOffset;
+  constructor(path, startOffset = 0) {
+    this.path = path;
+    this.startOffset = startOffset;
+    this.abortController = new AbortController;
+    this.run();
+  }
+  close() {
+    this.abortController.abort();
+  }
+  async* events() {
+    while (true) {
+      if (this.eventQueue.length > 0) {
+        yield this.eventQueue.shift();
+        continue;
+      }
+      if (this.done)
+        return;
+      const result = await new Promise((resolve) => {
+        this.resolvers.push(resolve);
+      });
+      if (result.done)
+        return;
+      yield result.value;
+    }
+  }
+  pushEvent(ev) {
+    const resolver = this.resolvers.shift();
+    if (resolver) {
+      resolver({ value: ev, done: false });
+    } else {
+      this.eventQueue.push(ev);
+    }
+  }
+  finish() {
+    this.done = true;
+    for (const resolver of this.resolvers) {
+      resolver({ value: undefined, done: true });
+    }
+    this.resolvers = [];
+  }
+  emitCompleteLines(pending) {
+    while (true) {
+      const idx = pending.indexOf(`
+`);
+      if (idx < 0)
+        return pending;
+      const line = pending.slice(0, idx).replace(/\r$/, "");
+      pending = pending.slice(idx + 1);
+      if (!line)
+        continue;
+      for (const ev of parseLineEvents(line)) {
+        this.pushEvent(ev);
+      }
+    }
+  }
+  async run() {
+    const signal = this.abortController.signal;
+    while (!signal.aborted) {
+      try {
+        await stat(this.path);
+        break;
+      } catch {
+        await sleep(250);
+        if (signal.aborted) {
+          this.finish();
+          return;
+        }
+      }
+    }
+    let offset = this.startOffset;
+    let pending = "";
+    while (!signal.aborted) {
+      const { data, offset: newOffset } = await readAppended(this.path, offset);
+      offset = newOffset;
+      if (data) {
+        pending += data;
+        pending = this.emitCompleteLines(pending);
+      }
+      await sleep(200);
+    }
+    this.finish();
+  }
+}
+
+// src/terminal/index.ts
+init_tmuxctl();
+import { spawnSync as spawnSync2 } from "node:child_process";
+function getModuleExports(mod) {
+  if (typeof mod === "object" && mod !== null && "default" in mod && mod.default) {
+    return mod.default;
+  }
+  return mod;
+}
+function hasTmuxBinary() {
+  const result = spawnSync2("tmux", ["-V"], {
+    stdio: "ignore"
+  });
+  return result.status === 0;
+}
+function hasBunTerminalRuntime() {
+  return typeof Bun !== "undefined" && typeof Bun.Terminal === "function";
+}
+function resolveXtermTransportKind(detectBunRuntime = hasBunTerminalRuntime) {
+  return detectBunRuntime() ? "bun-terminal" : "node-pty";
+}
+function resolveTerminalBackend(backend, detectTmux = hasTmuxBinary) {
+  if (backend === "auto") {
+    return detectTmux() ? "tmux" : "xterm";
+  }
+  if (backend === "tmux" && !detectTmux()) {
+    throw new Error("terminal backend 'tmux' was requested, but tmux is not available on PATH");
+  }
+  return backend;
+}
+function createTerminalHost(options) {
+  return createTerminalBackendDriver({
+    backend: options.backend,
+    tmuxSessionName: options.tmuxSessionName
+  }).createHost(options.tmuxWindowName);
+}
+function createTerminalBackendDriver(options) {
+  const backend = resolveTerminalBackend(options.backend);
+  if (backend === "tmux") {
+    return new TmuxTerminalBackendDriver(options.tmuxSessionName);
+  }
+  return new XtermTerminalBackendDriver;
+}
+
+class TmuxTerminalBackendDriver {
+  sessionName;
+  backend = "tmux";
+  constructor(sessionName) {
+    this.sessionName = sessionName;
+  }
+  createHost(windowName) {
+    return new TmuxTerminalHost(this.sessionName, windowName);
+  }
+  async listLiveSessions() {
+    const windows = await listWindows(this.sessionName);
+    return windows.map((window) => ({
+      sessionId: window.windowName,
+      cwd: window.paneCurrentPath,
+      updatedAt: parseTmuxActivity(window.windowActivity),
+      pid: window.panePid
+    }));
+  }
+  async hasLiveSession(sessionId) {
+    return await Session.find(this.sessionName, sessionId) !== null;
+  }
+  async closeLiveSession(sessionId) {
+    const found = await Session.find(this.sessionName, sessionId);
+    if (!found)
+      return false;
+    await found.kill();
+    return true;
+  }
+  supportsLiveReconnect() {
+    return true;
+  }
+}
+
+class XtermTerminalBackendDriver {
+  backend = "xterm";
+  createHost(_windowName) {
+    return new XtermTerminalHost;
+  }
+  async listLiveSessions() {
+    return [];
+  }
+  async hasLiveSession(_sessionId) {
+    return false;
+  }
+  async closeLiveSession(_sessionId) {
+    return false;
+  }
+  supportsLiveReconnect() {
+    return false;
+  }
+}
+function parseTmuxActivity(activity) {
+  if (!activity)
+    return;
+  const epochSeconds = Number.parseInt(activity, 10);
+  if (!Number.isFinite(epochSeconds) || epochSeconds <= 0) {
+    return;
+  }
+  return new Date(epochSeconds * 1000).toISOString();
+}
+
+class TmuxTerminalHost {
+  sessionName;
+  windowName;
+  backend = "tmux";
+  session = null;
+  constructor(sessionName, windowName) {
+    this.sessionName = sessionName;
+    this.windowName = windowName;
+  }
+  async start(command, options) {
+    this.session = await Session.newSession(this.sessionName, options.cols, options.rows, options.cwd, command, this.windowName);
+  }
+  async stop() {
+    if (!this.session)
+      return;
+    await this.session.kill().catch(() => {});
+    this.session = null;
+  }
+  async detach() {
+    this.session = null;
+  }
+  async reattach(windowName) {
+    const existing = await Session.find(this.sessionName, windowName);
+    if (!existing)
+      return false;
+    this.session = existing;
+    return true;
+  }
+  async send(input) {
+    if (!this.session)
+      throw new Error("tmux terminal is not started");
+    await this.session.sendLine(input);
+  }
+  async interrupt() {
+    if (!this.session)
+      throw new Error("tmux terminal is not started");
+    await this.session.interrupt();
+  }
+  async capture() {
+    if (!this.session)
+      throw new Error("tmux terminal is not started");
+    return this.session.capturePane();
+  }
+  async awaitIdle(options) {
+    if (!this.session)
+      throw new Error("tmux terminal is not started");
+    return this.session.awaitIdle(options);
+  }
+  alive() {
+    return this.session !== null && this.session.isAlive;
+  }
+  async processId() {
+    if (!this.session)
+      return;
+    return this.session.panePID().catch(() => {
+      return;
+    });
+  }
+}
+
+class XtermTerminalHost {
+  backend = "xterm";
+  transport = null;
+  terminal = null;
+  serializeAddon = null;
+  outputDrain = Promise.resolve();
+  exited = false;
+  async start(command, options) {
+    if (command.length === 0) {
+      throw new Error("xterm terminal requires a command");
+    }
+    const [headlessModule, serializeModule] = await Promise.all([
+      import("@xterm/headless"),
+      import("@xterm/addon-serialize")
+    ]);
+    const { Terminal } = getModuleExports(headlessModule);
+    const { SerializeAddon } = getModuleExports(serializeModule);
+    this.terminal = new Terminal({
+      allowProposedApi: true,
+      cols: options.cols,
+      rows: options.rows,
+      scrollback: 5000
+    });
+    this.serializeAddon = new SerializeAddon;
+    this.terminal.loadAddon(this.serializeAddon);
+    this.exited = false;
+    this.transport = await createPtyTransport();
+    this.terminal.onData((data) => {
+      this.transport?.write(data);
+    });
+    this.terminal.onBinary((data) => {
+      this.transport?.write(data);
+    });
+    await this.transport.start(command, options, (data) => {
+      this.outputDrain = this.outputDrain.then(() => new Promise((resolve) => {
+        this.terminal?.write(data, () => resolve());
+      })).catch(() => {});
+    }, () => {
+      this.exited = true;
+    });
+    options.signal.addEventListener("abort", () => {
+      this.stop();
+    }, { once: true });
+  }
+  async stop() {
+    await this.transport?.stop().catch(() => {});
+    this.transport = null;
+    this.serializeAddon = null;
+    this.exited = true;
+    await this.outputDrain.catch(() => {});
+  }
+  async detach() {
+    await this.stop();
+  }
+  async reattach(_windowName) {
+    return false;
+  }
+  async send(input) {
+    if (!this.transport)
+      throw new Error("xterm terminal is not started");
+    if (!this.terminal)
+      throw new Error("xterm terminal is not started");
+    await this.outputDrain.catch(() => {});
+    if (input) {
+      for (const char of input) {
+        this.terminal.input(char);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    this.terminal.input("\r");
+  }
+  async interrupt() {
+    if (!this.transport)
+      throw new Error("xterm terminal is not started");
+    if (!this.terminal)
+      throw new Error("xterm terminal is not started");
+    await this.outputDrain.catch(() => {});
+    this.terminal.input("\x03");
+  }
+  async capture() {
+    if (!this.serializeAddon)
+      throw new Error("xterm terminal is not started");
+    await this.outputDrain;
+    return this.serializeAddon.serialize();
+  }
+  async awaitIdle(options) {
+    return awaitPaneIdle(() => this.capture(), options);
+  }
+  alive() {
+    return this.transport !== null && this.transport.alive() && !this.exited;
+  }
+  async processId() {
+    return this.transport?.pid();
+  }
+}
+async function createPtyTransport() {
+  if (resolveXtermTransportKind() === "bun-terminal") {
+    return new BunTerminalTransport;
+  }
+  return new NodePtyTransport;
+}
+
+class NodePtyTransport {
+  pty = null;
+  aliveFlag = false;
+  async start(command, options, onOutput, onExit) {
+    if (command.length === 0) {
+      throw new Error("xterm terminal requires a command");
+    }
+    let ptyModule;
+    try {
+      ptyModule = await import("node-pty");
+    } catch (error) {
+      throw new Error("xterm backend under Node requires the optional dependency 'node-pty'. Install it or run with Bun so Bun.Terminal can be used instead.", { cause: error });
+    }
+    const pty = getModuleExports(ptyModule);
+    const [file, ...args] = command;
+    this.pty = pty.spawn(file, args, {
+      name: "xterm-256color",
+      cols: options.cols,
+      rows: options.rows,
+      cwd: options.cwd,
+      env: {
+        ...process.env,
+        TERM: "xterm-256color"
+      }
+    });
+    this.aliveFlag = true;
+    this.pty.onData((data) => {
+      onOutput(data);
+    });
+    this.pty.onExit(() => {
+      this.aliveFlag = false;
+      onExit();
+    });
+  }
+  async stop() {
+    if (!this.pty)
+      return;
+    try {
+      this.pty.kill();
+    } catch {}
+    this.pty = null;
+    this.aliveFlag = false;
+  }
+  write(data) {
+    if (!this.pty)
+      throw new Error("node-pty transport is not started");
+    this.pty.write(data);
+  }
+  alive() {
+    return this.pty !== null && this.aliveFlag;
+  }
+  pid() {
+    return this.pty?.pid;
+  }
+}
+
+class BunTerminalTransport {
+  terminal = null;
+  process = null;
+  decoder = new TextDecoder;
+  aliveFlag = false;
+  async start(command, options, onOutput, onExit) {
+    if (command.length === 0) {
+      throw new Error("xterm terminal requires a command");
+    }
+    if (!hasBunTerminalRuntime()) {
+      throw new Error("bun terminal transport requires Bun runtime");
+    }
+    this.terminal = new Bun.Terminal({
+      cols: options.cols,
+      rows: options.rows,
+      name: "xterm-256color",
+      data: (_terminal, data) => {
+        const text = this.decoder.decode(data, { stream: true });
+        if (text) {
+          onOutput(text);
+        }
+      },
+      exit: () => {
+        this.aliveFlag = false;
+        const rest = this.decoder.decode();
+        if (rest) {
+          onOutput(rest);
+        }
+        onExit();
+      }
+    });
+    this.process = Bun.spawn(command, {
+      cwd: options.cwd,
+      env: {
+        ...process.env,
+        TERM: "xterm-256color"
+      },
+      terminal: this.terminal
+    });
+    this.aliveFlag = true;
+  }
+  async stop() {
+    if (!this.terminal && !this.process)
+      return;
+    try {
+      this.process?.kill();
+    } catch {}
+    try {
+      this.terminal?.close();
+    } catch {}
+    this.process = null;
+    this.terminal = null;
+    this.aliveFlag = false;
+  }
+  write(data) {
+    if (!this.terminal)
+      throw new Error("bun terminal transport is not started");
+    this.terminal.write(data);
+  }
+  alive() {
+    return this.terminal !== null && !this.terminal.closed && this.aliveFlag;
+  }
+  pid() {
+    return this.process?.pid;
+  }
+}
+
+// src/claude/resolve.ts
+import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+var require2 = createRequire2(import.meta.url);
+var ENV_OVERRIDE = "CLAUDRABAND_CLAUDE_PATH";
+function resolveClaudeExecutable(explicitPath) {
+  if (explicitPath) {
+    return explicitPath;
+  }
+  const envOverride = process.env[ENV_OVERRIDE];
+  if (envOverride) {
+    return envOverride;
+  }
+  try {
+    const packageJsonPath = require2.resolve("@anthropic-ai/claude-code/package.json");
+    const packageJson = require2(packageJsonPath);
+    const binPath = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.claude;
+    if (!binPath) {
+      throw new Error("missing bin.claude entry");
+    }
+    const executable = join(dirname(packageJsonPath), binPath);
+    if (!existsSync(executable)) {
+      throw new Error(`resolved bin not found at ${executable}`);
+    }
+    return executable;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`claudraband could not resolve bundled Claude Code @anthropic-ai/claude-code@2.1.96 (${reason}). ` + `Install dependencies or set ${ENV_OVERRIDE} or ClaudrabandOptions.claudeExecutable.`);
+  }
+}
+
+// src/claude/claude.ts
+function sessionPath(cwd, sessionID) {
+  const home = homedir();
+  const escaped = cwd.replace(/\//g, "-");
+  return join2(home, ".claude", "projects", escaped, `${sessionID}.jsonl`);
+}
+
+class ClaudeWrapper {
+  cfg;
+  terminal = null;
+  tailer = null;
+  _claudeSessionId = "";
+  _signal = null;
+  abortController = null;
+  eventIterable = null;
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  name() {
+    return "claude";
+  }
+  model() {
+    return this.cfg.model;
+  }
+  setModel(model) {
+    this.cfg.model = model;
+  }
+  setPermissionMode(mode) {
+    this.cfg.permissionMode = mode;
+  }
+  get claudeSessionId() {
+    return this._claudeSessionId;
+  }
+  async start(signal) {
+    this._claudeSessionId = randomUUID();
+    this._signal = signal;
+    const cmd = this.buildCmd("--session-id", this._claudeSessionId);
+    await this.spawnAndTail(signal, cmd);
+  }
+  async startResume(claudeSessionId, signal) {
+    this._claudeSessionId = claudeSessionId;
+    this._signal = signal;
+    const terminal = createTerminalHost({
+      backend: this.cfg.terminalBackend,
+      tmuxSessionName: this.cfg.tmuxSession,
+      tmuxWindowName: claudeSessionId
+    });
+    const reattached = await terminal.reattach(claudeSessionId);
+    if (reattached) {
+      this.terminal = terminal;
+      this.abortController = new AbortController;
+      signal.addEventListener("abort", () => {
+        this.abortController?.abort();
+      });
+      const jsonlPath2 = sessionPath(this.cfg.workingDir, claudeSessionId);
+      let tailOffset2 = 0;
+      if (existsSync2(jsonlPath2)) {
+        tailOffset2 = statSync(jsonlPath2).size;
+      }
+      this.tailer = new Tailer(jsonlPath2, tailOffset2);
+      this.eventIterable = this.tailer.events();
+      const ac = this.abortController;
+      const tailer = this.tailer;
+      const term = this.terminal;
+      ac.signal.addEventListener("abort", async () => {
+        tailer.close();
+        await term?.stop().catch(() => {});
+      }, { once: true });
+      return;
+    }
+    const jsonlPath = sessionPath(this.cfg.workingDir, claudeSessionId);
+    let tailOffset = 0;
+    if (existsSync2(jsonlPath)) {
+      tailOffset = statSync(jsonlPath).size;
+    }
+    const cmd = existsSync2(jsonlPath) ? this.buildCmd("--resume", claudeSessionId) : this.buildCmd("--session-id", claudeSessionId);
+    await this.spawnAndTail(signal, cmd, tailOffset);
+  }
+  async restart() {
+    if (!this._signal)
+      throw new Error("claude: not started");
+    this.tailer?.close();
+    if (this.terminal) {
+      await this.terminal.stop().catch(() => {});
+    }
+    this.terminal = null;
+    this.tailer = null;
+    this.eventIterable = null;
+    const jsonlPath = sessionPath(this.cfg.workingDir, this._claudeSessionId);
+    let tailOffset = 0;
+    if (existsSync2(jsonlPath)) {
+      tailOffset = statSync(jsonlPath).size;
+    }
+    const cmd = existsSync2(jsonlPath) ? this.buildCmd("--resume", this._claudeSessionId) : this.buildCmd("--session-id", this._claudeSessionId);
+    await this.spawnAndTail(this._signal, cmd, tailOffset);
+  }
+  buildCmd(...extra) {
+    const cmd = [
+      resolveClaudeExecutable(this.cfg.claudeExecutable),
+      "--model",
+      this.cfg.model,
+      ...this.cfg.claudeArgs
+    ];
+    if (this.cfg.permissionMode && this.cfg.permissionMode !== "default") {
+      cmd.push("--permission-mode", this.cfg.permissionMode);
+    }
+    cmd.push(...extra);
+    return cmd;
+  }
+  async spawnAndTail(signal, cmd, tailOffset = 0) {
+    this.abortController = new AbortController;
+    this.terminal = createTerminalHost({
+      backend: this.cfg.terminalBackend,
+      tmuxSessionName: this.cfg.tmuxSession,
+      tmuxWindowName: this._claudeSessionId
+    });
+    signal.addEventListener("abort", () => {
+      this.abortController?.abort();
+    });
+    await this.terminal.start(cmd, {
+      cwd: this.cfg.workingDir,
+      cols: this.cfg.paneWidth,
+      rows: this.cfg.paneHeight,
+      signal
+    });
+    await this.waitForReady(signal);
+    const jsonlPath = sessionPath(this.cfg.workingDir, this._claudeSessionId);
+    this.tailer = new Tailer(jsonlPath, tailOffset);
+    this.eventIterable = this.tailer.events();
+    const ac = this.abortController;
+    const terminal = this.terminal;
+    const tailer = this.tailer;
+    ac.signal.addEventListener("abort", async () => {
+      tailer.close();
+      await terminal?.stop().catch(() => {});
+    }, { once: true });
+  }
+  async waitForReady(signal) {
+    const MAX_WAIT_MS = 15000;
+    const POLL_MS = 300;
+    const start = Date.now();
+    while (Date.now() - start < MAX_WAIT_MS) {
+      if (signal.aborted)
+        return;
+      try {
+        const pane = await this.terminal.capture();
+        if (pane.includes("INSERT") || pane.includes("NORMAL")) {
+          return;
+        }
+      } catch {}
+      await new Promise((r) => setTimeout(r, POLL_MS));
+    }
+  }
+  async stop() {
+    this.abortController?.abort();
+    if (this.terminal) {
+      await this.terminal.stop();
+    }
+  }
+  async detach() {
+    this.tailer?.close();
+    this.tailer = null;
+    this.eventIterable = null;
+    if (this.terminal) {
+      await this.terminal.detach();
+    }
+    this.terminal = null;
+  }
+  isProcessAlive() {
+    return this.terminal !== null && this.terminal.alive();
+  }
+  static async hasLiveProcess(tmuxSessionName, claudeSessionId) {
+    const { Session: Session2 } = await Promise.resolve().then(() => (init_tmuxctl(), exports_tmuxctl));
+    const found = await Session2.find(tmuxSessionName, claudeSessionId);
+    return found !== null;
+  }
+  static async stopLiveProcess(tmuxSessionName, claudeSessionId) {
+    const { Session: Session2 } = await Promise.resolve().then(() => (init_tmuxctl(), exports_tmuxctl));
+    const found = await Session2.find(tmuxSessionName, claudeSessionId);
+    if (!found)
+      return false;
+    await found.kill();
+    return true;
+  }
+  async send(input) {
+    if (!this.terminal)
+      throw new Error("claude: not started");
+    await this.terminal.send(input);
+  }
+  async interrupt() {
+    if (!this.terminal)
+      throw new Error("claude: not started");
+    await this.terminal.interrupt();
+  }
+  async capturePane() {
+    if (!this.terminal)
+      throw new Error("claude: not started");
+    return this.terminal.capture();
+  }
+  async processId() {
+    return this.terminal?.processId();
+  }
+  alive() {
+    return this.terminal !== null && this.terminal.alive();
+  }
+  async* events() {
+    if (this.eventIterable) {
+      yield* this.eventIterable;
+    }
+  }
+}
+function parseClaudeArgs(args) {
+  const passthroughArgs = [];
+  let model;
+  let permissionMode;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--model" && i + 1 < args.length) {
+      model = args[++i];
+      continue;
+    }
+    if (arg === "--permission-mode" && i + 1 < args.length) {
+      permissionMode = args[++i];
+      continue;
+    }
+    passthroughArgs.push(arg);
+  }
+  return { passthroughArgs, model, permissionMode };
+}
+// src/claude/inspect.ts
+import { readFile } from "node:fs/promises";
+async function hasPendingQuestion(jsonlPath) {
+  let data;
+  try {
+    data = await readFile(jsonlPath, "utf-8");
+  } catch {
+    return false;
+  }
+  const pendingIds = new Set;
+  for (const line of data.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!entry.message || !Array.isArray(entry.message.content))
+      continue;
+    const blocks = entry.message.content;
+    for (const block of blocks) {
+      if (block.type === "tool_use" && block.name === "AskUserQuestion" && block.id) {
+        pendingIds.add(block.id);
+      }
+      if (block.type === "tool_result" && block.tool_use_id) {
+        pendingIds.delete(block.tool_use_id);
+      }
+    }
+  }
+  return pendingIds.size > 0;
+}
+function parseNativePermissionPrompt(paneText) {
+  const questionMatch = paneText.match(/(?:^|\n)\s*(Do you want to [^\n]+\?)/);
+  if (!questionMatch)
+    return null;
+  const afterQuestion = paneText.slice(paneText.indexOf(questionMatch[1]) + questionMatch[1].length);
+  const optionRegex = /(?:❯\s*)?(\d+)\.\s+(.+)/g;
+  const options = [];
+  let match;
+  while ((match = optionRegex.exec(afterQuestion)) !== null) {
+    options.push({ number: match[1], label: match[2].trim() });
+  }
+  if (options.length === 0)
+    return null;
+  return { question: questionMatch[1], options };
+}
+function hasPendingNativePrompt(paneText) {
+  return parseNativePermissionPrompt(paneText) !== null;
+}
+// src/session-registry.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+import {
+  mkdir,
+  readdir,
+  readFile as readFile2,
+  rename,
+  rm,
+  writeFile
+} from "node:fs/promises";
+function registryRoot() {
+  return process.env.CLAUDRABAND_HOME || join3(homedir2(), ".claudraband");
+}
+function sessionsDir() {
+  return join3(registryRoot(), "sessions");
+}
+function knownSessionsDir() {
+  return join3(registryRoot(), "known-sessions");
+}
+function sessionFilePath(sessionId) {
+  return join3(sessionsDir(), `${sessionId}.json`);
+}
+function knownSessionFilePath(sessionId) {
+  return join3(knownSessionsDir(), `${sessionId}.json`);
+}
+async function ensureSessionRegistry() {
+  await mkdir(sessionsDir(), { recursive: true });
+  await mkdir(knownSessionsDir(), { recursive: true });
+}
+async function readSessionRecord(sessionId) {
+  try {
+    const text = await readFile2(sessionFilePath(sessionId), "utf8");
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function listSessionRecords() {
+  return listRecordDir(sessionsDir());
+}
+async function readKnownSessionRecord(sessionId) {
+  try {
+    const text = await readFile2(knownSessionFilePath(sessionId), "utf8");
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function listKnownSessionRecords() {
+  return listRecordDir(knownSessionsDir());
+}
+async function listRecordDir(dir) {
+  try {
+    const files = await readdir(dir);
+    const records = await Promise.all(files.filter((file) => file.endsWith(".json")).map(async (file) => {
+      try {
+        const text = await readFile2(join3(dir, file), "utf8");
+        return JSON.parse(text);
+      } catch {
+        return null;
+      }
+    }));
+    return records.filter((record) => record !== null);
+  } catch {
+    return [];
+  }
+}
+async function writeSessionRecord(record) {
+  await ensureSessionRegistry();
+  const targetPath = sessionFilePath(record.sessionId);
+  await writeRecordFile(targetPath, record);
+}
+async function writeKnownSessionRecord(record) {
+  await ensureSessionRegistry();
+  const targetPath = knownSessionFilePath(record.sessionId);
+  await writeRecordFile(targetPath, record);
+}
+async function writeRecordFile(targetPath, record) {
+  const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tempPath, JSON.stringify(record, null, 2));
+  await rename(tempPath, targetPath);
+}
+async function deleteSessionRecord(sessionId) {
+  await rm(sessionFilePath(sessionId), { force: true }).catch(() => {});
+}
+function normalizeServerUrl(server) {
+  return server.startsWith("http://") || server.startsWith("https://") ? server.replace(/\/+$/, "") : `http://${server}`.replace(/\/+$/, "");
+}
+function isPidAlive(pid) {
+  if (!pid || !Number.isFinite(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/index.ts
+var DEFAULT_PANE_WIDTH = 120;
+var DEFAULT_PANE_HEIGHT = 40;
+var IDLE_TIMEOUT_MS = 3000;
+var SHARED_TMUX_SESSION = "claudraband-working-session";
+var SHARED_TMUX_SESSION_NAME = "claudraband-working-session";
+async function hasLiveProcess(sessionId) {
+  return createTerminalBackendDriver({
+    backend: "tmux",
+    tmuxSessionName: SHARED_TMUX_SESSION_NAME
+  }).hasLiveSession(sessionId);
+}
+async function closeLiveProcess(sessionId) {
+  return createTerminalBackendDriver({
+    backend: "tmux",
+    tmuxSessionName: SHARED_TMUX_SESSION_NAME
+  }).closeLiveSession(sessionId);
+}
+var MODEL_OPTIONS = [
+  { value: "haiku", name: "Haiku", description: "Fast and lightweight" },
+  {
+    value: "sonnet",
+    name: "Sonnet",
+    description: "Balanced speed and intelligence"
+  },
+  { value: "opus", name: "Opus", description: "Most capable" }
+];
+var PERMISSION_MODES = [
+  { id: "default", name: "Default", description: "Ask before tool use" },
+  { id: "plan", name: "Plan", description: "Plan-only mode, no edits" },
+  { id: "auto", name: "Auto", description: "Bypass permission checks" },
+  {
+    id: "acceptEdits",
+    name: "Accept Edits",
+    description: "Auto-accept file edits"
+  },
+  { id: "dontAsk", name: "Don't Ask", description: "Skip all confirmations" },
+  {
+    id: "bypassPermissions",
+    name: "Bypass Permissions",
+    description: "Dangerously Skip Permissions"
+  }
+];
+var TERMINAL_BACKENDS = [
+  {
+    id: "auto",
+    name: "Auto",
+    description: "Prefer tmux, then fall back to headless xterm"
+  },
+  {
+    id: "tmux",
+    name: "tmux",
+    description: "Run Claude Code inside a tmux session"
+  },
+  {
+    id: "xterm",
+    name: "xterm",
+    description: "Run Claude Code in a headless xterm-backed PTY"
+  }
+];
+function makeDefaultLogger() {
+  const noop = () => {};
+  return {
+    info: noop,
+    debug: noop,
+    warn: noop,
+    error: noop
+  };
+}
+function normalizeOptions(defaults, options) {
+  const parsedClaudeArgs = parseClaudeArgs(options?.claudeArgs ?? defaults.claudeArgs ?? []);
+  return {
+    cwd: options?.cwd ?? defaults.cwd ?? process.cwd(),
+    claudeArgs: parsedClaudeArgs.passthroughArgs,
+    claudeExecutable: options?.claudeExecutable ?? defaults.claudeExecutable ?? "",
+    model: options?.model ?? parsedClaudeArgs.model ?? defaults.model ?? "sonnet",
+    permissionMode: options?.permissionMode ?? parsedClaudeArgs.permissionMode ?? defaults.permissionMode ?? "default",
+    allowTextResponses: options?.allowTextResponses ?? defaults.allowTextResponses ?? false,
+    terminalBackend: options?.terminalBackend ?? defaults.terminalBackend ?? "auto",
+    paneWidth: options?.paneWidth ?? defaults.paneWidth ?? DEFAULT_PANE_WIDTH,
+    paneHeight: options?.paneHeight ?? defaults.paneHeight ?? DEFAULT_PANE_HEIGHT,
+    logger: options?.logger ?? defaults.logger ?? makeDefaultLogger(),
+    onPermissionRequest: options?.onPermissionRequest ?? defaults.onPermissionRequest,
+    ...options?.sessionOwner ?? defaults.sessionOwner ? { sessionOwner: options?.sessionOwner ?? defaults.sessionOwner } : {}
+  };
+}
+function createClaudraband(defaults = {}) {
+  return new ClaudrabandRuntime(defaults);
+}
+
+class ClaudrabandRuntime {
+  defaults;
+  constructor(defaults) {
+    this.defaults = defaults;
+  }
+  async startSession(options) {
+    const cfg = normalizeOptions(this.defaults, options);
+    const backend = resolveTerminalBackend(cfg.terminalBackend);
+    const wrapper = new ClaudeWrapper({
+      model: cfg.model,
+      claudeArgs: cfg.claudeArgs,
+      claudeExecutable: cfg.claudeExecutable || undefined,
+      permissionMode: cfg.permissionMode,
+      terminalBackend: cfg.terminalBackend,
+      workingDir: cfg.cwd,
+      tmuxSession: SHARED_TMUX_SESSION,
+      paneWidth: cfg.paneWidth,
+      paneHeight: cfg.paneHeight
+    });
+    const lifetime = new AbortController;
+    await wrapper.start(lifetime.signal);
+    const session = new ClaudrabandSessionImpl(wrapper, wrapper.claudeSessionId, cfg.cwd, backend, cfg.model, cfg.permissionMode, cfg.allowTextResponses, cfg.logger, cfg.onPermissionRequest, lifetime, cfg.sessionOwner);
+    await session.syncSessionRecord();
+    return session;
+  }
+  async resumeSession(sessionId, options) {
+    const cfg = normalizeOptions(this.defaults, options);
+    const backend = resolveTerminalBackend(cfg.terminalBackend);
+    const wrapper = new ClaudeWrapper({
+      model: cfg.model,
+      claudeArgs: cfg.claudeArgs,
+      claudeExecutable: cfg.claudeExecutable || undefined,
+      permissionMode: cfg.permissionMode,
+      terminalBackend: cfg.terminalBackend,
+      workingDir: cfg.cwd,
+      tmuxSession: SHARED_TMUX_SESSION,
+      paneWidth: cfg.paneWidth,
+      paneHeight: cfg.paneHeight
+    });
+    const lifetime = new AbortController;
+    await wrapper.startResume(sessionId, lifetime.signal);
+    const session = new ClaudrabandSessionImpl(wrapper, sessionId, cfg.cwd, backend, cfg.model, cfg.permissionMode, cfg.allowTextResponses, cfg.logger, cfg.onPermissionRequest, lifetime, cfg.sessionOwner);
+    await session.syncSessionRecord();
+    return session;
+  }
+  listSessions(cwd) {
+    return discoverSessions(cwd);
+  }
+  inspectSession(sessionId, cwd) {
+    return inspectSession(sessionId, cwd);
+  }
+  closeSession(sessionId) {
+    return closeSessionByRecord(sessionId);
+  }
+  async replaySession(sessionId, cwd) {
+    let data;
+    try {
+      data = await readFile3(sessionPath(cwd, sessionId), "utf-8");
+    } catch {
+      return [];
+    }
+    const events = [];
+    for (const line of data.split(`
+`)) {
+      if (!line.trim())
+        continue;
+      events.push(...parseLineEvents(line));
+    }
+    return events;
+  }
+}
+
+class ClaudrabandSessionImpl {
+  sessionId;
+  cwd;
+  backend;
+  wrapper;
+  logger;
+  onPermissionRequest;
+  lifetime;
+  promptAbortController = null;
+  subscribers = new Set;
+  stopped = false;
+  pumpDone = false;
+  pumpError = null;
+  activePrompt = null;
+  pumpPromise;
+  _model;
+  _permissionMode;
+  allowTextResponses;
+  sessionOwner;
+  constructor(wrapper, sessionId, cwd, backend, model, permissionMode, allowTextResponses, logger, onPermissionRequest, lifetime, sessionOwner) {
+    this.sessionId = sessionId;
+    this.cwd = cwd;
+    this.backend = backend;
+    this.wrapper = wrapper;
+    this._model = model;
+    this._permissionMode = permissionMode;
+    this.allowTextResponses = allowTextResponses;
+    this.logger = logger;
+    this.onPermissionRequest = onPermissionRequest;
+    this.lifetime = lifetime;
+    this.sessionOwner = sessionOwner;
+    this.pumpPromise = this.pumpEvents();
+  }
+  get model() {
+    return this._model;
+  }
+  get permissionMode() {
+    return this._permissionMode;
+  }
+  async prompt(text) {
+    if (this.promptAbortController) {
+      this.promptAbortController.abort();
+    }
+    const controller = new AbortController;
+    this.promptAbortController = controller;
+    if (!text) {
+      controller.abort();
+      this.promptAbortController = null;
+      return { stopReason: "end_turn" };
+    }
+    const prompt = this.newPromptWaiter(text);
+    this.activePrompt = prompt;
+    this.logger.info("prompt received", "sid", this.sessionId, "length", text.length);
+    await this.wrapper.send(text);
+    try {
+      const stopReason = await this.waitForPromptCompletion(prompt, controller.signal);
+      this.logger.info("prompt completed", "sid", this.sessionId, "stop_reason", stopReason);
+      return { stopReason };
+    } finally {
+      if (this.activePrompt === prompt) {
+        this.activePrompt = null;
+      }
+      if (this.promptAbortController === controller) {
+        this.promptAbortController = null;
+      }
+    }
+  }
+  async awaitTurn() {
+    if (this.promptAbortController) {
+      this.promptAbortController.abort();
+    }
+    const controller = new AbortController;
+    this.promptAbortController = controller;
+    const prompt = this.newPromptWaiter("");
+    prompt.matchedUserEcho = true;
+    this.activePrompt = prompt;
+    this.logger.info("awaitTurn", "sid", this.sessionId);
+    try {
+      const stopReason = await this.waitForPromptCompletion(prompt, controller.signal);
+      this.logger.info("awaitTurn completed", "sid", this.sessionId, "stop_reason", stopReason);
+      return { stopReason };
+    } finally {
+      if (this.activePrompt === prompt) {
+        this.activePrompt = null;
+      }
+      if (this.promptAbortController === controller) {
+        this.promptAbortController = null;
+      }
+    }
+  }
+  async sendAndAwaitTurn(text) {
+    if (this.promptAbortController) {
+      this.promptAbortController.abort();
+    }
+    const controller = new AbortController;
+    this.promptAbortController = controller;
+    const prompt = this.newPromptWaiter("");
+    prompt.matchedUserEcho = true;
+    this.activePrompt = prompt;
+    this.logger.info("sendAndAwaitTurn", "sid", this.sessionId, "length", text.length);
+    await this.wrapper.send(text);
+    try {
+      const stopReason = await this.waitForPromptCompletion(prompt, controller.signal);
+      this.logger.info("sendAndAwaitTurn completed", "sid", this.sessionId, "stop_reason", stopReason);
+      return { stopReason };
+    } finally {
+      if (this.activePrompt === prompt) {
+        this.activePrompt = null;
+      }
+      if (this.promptAbortController === controller) {
+        this.promptAbortController = null;
+      }
+    }
+  }
+  send(text) {
+    return this.wrapper.send(text);
+  }
+  async interrupt() {
+    this.promptAbortController?.abort();
+    await this.wrapper.interrupt();
+  }
+  async stop() {
+    this.stopped = true;
+    this.promptAbortController?.abort();
+    this.lifetime.abort();
+    await this.wrapper.stop().catch(() => {});
+    await this.pumpPromise.catch(() => {});
+    this.closeSubscribers();
+    await this.syncSessionRecord(false);
+  }
+  async detach() {
+    this.stopped = true;
+    this.promptAbortController?.abort();
+    await this.wrapper.detach();
+    await this.pumpPromise.catch(() => {});
+    this.closeSubscribers();
+    await this.syncSessionRecord();
+  }
+  isProcessAlive() {
+    return this.wrapper.isProcessAlive();
+  }
+  capturePane() {
+    return this.wrapper.capturePane();
+  }
+  async syncSessionRecord(alive = this.isProcessAlive()) {
+    const existing = await readSessionRecord(this.sessionId);
+    const known = await readKnownSessionRecord(this.sessionId);
+    const transcriptPath = sessionPath(this.cwd, this.sessionId);
+    const now = new Date().toISOString();
+    const title = existing?.title ?? known?.title ?? await extractSessionTitle(transcriptPath) ?? undefined;
+    await writeKnownSessionRecord({
+      version: 1,
+      sessionId: this.sessionId,
+      cwd: this.cwd,
+      backend: this.backend,
+      title,
+      createdAt: existing?.createdAt ?? known?.createdAt ?? now,
+      updatedAt: now,
+      transcriptPath
+    });
+    if (!alive) {
+      await deleteSessionRecord(this.sessionId);
+      return;
+    }
+    const owner = await this.resolveSessionOwner();
+    await writeSessionRecord({
+      version: 1,
+      sessionId: this.sessionId,
+      cwd: this.cwd,
+      backend: this.backend,
+      title,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now,
+      lastKnownAlive: alive,
+      reattachable: alive && this.supportsReconnect(owner),
+      transcriptPath,
+      owner
+    });
+  }
+  async resolveSessionOwner() {
+    if (this.sessionOwner?.kind === "daemon") {
+      return this.sessionOwner;
+    }
+    return {
+      kind: "local",
+      pid: await this.wrapper.processId().catch(() => {
+        return;
+      })
+    };
+  }
+  supportsReconnect(owner) {
+    return owner.kind === "daemon" || this.backend === "tmux";
+  }
+  async hasPendingInput() {
+    const jsonlPath = sessionPath(this.cwd, this.sessionId);
+    const pendingQuestion = await hasPendingQuestion(jsonlPath);
+    const pendingNativePrompt = hasPendingNativePrompt(await this.wrapper.capturePane().catch(() => ""));
+    return {
+      pending: pendingQuestion || pendingNativePrompt,
+      source: pendingQuestion || pendingNativePrompt ? "terminal" : "none"
+    };
+  }
+  async setModel(model) {
+    this._model = model;
+    this.wrapper.setModel(model);
+    await this.wrapper.send(`/model ${model}`);
+  }
+  async setPermissionMode(mode) {
+    this._permissionMode = mode;
+    this.wrapper.setPermissionMode(mode);
+    await this.wrapper.restart();
+    await this.syncSessionRecord();
+  }
+  async flushEvents() {
+    while (true) {
+      let pending = false;
+      for (const subscriber of this.subscribers) {
+        if (subscriber.queue.length > 0 || subscriber.inFlight > 0) {
+          pending = true;
+          break;
+        }
+      }
+      if (!pending) {
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
+  async* events() {
+    const subscriber = {
+      queue: [],
+      resolvers: [],
+      closed: false,
+      inFlight: 0
+    };
+    this.subscribers.add(subscriber);
+    try {
+      while (true) {
+        if (subscriber.queue.length > 0) {
+          const event = subscriber.queue.shift();
+          subscriber.inFlight++;
+          yield event;
+          subscriber.inFlight = Math.max(0, subscriber.inFlight - 1);
+          continue;
+        }
+        if (subscriber.closed)
+          return;
+        const result = await new Promise((resolve) => {
+          subscriber.resolvers.push(resolve);
+        });
+        if (result.done)
+          return;
+        yield result.value;
+        subscriber.inFlight = Math.max(0, subscriber.inFlight - 1);
+      }
+    } finally {
+      subscriber.closed = true;
+      this.subscribers.delete(subscriber);
+    }
+  }
+  emit(ev) {
+    for (const subscriber of this.subscribers) {
+      if (subscriber.closed)
+        continue;
+      const resolver = subscriber.resolvers.shift();
+      if (resolver) {
+        subscriber.inFlight++;
+        resolver({ value: ev, done: false });
+      } else {
+        subscriber.queue.push(ev);
+      }
+    }
+  }
+  newPromptWaiter(text) {
+    return {
+      text,
+      matchedUserEcho: false,
+      pendingTools: 0,
+      gotResponse: false,
+      turnEnded: false,
+      inputDeferred: false,
+      lastPendingTool: null,
+      consecutiveIdles: 0,
+      waiters: new Set
+    };
+  }
+  notifyPrompt(prompt) {
+    if (!prompt)
+      return;
+    for (const wake of prompt.waiters) {
+      wake();
+    }
+    prompt.waiters.clear();
+  }
+  async pumpEvents() {
+    try {
+      for await (const ev of this.wrapper.events()) {
+        this.emit(ev);
+        await this.handlePromptEvent(ev);
+      }
+    } catch (err) {
+      this.pumpError = err;
+      this.logger.error("session event pump failed", "sid", this.sessionId, err);
+    } finally {
+      this.pumpDone = true;
+      this.notifyPrompt(this.activePrompt);
+      this.closeSubscribers();
+    }
+  }
+  closeSubscribers() {
+    for (const subscriber of this.subscribers) {
+      subscriber.closed = true;
+      for (const resolver of subscriber.resolvers) {
+        resolver({ value: undefined, done: true });
+      }
+      subscriber.resolvers = [];
+    }
+    this.subscribers.clear();
+  }
+  async handlePromptEvent(ev) {
+    const prompt = this.activePrompt;
+    if (!prompt)
+      return;
+    if (!prompt.matchedUserEcho) {
+      if (ev.kind === "user_message" /* UserMessage */ && ev.text === prompt.text) {
+        prompt.matchedUserEcho = true;
+        this.notifyPrompt(prompt);
+      }
+      return;
+    }
+    switch (ev.kind) {
+      case "assistant_text" /* AssistantText */:
+        prompt.gotResponse = true;
+        break;
+      case "tool_call" /* ToolCall */:
+        prompt.pendingTools++;
+        if (ev.toolName === "AskUserQuestion") {
+          prompt.inputDeferred = await this.handleUserQuestion(ev);
+          prompt.pendingTools = Math.max(0, prompt.pendingTools - 1);
+          prompt.gotResponse = true;
+        } else {
+          prompt.lastPendingTool = {
+            name: ev.toolName,
+            id: ev.toolID,
+            input: ev.toolInput
+          };
+        }
+        break;
+      case "tool_result" /* ToolResult */:
+        prompt.pendingTools = Math.max(0, prompt.pendingTools - 1);
+        prompt.lastPendingTool = null;
+        prompt.gotResponse = true;
+        break;
+      case "turn_end" /* TurnEnd */:
+        prompt.gotResponse = true;
+        prompt.turnEnded = true;
+        break;
+      default:
+        break;
+    }
+    this.notifyPrompt(prompt);
+  }
+  waitForPromptUpdate(prompt, signal, timeoutMs) {
+    return new Promise((resolve) => {
+      if (signal.aborted) {
+        resolve("abort");
+        return;
+      }
+      if (this.pumpDone) {
+        resolve("done");
+        return;
+      }
+      let settled = false;
+      let timer;
+      const finish = (result) => {
+        if (settled)
+          return;
+        settled = true;
+        prompt.waiters.delete(onChange);
+        signal.removeEventListener("abort", onAbort);
+        if (timer)
+          clearTimeout(timer);
+        resolve(result);
+      };
+      const onChange = () => finish("changed");
+      const onAbort = () => finish("abort");
+      prompt.waiters.add(onChange);
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (timeoutMs != null) {
+        timer = setTimeout(() => finish("timeout"), timeoutMs);
+      }
+      if (this.pumpDone) {
+        finish("done");
+      }
+    });
+  }
+  async waitForPromptCompletion(prompt, signal) {
+    while (true) {
+      if (signal.aborted)
+        return "cancelled";
+      if (this.stopped)
+        return "cancelled";
+      if (this.pumpDone) {
+        if (this.pumpError) {
+          this.logger.warn("prompt ending after pump shutdown", "sid", this.sessionId);
+        }
+        return "end_turn";
+      }
+      if (prompt.inputDeferred) {
+        return "end_turn";
+      }
+      if (prompt.turnEnded && prompt.pendingTools <= 0) {
+        return "end_turn";
+      }
+      const result = await this.waitForPromptUpdate(prompt, signal, prompt.matchedUserEcho ? IDLE_TIMEOUT_MS : undefined);
+      if (result === "abort")
+        return "cancelled";
+      if (result === "done")
+        return "end_turn";
+      if (result === "changed") {
+        prompt.consecutiveIdles = 0;
+        continue;
+      }
+      if (result === "timeout") {
+        prompt.consecutiveIdles++;
+        if (!prompt.matchedUserEcho) {
+          continue;
+        }
+        if (prompt.inputDeferred) {
+          return "end_turn";
+        }
+        if (prompt.turnEnded && prompt.pendingTools <= 0) {
+          return "end_turn";
+        }
+        if (prompt.pendingTools > 0) {
+          const handled = await this.pollNativePermission(prompt.lastPendingTool);
+          if (handled) {
+            prompt.pendingTools = Math.max(0, prompt.pendingTools - 1);
+            prompt.gotResponse = true;
+            prompt.lastPendingTool = null;
+            this.notifyPrompt(prompt);
+          }
+          continue;
+        }
+        if (prompt.gotResponse && prompt.consecutiveIdles >= 2) {
+          return "end_turn";
+        }
+        continue;
+      }
+    }
+  }
+  async pollNativePermission(pendingTool) {
+    let paneText;
+    try {
+      paneText = await this.wrapper.capturePane();
+    } catch {
+      return false;
+    }
+    const prompt = parseNativePermissionPrompt(paneText);
+    if (!prompt)
+      return false;
+    const decision = await this.resolvePermission({
+      source: "native_prompt",
+      sessionId: this.sessionId,
+      toolCallId: pendingTool?.id ?? `native-perm-${Date.now()}`,
+      title: pendingTool ? `${pendingTool.name}: ${prompt.question}` : prompt.question,
+      kind: pendingTool ? mapToolKind(pendingTool.name) : "other",
+      content: [
+        ...pendingTool ? (() => {
+          const detail = formatToolDetail(pendingTool.name, pendingTool.input);
+          return detail ? [{ type: "text", text: detail }] : [];
+        })() : [],
+        { type: "text", text: prompt.question }
+      ],
+      options: prompt.options.map((opt) => ({
+        kind: opt.label.toLowerCase().startsWith("no") || opt.label.toLowerCase().startsWith("reject") ? "reject_once" : "allow_once",
+        optionId: opt.number,
+        name: opt.label
+      }))
+    });
+    if (decision.outcome === "deferred") {
+      return false;
+    }
+    if (decision.outcome === "cancelled") {
+      await this.wrapper.interrupt();
+      return true;
+    }
+    if (decision.outcome === "text") {
+      await this.wrapper.send(decision.text);
+      return true;
+    }
+    await this.wrapper.send(decision.optionId);
+    return true;
+  }
+  async handleUserQuestion(ev) {
+    const parsed = parseAskUserQuestion(ev.toolInput);
+    if (!parsed) {
+      this.logger.warn("AskUserQuestion parse failed", "sid", this.sessionId);
+      await this.wrapper.send("1");
+      return false;
+    }
+    for (const question of parsed.questions) {
+      const decision = await this.resolvePermission({
+        source: "ask_user_question",
+        sessionId: this.sessionId,
+        toolCallId: ev.toolID,
+        title: question.header || "Claude has a question",
+        kind: "other",
+        content: [{ type: "text", text: question.question }],
+        options: buildAskUserQuestionOptions(question, this.allowTextResponses)
+      });
+      if (decision.outcome === "deferred") {
+        return true;
+      }
+      if (decision.outcome === "cancelled") {
+        await this.wrapper.interrupt();
+        return false;
+      }
+      if (decision.outcome === "text") {
+        await this.wrapper.send(decision.text);
+        return false;
+      }
+      if (decision.optionId === "0") {
+        await this.wrapper.interrupt();
+        return false;
+      }
+      await this.wrapper.send(decision.optionId);
+    }
+    return false;
+  }
+  async resolvePermission(request) {
+    if (!this.onPermissionRequest) {
+      return { outcome: "cancelled" };
+    }
+    try {
+      return await this.onPermissionRequest(request);
+    } catch (err) {
+      this.logger.error("permission handler failed", err);
+      return { outcome: "cancelled" };
+    }
+  }
+}
+var __test = {
+  buildAskUserQuestionOptions,
+  createSession(wrapper, options = {}) {
+    return new ClaudrabandSessionImpl(wrapper, options.sessionId ?? "test-session", options.cwd ?? "/tmp", options.backend ?? "tmux", options.model ?? "sonnet", options.permissionMode ?? "default", options.allowTextResponses ?? false, options.logger ?? makeDefaultLogger(), options.onPermissionRequest, options.lifetime ?? new AbortController);
+  }
+};
+function buildAskUserQuestionOptions(question, allowTextResponses = false) {
+  return [
+    ...question.options.map((opt, i) => ({
+      kind: "allow_once",
+      optionId: String(i + 1),
+      name: opt.label + (opt.description ? ` — ${opt.description}` : "")
+    })),
+    ...allowTextResponses ? [{
+      kind: "allow_once",
+      optionId: String(question.options.length + 1),
+      name: "Type a response",
+      textInput: true
+    }] : [],
+    {
+      kind: "reject_once",
+      optionId: "0",
+      name: "Cancel"
+    }
+  ];
+}
+async function discoverSessions(cwdFilter) {
+  await reconcileLiveLocalSessions(cwdFilter);
+  const live = (await refreshSessionRecords(await listSessionRecords())).filter((record) => !cwdFilter || record.cwd === cwdFilter).map(sessionRecordToSummary);
+  const liveKeys = new Set(live.map((session) => `${session.sessionId}	${session.cwd}`));
+  const history = (await discoverHistoricalSessions(cwdFilter)).filter((session) => !liveKeys.has(`${session.sessionId}	${session.cwd}`));
+  return [...live, ...history].sort((left, right) => Number(right.alive) - Number(left.alive) || (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "") || left.sessionId.localeCompare(right.sessionId));
+}
+async function inspectSession(sessionId, cwd) {
+  await reconcileLiveLocalSessions(cwd);
+  const record = await readSessionRecord(sessionId);
+  if (record && (!cwd || record.cwd === cwd)) {
+    const refreshed = await refreshSessionRecords([record]);
+    if (refreshed[0]) {
+      return sessionRecordToSummary(refreshed[0]);
+    }
+  }
+  const history = await discoverHistoricalSessions(cwd);
+  const matches = history.filter((session) => session.sessionId === sessionId);
+  return matches[0] ?? null;
+}
+async function closeSessionByRecord(sessionId) {
+  await reconcileLiveLocalSessions();
+  const record = await readSessionRecord(sessionId);
+  if (!record)
+    return false;
+  const [refreshed] = await refreshSessionRecords([record]);
+  if (!refreshed?.lastKnownAlive) {
+    return false;
+  }
+  let closed = false;
+  if (refreshed.owner.kind === "daemon") {
+    closed = await closeDaemonSession(refreshed.owner.serverUrl, refreshed.sessionId);
+  } else if (refreshed.backend === "tmux") {
+    closed = await createTerminalBackendDriver({
+      backend: "tmux",
+      tmuxSessionName: SHARED_TMUX_SESSION
+    }).closeLiveSession(refreshed.sessionId);
+  } else if (isPidAlive(refreshed.owner.pid)) {
+    try {
+      process.kill(refreshed.owner.pid);
+      closed = true;
+    } catch {
+      closed = false;
+    }
+  }
+  if (closed) {
+    await deleteSessionRecord(sessionId);
+  }
+  return closed;
+}
+async function reconcileLiveLocalSessions(cwdFilter) {
+  const discovered = await discoverLegacyLiveSessions(createTerminalBackendDriver({
+    backend: "tmux",
+    tmuxSessionName: SHARED_TMUX_SESSION
+  }), cwdFilter);
+  for (const session of discovered) {
+    const existing = await readSessionRecord(session.sessionId);
+    const known = await readKnownSessionRecord(session.sessionId);
+    const transcriptPath = sessionPath(session.cwd, session.sessionId);
+    const title = existing?.title ?? known?.title ?? session.title;
+    const createdAt = existing?.createdAt ?? known?.createdAt ?? session.createdAt;
+    const updatedAt = session.updatedAt ?? existing?.updatedAt ?? known?.updatedAt ?? session.createdAt;
+    await writeKnownSessionRecord({
+      version: 1,
+      sessionId: session.sessionId,
+      cwd: session.cwd,
+      backend: session.backend,
+      title,
+      createdAt,
+      updatedAt,
+      transcriptPath
+    });
+    await writeSessionRecord({
+      version: 1,
+      sessionId: session.sessionId,
+      cwd: session.cwd,
+      backend: session.backend,
+      title,
+      createdAt,
+      updatedAt,
+      lastKnownAlive: true,
+      reattachable: session.reattachable,
+      transcriptPath,
+      owner: {
+        kind: "local",
+        pid: session.owner.kind === "local" ? session.owner.pid : undefined
+      }
+    });
+  }
+}
+async function discoverHistoricalSessions(cwdFilter) {
+  const records = (await listKnownSessionRecords()).filter((record) => !cwdFilter || record.cwd === cwdFilter);
+  const results = [];
+  for (const record of records) {
+    const transcriptPath = record.transcriptPath ?? sessionPath(record.cwd, record.sessionId);
+    try {
+      const fileStat = await stat2(transcriptPath);
+      if (fileStat.size < 100)
+        continue;
+      results.push({
+        sessionId: record.sessionId,
+        cwd: record.cwd,
+        title: record.title ?? await extractSessionTitle(transcriptPath) ?? undefined,
+        createdAt: record.createdAt || fileStat.birthtime.toISOString(),
+        updatedAt: fileStat.mtime.toISOString(),
+        backend: record.backend,
+        source: "history",
+        alive: false,
+        reattachable: false,
+        owner: { kind: "local" }
+      });
+    } catch {
+      continue;
+    }
+  }
+  return results;
+}
+async function discoverLegacyLiveSessions(backendDriver, cwdFilter) {
+  try {
+    const windows = await backendDriver.listLiveSessions();
+    const results = [];
+    for (const window of windows) {
+      if (!isSessionId(window.sessionId))
+        continue;
+      if (!window.cwd)
+        continue;
+      if (cwdFilter && window.cwd !== cwdFilter)
+        continue;
+      results.push({
+        sessionId: window.sessionId,
+        cwd: window.cwd,
+        createdAt: window.updatedAt ?? new Date().toISOString(),
+        updatedAt: window.updatedAt,
+        backend: backendDriver.backend,
+        source: "live",
+        alive: true,
+        reattachable: backendDriver.supportsLiveReconnect(),
+        owner: {
+          kind: "local",
+          pid: window.pid
+        }
+      });
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+async function refreshSessionRecords(records) {
+  const tmuxDriver = createTerminalBackendDriver({
+    backend: "tmux",
+    tmuxSessionName: SHARED_TMUX_SESSION
+  });
+  const tmuxWindows = await tmuxDriver.listLiveSessions().catch(() => []);
+  const tmuxById = new Map(tmuxWindows.map((window) => [window.sessionId, window]));
+  const daemonByUrl = new Map;
+  const refreshed = [];
+  for (const record of records) {
+    const metadata = await readRecordMetadata(record);
+    let next = {
+      ...record,
+      transcriptPath: metadata.transcriptPath,
+      title: metadata.title,
+      updatedAt: metadata.updatedAt ?? record.updatedAt
+    };
+    if (record.owner.kind === "daemon") {
+      const serverUrl = normalizeServerUrl(record.owner.serverUrl);
+      if (!daemonByUrl.has(serverUrl)) {
+        daemonByUrl.set(serverUrl, isPidAlive(record.owner.serverPid) ? await fetchDaemonSessionStates(serverUrl) : null);
+      }
+      const daemonSessions = daemonByUrl.get(serverUrl);
+      const alive = daemonSessions?.get(record.sessionId) ?? false;
+      next = {
+        ...next,
+        owner: {
+          ...record.owner,
+          serverUrl
+        },
+        lastKnownAlive: alive,
+        reattachable: alive
+      };
+    } else if (record.backend === "tmux") {
+      const liveWindow = tmuxById.get(record.sessionId);
+      next = {
+        ...next,
+        owner: {
+          kind: "local",
+          pid: liveWindow?.pid ?? record.owner.pid
+        },
+        lastKnownAlive: liveWindow !== undefined,
+        reattachable: liveWindow !== undefined
+      };
+    } else {
+      const alive = isPidAlive(record.owner.pid);
+      next = {
+        ...next,
+        lastKnownAlive: alive,
+        reattachable: false
+      };
+    }
+    if (!next.lastKnownAlive) {
+      await deleteSessionRecord(record.sessionId);
+      continue;
+    }
+    if (!sessionRecordsEqual(record, next)) {
+      await writeSessionRecord(next);
+    }
+    refreshed.push(next);
+  }
+  return refreshed;
+}
+async function readRecordMetadata(record) {
+  const transcriptPath = record.transcriptPath ?? sessionPath(record.cwd, record.sessionId);
+  try {
+    const transcriptStat = await stat2(transcriptPath);
+    return {
+      transcriptPath,
+      title: record.title ?? await extractSessionTitle(transcriptPath) ?? undefined,
+      updatedAt: transcriptStat.mtime.toISOString()
+    };
+  } catch {
+    return {
+      transcriptPath,
+      title: record.title,
+      updatedAt: record.updatedAt
+    };
+  }
+}
+function sessionRecordToSummary(record) {
+  return {
+    sessionId: record.sessionId,
+    cwd: record.cwd,
+    title: record.title,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt,
+    backend: record.backend,
+    source: "live",
+    alive: record.lastKnownAlive,
+    reattachable: record.reattachable,
+    owner: record.owner
+  };
+}
+function sessionRecordsEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function isSessionId(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(value);
+}
+async function fetchDaemonSessionStates(serverUrl) {
+  try {
+    const result = await daemonRequest(serverUrl, "GET", "/sessions");
+    const sessions = new Map;
+    for (const session of result.sessions ?? []) {
+      sessions.set(session.sessionId, session.alive);
+    }
+    return sessions;
+  } catch {
+    return null;
+  }
+}
+async function closeDaemonSession(serverUrl, sessionId) {
+  try {
+    await daemonRequest(serverUrl, "DELETE", `/sessions/${sessionId}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function daemonRequest(serverUrl, method, path) {
+  const url = new URL(path, normalizeServerUrl(serverUrl));
+  return new Promise((resolve, reject) => {
+    const req = httpRequest({
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname,
+      method
+    }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const text = Buffer.concat(chunks).toString();
+        if ((res.statusCode ?? 500) >= 400) {
+          reject(new Error(text || `request failed with status ${res.statusCode}`));
+          return;
+        }
+        if (!text) {
+          resolve({});
+          return;
+        }
+        try {
+          resolve(JSON.parse(text));
+        } catch {
+          resolve(text);
+        }
+      });
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+async function extractSessionTitle(filePath) {
+  try {
+    const buf = Buffer.alloc(4096);
+    const fh = await open2(filePath, "r");
+    const { bytesRead } = await fh.read(buf, 0, 4096, 0);
+    await fh.close();
+    for (const line of buf.toString("utf-8", 0, bytesRead).split(`
+`)) {
+      if (!line.trim())
+        continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type !== "user" || !obj.message?.content)
+          continue;
+        const content = typeof obj.message.content === "string" ? obj.message.content : obj.message.content.filter((block) => block.type === "text").map((block) => block.text ?? "").join(" ");
+        return content.length > 80 ? `${content.slice(0, 77)}...` : content;
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function mapToolKind(toolName) {
+  switch (toolName) {
+    case "Read":
+    case "ReadFile":
+    case "read_file":
+      return "read";
+    case "Write":
+    case "WriteFile":
+    case "write_to_file":
+    case "Edit":
+    case "EditFile":
+    case "str_replace_editor":
+    case "MultiEdit":
+    case "NotebookEdit":
+      return "edit";
+    case "Bash":
+    case "bash":
+    case "execute_command":
+      return "execute";
+    case "Grep":
+    case "Glob":
+    case "Search":
+    case "grep":
+    case "search":
+    case "find_file":
+    case "list_files":
+      return "search";
+    case "WebFetch":
+    case "WebSearch":
+    case "web_fetch":
+    case "fetch":
+      return "fetch";
+    case "Think":
+    case "think":
+      return "think";
+    default:
+      return "other";
+  }
+}
+function formatToolDetail(toolName, toolInput) {
+  let parsed;
+  try {
+    parsed = JSON.parse(toolInput);
+  } catch {
+    return null;
+  }
+  switch (toolName) {
+    case "Write": {
+      const filePath = String(parsed.file_path ?? parsed.path ?? "");
+      const content = String(parsed.content ?? "");
+      return `**${filePath}**
+\`\`\`
+${content}
+\`\`\``;
+    }
+    case "Edit": {
+      const filePath = String(parsed.file_path ?? parsed.path ?? "");
+      const oldStr = String(parsed.old_string ?? "");
+      const newStr = String(parsed.new_string ?? "");
+      return `**${filePath}**
+\`\`\`diff
+- ${oldStr.split(`
+`).join(`
+- `)}
++ ${newStr.split(`
+`).join(`
++ `)}
+\`\`\``;
+    }
+    case "Bash":
+      return `\`\`\`bash
+${String(parsed.command ?? "")}
+\`\`\``;
+    default:
+      return `\`\`\`json
+${JSON.stringify(parsed, null, 2)}
+\`\`\``;
+  }
+}
+function parseAskUserQuestion(rawInput) {
+  try {
+    const parsed = JSON.parse(rawInput);
+    if (!parsed.questions || parsed.questions.length === 0)
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+export {
+  sessionPath,
+  resolveTerminalBackend,
+  parseClaudeArgs,
+  hasPendingQuestion,
+  hasPendingNativePrompt,
+  hasLiveProcess,
+  createClaudraband,
+  closeLiveProcess,
+  awaitPaneIdle,
+  __test,
+  TERMINAL_BACKENDS,
+  PERMISSION_MODES,
+  MODEL_OPTIONS,
+  EventKind
+};