@kodizm/acp 0.7.0 → 0.8.0

package/dist/index.js

@@ -52133,10 +52133,2367 @@ var init_driver2 = __esm(() => {
   };
   logger = createLogger({ env: process.env });
 });
+
+// src/live/redact.ts
+function redact(text, knownValues) {
+  const values = knownValues.filter((value) => value !== "").sort((left, right) => right.length - left.length);
+  let result = text;
+  for (const value of values) {
+    result = result.replaceAll(value, REDACTED);
+  }
+  for (const pattern of CREDENTIAL_PATTERNS) {
+    result = result.replace(pattern, REDACTED);
+  }
+  return result.replace(URL_CREDENTIAL, `$1${REDACTED}@`);
+}
+var REDACTED = "[REDACTED]", CREDENTIAL_PATTERNS, URL_CREDENTIAL;
+var init_redact = __esm(() => {
+  CREDENTIAL_PATTERNS = [
+    /kgw-[A-Za-z0-9]{8,}/g,
+    /sk-ant-[\w-]+/g,
+    /kdz-int-jwt\.[\w.-]+/g,
+    /-----BEGIN[\s\S]*?(?:-----END[^\n]*?-----|$)/g
+  ];
+  URL_CREDENTIAL = /(x-access-token:)[^@\s/]+@/g;
+});
+
+// src/live/events.ts
+function redactDeep(value, knownValues) {
+  if (typeof value === "string") {
+    return redact(value, knownValues);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactDeep(item, knownValues));
+  }
+  if (isRecord(value)) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactDeep(item, knownValues)]));
+  }
+  return value;
+}
+function sessionStarted(hook, source) {
+  return draft("session_started", {
+    claudeSessionId: text(hook.session_id),
+    model: text(hook.model),
+    source
+  });
+}
+function turnStarted(promptId) {
+  return draft("turn_started", { promptId });
+}
+function turnCompleted(stopReason, lastAssistantMessage) {
+  return draft("turn_completed", {
+    stopReason,
+    lastAssistantMessage
+  });
+}
+function apiStopReason(reason) {
+  return reason !== null && API_STOP_REASONS.has(reason) ? reason : "end_turn";
+}
+function turnFailed(hook) {
+  const error = text(hook.error) ?? "unknown";
+  const details = text(hook.error_details);
+  return draft("turn_failed", {
+    reason: FAILURE_REASONS[error] ?? "api_error",
+    detail: details === undefined ? `StopFailure ${error}` : `StopFailure ${error}: ${details}`.slice(0, TITLE_MAX * 2)
+  });
+}
+function sessionEnded(reason) {
+  return draft("session_ended", { reason });
+}
+function toolCallBegin(hook, toolCallId) {
+  return draft("tool_call_begin", {
+    toolCallId,
+    name: text(hook.tool_name),
+    input: hook.tool_input
+  });
+}
+function toolCallEnd(toolCallId, status, output) {
+  return draft("tool_call_end", {
+    toolCallId,
+    status,
+    output
+  });
+}
+function toolOutput(response) {
+  if (response === undefined || response === null) {
+    return;
+  }
+  if (typeof response === "string") {
+    return response.slice(0, OUTPUT_MAX);
+  }
+  if (isRecord(response) && typeof response.stdout === "string") {
+    const stderr = typeof response.stderr === "string" && response.stderr !== "" ? `
+${response.stderr}` : "";
+    return `${response.stdout}${stderr}`.slice(0, OUTPUT_MAX);
+  }
+  return JSON.stringify(response).slice(0, OUTPUT_MAX);
+}
+function permissionRequest(hook, toolCallId) {
+  const name = text(hook.tool_name) ?? "unknown";
+  return {
+    toolCallId,
+    title: toolTitle(name, hook.tool_input),
+    kind: TOOL_KINDS[name] ?? "other",
+    rawInput: hook.tool_input ?? null,
+    options: PERMISSION_OPTIONS
+  };
+}
+function subagentSpawn(hook) {
+  const type = text(hook.agent_type);
+  return draft("subagent_spawn", {
+    subagent_id: text(hook.agent_id),
+    subagent_type: type === undefined || type === "" ? "general-purpose" : type
+  });
+}
+function subagentComplete(hook) {
+  return draft("subagent_complete", {
+    subagent_id: text(hook.agent_id)
+  });
+}
+function compactionStarted(hook) {
+  return draft("compaction_started", {
+    trigger: hook.trigger === "auto" ? "auto" : "manual"
+  });
+}
+function compactionCompleted(hook) {
+  return draft("compaction_completed", {
+    succeeded: true,
+    trigger: hook.trigger === "auto" ? "auto" : "manual"
+  });
+}
+function usage(counts) {
+  return draft("usage", { ...counts });
+}
+function outputChunk(chunk) {
+  return draft("output_chunk", { text: chunk });
+}
+function thinkingChunk(chunk) {
+  return draft("thinking_chunk", { text: chunk });
+}
+function heartbeat() {
+  return draft("heartbeat", {});
+}
+function processDied() {
+  return draft("process_died", { exitCode: null });
+}
+function sessionFailed(reason, detail) {
+  return draft("session_failed", {
+    reason,
+    detail
+  });
+}
+function text(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toolTitle(name, input) {
+  if (!isRecord(input)) {
+    return name;
+  }
+  const field = TITLE_FIELDS.find((key) => typeof input[key] === "string" && input[key] !== "");
+  const subject = field === undefined ? JSON.stringify(input) : input[field];
+  return `${name}: ${subject}`.slice(0, TITLE_MAX);
+}
+function draft(type, payload) {
+  return {
+    type,
+    payload: Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== undefined))
+  };
+}
+var PERMISSION_OPTIONS, API_STOP_REASONS, TOOL_KINDS, TITLE_FIELDS, TITLE_MAX = 200, OUTPUT_MAX = 16000, FAILURE_REASONS;
+var init_events2 = __esm(() => {
+  init_redact();
+  PERMISSION_OPTIONS = [
+    {
+      optionId: "allow",
+      kind: "allow_once"
+    },
+    {
+      optionId: "deny",
+      kind: "reject_once"
+    }
+  ];
+  API_STOP_REASONS = new Set(["end_turn", "max_tokens", "refusal"]);
+  TOOL_KINDS = {
+    Bash: "execute",
+    BashOutput: "execute",
+    KillShell: "execute",
+    Edit: "edit",
+    MultiEdit: "edit",
+    Write: "edit",
+    NotebookEdit: "edit",
+    Read: "read",
+    Glob: "search",
+    Grep: "search",
+    WebFetch: "fetch",
+    WebSearch: "fetch"
+  };
+  TITLE_FIELDS = ["command", "file_path", "notebook_path", "path", "url", "pattern", "query", "description"];
+  FAILURE_REASONS = {
+    rate_limit: "rate_limit",
+    authentication_failed: "auth_error",
+    oauth_org_not_allowed: "auth_error",
+    account_on_hold: "auth_error",
+    billing_error: "auth_error",
+    cloud_credential_error: "auth_error"
+  };
+});
+
+// src/live/hooks.ts
+import { readFile as readFile2, rename as rename3, writeFile } from "fs/promises";
+import { createConnection } from "net";
+async function buildPaneSettings(options) {
+  const base = JSON.parse(await readFile2(options.basePath, "utf8"));
+  if (!isRecord2(base)) {
+    throw new Error(`${options.basePath} does not hold a JSON object`);
+  }
+  const hooks = Object.fromEntries(HOOK_EVENTS.map((event) => [
+    event,
+    [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: hookCommand(options, event),
+            timeout: event === "PermissionRequest" ? PERMISSION_HOOK_TIMEOUT_S : HOOK_TIMEOUT_S
+          }
+        ]
+      }
+    ]
+  ]));
+  return {
+    ...base,
+    disableAllHooks: false,
+    hooks
+  };
+}
+async function writePaneSettings(path, options) {
+  const settings = await buildPaneSettings(options);
+  const staging = `${path}.${process.pid}.tmp`;
+  await writeFile(staging, JSON.stringify(settings, null, 2), { mode: 384 });
+  await rename3(staging, path);
+}
+async function runHookHelper(options) {
+  const payload = parseObject(options.input);
+  if (payload === null) {
+    return "";
+  }
+  const blocking = options.event === "PermissionRequest";
+  const timeoutMs = options.timeoutMs ?? (blocking ? PERMISSION_HELPER_TIMEOUT_MS : HELPER_TIMEOUT_MS);
+  let response;
+  try {
+    response = await socketRequest(options.socketPath, {
+      kind: "hook",
+      pane: options.paneId,
+      event: options.event,
+      payload
+    }, timeoutMs);
+  } catch (error) {
+    if (error instanceof SocketRequestError) {
+      process.stderr.write(`${JSON.stringify({ level: "warn", message: error.message, event: options.event })}
+`);
+      return "";
+    }
+    throw error;
+  }
+  return blocking && isRecord2(response) ? hookDecisionOutput(response.decision) : "";
+}
+function hookDecisionOutput(decision) {
+  if (!isRecord2(decision) || decision.behavior !== "allow" && decision.behavior !== "deny") {
+    return "";
+  }
+  const answer = {
+    behavior: decision.behavior
+  };
+  if (decision.behavior === "deny" && typeof decision.message === "string") {
+    answer.message = decision.message;
+  }
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PermissionRequest",
+      decision: answer
+    }
+  });
+}
+function socketRequest(path, message, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(path);
+    let buffer = "";
+    let settled = false;
+    const finish = (outcome) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      outcome();
+    };
+    const timer = setTimeout(() => finish(() => reject(new SocketRequestError("timeout"))), timeoutMs);
+    let connected = false;
+    socket.on("connect", () => {
+      connected = true;
+      socket.write(`${JSON.stringify(message)}
+`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      const newline = buffer.indexOf(`
+`);
+      if (newline === -1) {
+        return;
+      }
+      const answer = parseJson(buffer.slice(0, newline));
+      finish(() => answer === undefined ? reject(new SocketRequestError("malformed")) : resolve(answer.value));
+    });
+    socket.on("error", (error) => finish(() => reject(new SocketRequestError(connected ? "closed" : "unreachable", error.message))));
+    socket.on("close", () => finish(() => reject(new SocketRequestError(connected ? "closed" : "unreachable"))));
+  });
+}
+function shellQuote(argument) {
+  return `'${argument.replaceAll("'", "'\\''")}'`;
+}
+function hookCommand(options, event) {
+  return [...options.helperArgv, "tmuxd", "hook", event, "--pane", options.paneId, "--socket", options.socketPath].map(shellQuote).join(" ");
+}
+function parseObject(text) {
+  const parsed = parseJson(text);
+  return parsed !== undefined && isRecord2(parsed.value) ? parsed.value : null;
+}
+function parseJson(text) {
+  try {
+    return { value: JSON.parse(text) };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return;
+    }
+    throw error;
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var HOOK_EVENTS, DEFAULT_BASE_SETTINGS_PATH = "/home/agent/.claude/kodizm-live-base.json", HOOK_TIMEOUT_S = 10, PERMISSION_HOOK_TIMEOUT_S = 3600, HELPER_TIMEOUT_MS = 3000, PERMISSION_HELPER_TIMEOUT_MS, SocketRequestError;
+var init_hooks = __esm(() => {
+  HOOK_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PermissionRequest",
+    "PermissionDenied",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "Stop",
+    "StopFailure",
+    "SessionEnd",
+    "SubagentStart",
+    "SubagentStop",
+    "PreCompact",
+    "PostCompact"
+  ];
+  PERMISSION_HELPER_TIMEOUT_MS = PERMISSION_HOOK_TIMEOUT_S * 1000 - 5000;
+  SocketRequestError = class SocketRequestError extends Error {
+    reason;
+    constructor(reason, detail) {
+      super(detail === undefined ? `daemon socket ${reason}` : `daemon socket ${reason}: ${detail}`);
+      this.name = "SocketRequestError";
+      this.reason = reason;
+    }
+  };
+});
+
+// src/live/input.ts
+function sanitizePrompt(text) {
+  let sanitized = "";
+  for (const char of text.replaceAll("\t", TAB_REPLACEMENT)) {
+    if (!isStrippedControl(char.charCodeAt(0))) {
+      sanitized += char;
+    }
+  }
+  const first = sanitized.trimStart().charAt(0);
+  if (first === "") {
+    throw new InputRejectedError("empty");
+  }
+  if (first === "!") {
+    throw new InputRejectedError("bash_mode");
+  }
+  if (first === "/") {
+    throw new InputRejectedError("slash_command");
+  }
+  return sanitized;
+}
+function isStrippedControl(code) {
+  return code <= 31 && code !== 10 || code >= 127 && code <= 159;
+}
+function sanitizeCommand(command) {
+  const trimmed = command.trim();
+  if (BARE_COMMANDS.has(trimmed)) {
+    return trimmed;
+  }
+  if (trimmed !== "/model" && !trimmed.startsWith("/model ")) {
+    throw new InputRejectedError("unknown_command");
+  }
+  const alias = trimmed.slice("/model ".length);
+  if (!MODEL_NAME.test(alias)) {
+    throw new InputRejectedError("invalid_model_alias");
+  }
+  return `/model ${alias}`;
+}
+var InputRejectedError, TAB_REPLACEMENT = "    ", MODEL_NAME, BARE_COMMANDS;
+var init_input = __esm(() => {
+  InputRejectedError = class InputRejectedError extends Error {
+    reason;
+    constructor(reason) {
+      super(`input rejected: ${reason}`);
+      this.name = "InputRejectedError";
+      this.reason = reason;
+    }
+  };
+  MODEL_NAME = /^[A-Za-z0-9._:[\]-]{1,64}$/;
+  BARE_COMMANDS = new Set(["/compact", "/clear"]);
+});
+
+// src/live/pane.ts
+import { mkdir as mkdir3, readFile as readFile3, realpath as realpath3, rename as rename4, writeFile as writeFile2 } from "fs/promises";
+import { join as join6 } from "path";
+function supportsPasteBufferS(versionOutput) {
+  const match = /^tmux (?:next-)?(\d+)\.(\d+)[a-z]?$/.exec(versionOutput.trim());
+  if (match === null) {
+    return false;
+  }
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return major > PASTE_S_SINCE[0] || major === PASTE_S_SINCE[0] && minor >= PASTE_S_SINCE[1];
+}
+async function createPane(options) {
+  const pane = {
+    id: options.id,
+    socket: options.socket ?? LIVE_SOCKET
+  };
+  if (!PANE_ID.test(pane.id)) {
+    throw new PaneError("invalid_pane_id");
+  }
+  if (options.resumeSessionId !== undefined && !RESUME_ID.test(options.resumeSessionId)) {
+    throw new PaneError("invalid_resume_id");
+  }
+  if (options.model !== undefined && (!MODEL_NAME.test(options.model) || options.model.startsWith("-"))) {
+    throw new PaneError("invalid_model");
+  }
+  const env = paneEnv(options);
+  const cwd = await realpath3(options.cwd);
+  await seedTrust(env.CLAUDE_CONFIG_DIR === undefined ? [env.HOME] : [env.HOME, env.CLAUDE_CONFIG_DIR], cwd);
+  const { PATH: path, TERM: term, ...sessionEnv } = env;
+  const created = await run(pane.socket, [
+    "start-server",
+    ";",
+    "set-option",
+    "-g",
+    "default-terminal",
+    term,
+    ";",
+    "new-session",
+    "-d",
+    "-s",
+    pane.id,
+    "-x",
+    "200",
+    "-y",
+    "50",
+    "-c",
+    cwd,
+    ...Object.entries(sessionEnv).flatMap(([name, value]) => ["-e", `${name}=${value}`]),
+    "--",
+    ...launchArgv(options)
+  ], { path });
+  if (created.exitCode !== 0) {
+    throw new PaneError("tmux_failed", created.stderr);
+  }
+  if (options.confirmStarted !== undefined && !await options.confirmStarted(SESSION_START_TIMEOUT_MS)) {
+    await killPane(pane);
+    throw new PaneError("start_timeout");
+  }
+  return pane;
+}
+async function deliverPrompt(pane, text, confirmSubmitted, abortIf) {
+  const payload = sanitizePrompt(text);
+  bufferSequence += 1;
+  const buffer = `${pane.id}-${bufferSequence}`;
+  await runOnPane(pane, ["load-buffer", "-b", buffer, "-"], new TextEncoder().encode(payload));
+  const flags = await pasteKeepsControlBytes() ? ["-p", "-d", "-r", "-S"] : ["-p", "-d", "-r"];
+  const pasted = await run(pane.socket, ["paste-buffer", ...flags, "-b", buffer, "-t", paneTarget(pane)]);
+  if (pasted.exitCode !== 0) {
+    await run(pane.socket, ["delete-buffer", "-b", buffer]);
+    await failOnPane(pane, pasted.stderr);
+  }
+  await Bun.sleep(PASTE_ENTER_DELAY_MS);
+  for (const windowMs of SUBMIT_WINDOWS_MS) {
+    if (abortIf?.() === true) {
+      return await confirmSubmitted(0) ? "submitted" : "aborted";
+    }
+    await runOnPane(pane, ["send-keys", "-t", paneTarget(pane), "Enter"]);
+    if (await confirmSubmitted(windowMs)) {
+      return "submitted";
+    }
+  }
+  throw new PaneError("not_submitted");
+}
+async function deliverCommand(pane, command) {
+  const typed = sanitizeCommand(command);
+  await runOnPane(pane, ["send-keys", "-t", paneTarget(pane), "-l", "--", typed]);
+  await Bun.sleep(PASTE_ENTER_DELAY_MS);
+  await runOnPane(pane, ["send-keys", "-t", paneTarget(pane), "Enter"]);
+}
+async function cancelPane(pane) {
+  await runOnPane(pane, ["send-keys", "-t", paneTarget(pane), "Escape"]);
+  await Bun.sleep(CANCEL_CLEAR_DELAY_MS);
+  await runOnPane(pane, ["send-keys", "-t", paneTarget(pane), "C-u"]);
+}
+async function paneAlive(pane) {
+  return (await run(pane.socket, ["has-session", "-t", sessionTarget(pane)])).exitCode === 0;
+}
+async function killPane(pane) {
+  const result = await run(pane.socket, ["kill-session", "-t", sessionTarget(pane)]);
+  if (result.exitCode !== 0 && await paneAlive(pane)) {
+    throw new PaneError("tmux_failed", result.stderr);
+  }
+}
+function paneEnv(options) {
+  const env = {
+    PATH: process.env.PATH ?? "/usr/bin:/bin"
+  };
+  for (const [name, value] of Object.entries(options.env ?? {})) {
+    if (!DROPPED_ENV.has(name)) {
+      env[name] = value;
+    }
+  }
+  return {
+    ...env,
+    HOME: options.home,
+    CI: "1",
+    TERM: "xterm-256color"
+  };
+}
+function launchArgv(options) {
+  const argv = [options.claudeBin ?? "claude", "--settings", options.settingsPath, "--setting-sources", "user"];
+  if (options.model !== undefined) {
+    argv.push("--model", options.model);
+  }
+  if (options.resumeSessionId !== undefined) {
+    argv.push("--resume", options.resumeSessionId);
+  }
+  return argv;
+}
+async function seedTrust(dirs, cwd) {
+  for (const dir of dirs) {
+    const path = join6(dir, ".claude.json");
+    const config = await readConfig(path);
+    const projects = isRecord3(config.projects) ? config.projects : {};
+    const project = isRecord3(projects[cwd]) ? projects[cwd] : {};
+    projects[cwd] = {
+      allowedTools: [],
+      ...project,
+      hasTrustDialogAccepted: true,
+      hasCompletedProjectOnboarding: true
+    };
+    const seeded = {
+      theme: "dark",
+      ...config,
+      hasCompletedOnboarding: true,
+      projects
+    };
+    await mkdir3(dir, { recursive: true });
+    const staging = `${path}.${process.pid}.tmp`;
+    await writeFile2(staging, JSON.stringify(seeded, null, 2), { mode: 384 });
+    await rename4(staging, path);
+  }
+}
+async function readConfig(path) {
+  const file = Bun.file(path);
+  if (!await file.exists()) {
+    return {};
+  }
+  const config = JSON.parse(await readFile3(path, "utf8"));
+  if (!isRecord3(config)) {
+    throw new Error(`${path} does not hold a JSON object`);
+  }
+  return config;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sessionTarget(pane) {
+  return `=${pane.id}`;
+}
+function paneTarget(pane) {
+  return `=${pane.id}:`;
+}
+function tmuxBinary() {
+  const binary = Bun.which("tmux");
+  if (binary === null) {
+    throw new PaneError("tmux_failed", "tmux is not on PATH");
+  }
+  return binary;
+}
+function pasteKeepsControlBytes() {
+  const binary = tmuxBinary();
+  let known = pasteSFlags.get(binary);
+  if (known === undefined) {
+    known = tmuxVersion(binary).then(supportsPasteBufferS);
+    pasteSFlags.set(binary, known);
+  }
+  return known;
+}
+async function tmuxVersion(binary) {
+  const child = Bun.spawn([binary, "-V"], {
+    env: {
+      PATH: process.env.PATH ?? "/usr/bin:/bin"
+    },
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "ignore"
+  });
+  const [exitCode, output] = await Promise.all([child.exited, new Response(child.stdout).text()]);
+  return exitCode === 0 ? output : "";
+}
+async function run(socket, args, options = {}) {
+  const binary = tmuxBinary();
+  const env = {
+    PATH: options.path ?? process.env.PATH ?? "/usr/bin:/bin"
+  };
+  if (process.env.TMUX_TMPDIR !== undefined) {
+    env.TMUX_TMPDIR = process.env.TMUX_TMPDIR;
+  }
+  const child = Bun.spawn([binary, "-L", socket, "-f", "/dev/null", ...args], {
+    env,
+    stdin: options.stdin ?? "ignore",
+    stdout: "ignore",
+    stderr: "pipe"
+  });
+  const [exitCode, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+  return {
+    exitCode,
+    stderr: stderr.trim()
+  };
+}
+async function runOnPane(pane, args, stdin) {
+  const result = await run(pane.socket, args, { stdin });
+  if (result.exitCode !== 0) {
+    await failOnPane(pane, result.stderr);
+  }
+}
+async function failOnPane(pane, stderr) {
+  if (!await paneAlive(pane)) {
+    throw new PaneError("pane_dead");
+  }
+  throw new PaneError("tmux_failed", stderr);
+}
+var LIVE_SOCKET = "kodizm-live", PASTE_ENTER_DELAY_MS = 328, SUBMIT_WINDOWS_MS, SESSION_START_TIMEOUT_MS = 1e4, CANCEL_CLEAR_DELAY_MS = 414, PANE_ID, RESUME_ID, DROPPED_ENV, PASTE_S_SINCE, PaneError, bufferSequence = 0, pasteSFlags;
+var init_pane = __esm(() => {
+  init_input();
+  SUBMIT_WINDOWS_MS = [328, 656, 1312, 2624];
+  PANE_ID = /^[A-Za-z0-9_-]{1,64}$/;
+  RESUME_ID = /^[A-Za-z0-9][A-Za-z0-9-]{0,127}$/;
+  DROPPED_ENV = new Set(["CLAUDE_CODE_SESSION_ID", "CLAUDE_CODE_CHILD_SESSION"]);
+  PASTE_S_SINCE = [3, 7];
+  PaneError = class PaneError extends Error {
+    reason;
+    constructor(reason, detail) {
+      super(detail === undefined ? `pane ${reason}` : `pane ${reason}: ${detail}`);
+      this.name = "PaneError";
+      this.reason = reason;
+    }
+  };
+  pasteSFlags = new Map;
+});
+
+// src/live/transcript.ts
+import { stat as stat2 } from "fs/promises";
+
+class TranscriptTail {
+  path;
+  skipped = 0;
+  offset;
+  pending = new Uint8Array(0);
+  constructor(path, offset = 0) {
+    this.path = path;
+    this.offset = offset;
+  }
+  static async atEnd(path) {
+    const file = Bun.file(path);
+    return new TranscriptTail(path, await file.exists() ? file.size : 0);
+  }
+  async poll() {
+    const size = await fileSize(this.path);
+    if (size === null) {
+      return [];
+    }
+    if (size < this.offset) {
+      this.offset = 0;
+      this.pending = new Uint8Array(0);
+    }
+    if (size === this.offset) {
+      return [];
+    }
+    const chunk = new Uint8Array(await Bun.file(this.path).slice(this.offset, size).arrayBuffer());
+    this.offset += chunk.byteLength;
+    const bytes = concat(this.pending, chunk);
+    const end = bytes.lastIndexOf(NEWLINE);
+    if (end === -1) {
+      this.pending = bytes;
+      return [];
+    }
+    this.pending = bytes.slice(end + 1);
+    return this.parse(new TextDecoder().decode(bytes.subarray(0, end)));
+  }
+  parse(text) {
+    const records = [];
+    for (const line of text.split(`
+`)) {
+      if (line.trim() === "") {
+        continue;
+      }
+      const record = parseLine(line);
+      if (record === null) {
+        this.skipped += 1;
+        continue;
+      }
+      records.push(record);
+    }
+    return records;
+  }
+}
+function classifyInterrupt(record) {
+  if (record.type !== "user" || !isMainChain(record) || typeof record.timestamp !== "string") {
+    return null;
+  }
+  const content = messageOf(record)?.content;
+  if (!Array.isArray(content) || content.length !== 1) {
+    return null;
+  }
+  const [block] = content;
+  if (!isRecord4(block) || block.type !== "text") {
+    return null;
+  }
+  if (block.text === INTERRUPT_MARKER) {
+    return "turn";
+  }
+  if (block.text === INTERRUPT_TOOL_MARKER) {
+    return "tool_use";
+  }
+  return null;
+}
+
+class UsageLedger {
+  counted = new Map;
+  take(record) {
+    const message = messageOf(record);
+    if (record.type !== "assistant" || !isMainChain(record) || message === null) {
+      return null;
+    }
+    if (typeof message.id !== "string" || !isRecord4(message.usage)) {
+      return null;
+    }
+    const seen = this.counted.get(message.id) ?? emptyCounts();
+    const now = {
+      inputTokens: Math.max(seen.inputTokens, count(message.usage.input_tokens)),
+      outputTokens: Math.max(seen.outputTokens, count(message.usage.output_tokens)),
+      cacheReadTokens: Math.max(seen.cacheReadTokens, count(message.usage.cache_read_input_tokens)),
+      cacheCreationTokens: Math.max(seen.cacheCreationTokens, count(message.usage.cache_creation_input_tokens))
+    };
+    this.counted.set(message.id, now);
+    const delta = {
+      inputTokens: now.inputTokens - seen.inputTokens,
+      outputTokens: now.outputTokens - seen.outputTokens,
+      cacheReadTokens: now.cacheReadTokens - seen.cacheReadTokens,
+      cacheCreationTokens: now.cacheCreationTokens - seen.cacheCreationTokens
+    };
+    return Object.values(delta).some((value) => value > 0) ? delta : null;
+  }
+}
+function assistantBlocks(record) {
+  const content = messageOf(record)?.content;
+  if (record.type !== "assistant" || !isMainChain(record) || !Array.isArray(content)) {
+    return [];
+  }
+  const blocks = [];
+  for (const block of content) {
+    if (!isRecord4(block)) {
+      continue;
+    }
+    if (block.type === "text" && typeof block.text === "string" && block.text !== "") {
+      blocks.push({ kind: "text", text: block.text });
+    }
+    if (block.type === "thinking" && typeof block.thinking === "string" && block.thinking !== "") {
+      blocks.push({ kind: "thinking", text: block.thinking });
+    }
+  }
+  return blocks;
+}
+function assistantStopReason(record) {
+  const reason = messageOf(record)?.stop_reason;
+  return record.type === "assistant" && typeof reason === "string" ? reason : null;
+}
+function isMainChain(record) {
+  return record.isSidechain !== true;
+}
+function messageOf(record) {
+  return isRecord4(record.message) ? record.message : null;
+}
+function parseLine(line) {
+  try {
+    const value = JSON.parse(line);
+    return isRecord4(value) ? value : null;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function fileSize(path) {
+  try {
+    return (await stat2(path)).size;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+function concat(left, right) {
+  if (left.byteLength === 0) {
+    return right;
+  }
+  const joined = new Uint8Array(left.byteLength + right.byteLength);
+  joined.set(left);
+  joined.set(right, left.byteLength);
+  return joined;
+}
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function emptyCounts() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0
+  };
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var INTERRUPT_MARKER = "[Request interrupted by user]", INTERRUPT_TOOL_MARKER = "[Request interrupted by user for tool use]", NEWLINE = 10;
+var init_transcript = () => {};
+
+// src/live/daemon.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { chmod, mkdir as mkdir4, readFile as readFile4, stat as stat3, unlink as unlink2 } from "fs/promises";
+import { createServer } from "net";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join7 } from "path";
+function exitCodeFor(code) {
+  return EXIT_CODES[code];
+}
+
+class Latch {
+  fired = false;
+  waiters = [];
+  arm() {
+    this.fired = false;
+  }
+  fire() {
+    this.fired = true;
+    for (const waiter of this.waiters.splice(0)) {
+      waiter();
+    }
+  }
+  wait(timeoutMs) {
+    if (this.fired) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve) => {
+      const waiter = () => {
+        clearTimeout(timer);
+        resolve(true);
+      };
+      const timer = setTimeout(() => {
+        this.waiters = this.waiters.filter((candidate) => candidate !== waiter);
+        resolve(false);
+      }, timeoutMs);
+      this.waiters.push(waiter);
+    });
+  }
+}
+
+class EventQueue {
+  options;
+  seq = 0;
+  pending = [];
+  running = false;
+  stopped = false;
+  constructor(options) {
+    this.options = options;
+  }
+  get lastSeq() {
+    return this.seq;
+  }
+  get size() {
+    return this.pending.length;
+  }
+  push(draft) {
+    if (this.stopped) {
+      return;
+    }
+    this.seq += 1;
+    this.pending.push({
+      type: draft.type,
+      seq: this.seq,
+      gen: this.options.gen,
+      ts: new Date().toISOString(),
+      payload: redactDeep(draft.payload, this.options.secrets())
+    });
+    this.kick();
+  }
+  async drain(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (this.pending.length > 0 && !this.stopped && Date.now() < deadline) {
+      await Bun.sleep(20);
+    }
+  }
+  stop() {
+    this.stopped = true;
+  }
+  kick() {
+    if (this.running || this.stopped) {
+      return;
+    }
+    this.running = true;
+    this.loop().finally(() => {
+      this.running = false;
+    });
+  }
+  async loop() {
+    let failures = 0;
+    while (!this.stopped && this.pending.length > 0) {
+      const outcome = await this.send(this.pending.slice(0, MAX_BATCH));
+      if (outcome === "stale") {
+        this.stopped = true;
+        this.pending = [];
+        this.options.onStaleGen();
+        return;
+      }
+      if (outcome === "acknowledged") {
+        failures = 0;
+        continue;
+      }
+      failures += 1;
+      const timings = this.options.timings();
+      await Bun.sleep(Math.min(timings.retryMaxMs, timings.retryBaseMs * 2 ** (failures - 1)));
+    }
+  }
+  async send(batch) {
+    const response = await fetchJson(this.options.endpoint, {
+      method: "POST",
+      bearer: this.options.bearer(),
+      body: {
+        events: batch
+      },
+      timeoutMs: this.options.timings().ingestTimeoutMs
+    });
+    if (response.status === 200 && isRecord(response.body) && typeof response.body.lastSeq === "number") {
+      return this.acknowledge(response.body.lastSeq);
+    }
+    const error = isRecord(response.body) && isRecord(response.body.error) ? response.body.error : {};
+    if (response.status === 409 && error.code === "stale_gen") {
+      this.options.logger.warn("tmuxd ingest moved to a newer gen", {
+        gen: this.options.gen,
+        currentGen: error.currentGen
+      });
+      return "stale";
+    }
+    if (response.status === 409 && error.code === "seq_gap" && typeof error.expectedSeq === "number") {
+      return this.acknowledge(error.expectedSeq - 1);
+    }
+    this.options.logger.warn("tmuxd event push failed", {
+      gen: this.options.gen,
+      status: response.status,
+      code: error.code
+    });
+    return "retry";
+  }
+  acknowledge(lastSeq) {
+    const before = this.pending.length;
+    this.pending = this.pending.filter((event) => event.seq > lastSeq);
+    const first = this.pending[0];
+    if (first !== undefined && first.seq !== lastSeq + 1) {
+      this.options.logger.error("tmuxd ingest expects an event that was already acknowledged", {
+        gen: this.options.gen,
+        expectedSeq: lastSeq + 1,
+        firstPending: first.seq
+      });
+      return "retry";
+    }
+    return this.pending.length < before ? "acknowledged" : "retry";
+  }
+}
+
+class LivePane {
+  pane;
+  gen;
+  ingestUrl;
+  daemon;
+  started = new Latch;
+  submitted = new Latch;
+  turnClosed = new Latch;
+  queue;
+  claudeSessionId;
+  model;
+  pid;
+  turn;
+  pendingPromptId;
+  dialog;
+  compacting = false;
+  lastCloseCause;
+  token;
+  secrets;
+  openTools = new Map;
+  subagents = new Set;
+  tail;
+  ledger = new UsageLedger;
+  reading;
+  skippedLines = 0;
+  lastAssistantText;
+  lastStopReason = null;
+  settled = false;
+  lastActivityAt = Date.now();
+  sessionEndReason;
+  timers = [];
+  monitoring = false;
+  closed = false;
+  constructor(pane, gen, ingestUrl, token, authValues, daemon) {
+    this.pane = pane;
+    this.gen = gen;
+    this.ingestUrl = ingestUrl;
+    this.daemon = daemon;
+    this.token = token;
+    this.secrets = [token, ...authValues.filter((value) => value.length >= MIN_SECRET_LENGTH)];
+    this.queue = new EventQueue({
+      gen,
+      endpoint: `${ingestUrl}/events`,
+      bearer: () => this.token,
+      secrets: () => this.secrets,
+      timings: () => daemon.timings,
+      onStaleGen: () => void this.abandon(),
+      logger: daemon.logger
+    });
+  }
+  get id() {
+    return this.pane.id;
+  }
+  get busy() {
+    return this.turn !== undefined || this.compacting;
+  }
+  begin() {
+    const timings = this.daemon.timings;
+    this.timers = [
+      setInterval(() => void this.guard("transcript", () => this.readTranscript()), timings.transcriptPollMs),
+      setInterval(() => void this.guard("monitor", () => this.monitor()), timings.monitorMs),
+      setInterval(() => void this.guard("heartbeat", () => this.beat()), timings.heartbeatMs)
+    ];
+  }
+  rotate(token) {
+    this.token = token;
+    this.secrets.push(token);
+  }
+  async handleHook(event, payload, signal) {
+    if (this.closed) {
+      return { ok: false };
+    }
+    this.lastActivityAt = Date.now();
+    switch (event) {
+      case "SessionStart":
+        await this.onSessionStart(payload);
+        break;
+      case "UserPromptSubmit":
+        this.onPromptSubmit(payload);
+        break;
+      case "PreToolUse":
+        this.onPreToolUse(payload);
+        break;
+      case "PermissionRequest":
+        return this.onPermissionRequest(payload, signal);
+      case "PostToolUse":
+        this.closeTool(payload, "completed", toolOutput(payload.tool_response));
+        break;
+      case "PostToolUseFailure":
+        this.closeTool(payload, "failed", text(payload.error));
+        break;
+      case "PermissionDenied":
+        this.closeTool(payload, "failed");
+        break;
+      case "Stop":
+        await this.onStop(payload);
+        break;
+      case "StopFailure":
+        await this.onStopFailure(payload);
+        break;
+      case "SessionEnd":
+        if (payload.reason !== "clear") {
+          this.sessionEndReason = text(payload.reason) ?? "other";
+        }
+        break;
+      case "SubagentStart":
+        this.onSubagentStart(payload);
+        break;
+      case "SubagentStop":
+        this.onSubagentStop(payload);
+        break;
+      case "PreCompact":
+        this.compacting = true;
+        this.queue.push(compactionStarted(payload));
+        break;
+      case "PostCompact":
+        this.compacting = false;
+        this.queue.push(compactionCompleted(payload));
+        break;
+    }
+    return { ok: true };
+  }
+  closeTurn(draft, cause) {
+    if (this.turn === undefined) {
+      return;
+    }
+    this.closeOpenTools();
+    this.clearDialog();
+    this.queue.push(draft);
+    this.turn = undefined;
+    this.lastCloseCause = cause;
+    this.turnClosed.fire();
+  }
+  clearDialog() {
+    this.dialog?.abort.abort();
+    this.dialog = undefined;
+  }
+  interruptedTurn() {
+    return turnCompleted("interrupted", this.lastAssistantText);
+  }
+  async stop() {
+    this.close();
+    await killPane(this.pane);
+    this.queue.push(sessionEnded("stopped"));
+    await this.queue.drain(STOP_DRAIN_MS);
+    this.queue.stop();
+  }
+  async dispose() {
+    this.close();
+    this.queue.stop();
+    await this.killLogged();
+  }
+  close() {
+    this.closed = true;
+    for (const timer of this.timers.splice(0)) {
+      clearInterval(timer);
+    }
+    this.clearDialog();
+  }
+  async onSessionStart(payload) {
+    const source = text(payload.source);
+    this.model = text(payload.model) ?? this.model;
+    if (source === "compact") {
+      return;
+    }
+    const path = text(payload.transcript_path);
+    if (path !== undefined) {
+      this.tail = source === "resume" ? await TranscriptTail.atEnd(path) : new TranscriptTail(path);
+    }
+    this.claudeSessionId = text(payload.session_id) ?? this.claudeSessionId;
+    this.queue.push(sessionStarted({
+      ...payload,
+      model: this.model
+    }, source === "resume" ? "resume" : "startup"));
+    this.started.fire();
+  }
+  onPromptSubmit(payload) {
+    if (this.turn !== undefined) {
+      return;
+    }
+    this.turn = {
+      promptId: this.pendingPromptId ?? text(payload.prompt_id) ?? randomUUID5()
+    };
+    this.pendingPromptId = undefined;
+    this.settled = false;
+    this.lastAssistantText = undefined;
+    this.lastStopReason = null;
+    this.queue.push(turnStarted(this.turn.promptId));
+    this.submitted.fire();
+  }
+  onPreToolUse(payload) {
+    if (this.turn === undefined) {
+      return;
+    }
+    const toolCallId = text(payload.tool_use_id) ?? randomUUID5();
+    this.openTools.set(toolCallId, {
+      name: text(payload.tool_name),
+      input: payload.tool_input
+    });
+    this.settled = false;
+    this.queue.push(toolCallBegin(payload, toolCallId));
+  }
+  async onPermissionRequest(payload, signal) {
+    const correlated = this.findOpenTool(payload);
+    const dialog = {
+      toolCallId: correlated ?? randomUUID5(),
+      correlated: correlated !== undefined,
+      toolName: text(payload.tool_name),
+      input: payload.tool_input,
+      abort: new AbortController
+    };
+    this.dialog?.abort.abort();
+    this.dialog = dialog;
+    signal.addEventListener("abort", () => dialog.abort.abort());
+    const request = permissionRequest(payload, dialog.toolCallId);
+    this.queue.push({
+      type: "permission_request",
+      payload: {
+        ...request
+      }
+    });
+    const decision = await this.askIngest(request, dialog.abort.signal);
+    if (decision === undefined || this.dialog !== dialog) {
+      return { ok: true };
+    }
+    this.dialog = undefined;
+    return {
+      ok: true,
+      decision
+    };
+  }
+  async askIngest(request, signal) {
+    const timings = this.daemon.timings;
+    const opened = await fetchJson(`${this.ingestUrl}/permissions`, {
+      method: "POST",
+      bearer: this.token,
+      body: redactDeep({
+        gen: this.gen,
+        ...request
+      }, this.secrets),
+      timeoutMs: timings.ingestTimeoutMs,
+      signal
+    });
+    if (opened.status !== 200 && opened.status !== 201) {
+      this.daemon.logger.warn("tmuxd permission open failed", { pane: this.id, status: opened.status });
+      return;
+    }
+    const immediate = decisionFrom(opened.body);
+    if (immediate !== "pending") {
+      return immediate;
+    }
+    const id = isRecord(opened.body) ? text(opened.body.id) : undefined;
+    if (id === undefined) {
+      return;
+    }
+    const deadline = Date.now() + PERMISSION_WAIT_MS;
+    while (!signal.aborted && Date.now() < deadline) {
+      await Bun.sleep(timings.permissionPollMs);
+      if (signal.aborted) {
+        return;
+      }
+      const polled = await fetchJson(`${this.ingestUrl}/permissions/${encodeURIComponent(id)}`, {
+        method: "GET",
+        bearer: this.token,
+        timeoutMs: timings.ingestTimeoutMs,
+        signal
+      });
+      if (polled.status === 404) {
+        return;
+      }
+      if (polled.status !== 200) {
+        continue;
+      }
+      const decision = decisionFrom(polled.body);
+      if (decision !== "pending") {
+        return decision;
+      }
+    }
+    return;
+  }
+  closeTool(payload, status, output) {
+    const toolCallId = text(payload.tool_use_id) ?? this.findOpenTool(payload);
+    if (this.dialog !== undefined && this.isDialogOf(this.dialog, payload, toolCallId)) {
+      this.clearDialog();
+    }
+    if (toolCallId === undefined || !this.openTools.delete(toolCallId)) {
+      return;
+    }
+    this.queue.push(toolCallEnd(toolCallId, status, output));
+  }
+  isDialogOf(dialog, payload, toolCallId) {
+    if (dialog.correlated) {
+      return toolCallId === dialog.toolCallId;
+    }
+    return dialog.toolName === text(payload.tool_name) && sameJson(dialog.input, payload.tool_input);
+  }
+  findOpenTool(payload) {
+    const name = text(payload.tool_name);
+    const matches = [...this.openTools.entries()].filter(([, tool]) => tool.name === name && sameJson(tool.input, payload.tool_input));
+    return matches.at(-1)?.[0];
+  }
+  closeOpenTools() {
+    for (const toolCallId of this.openTools.keys()) {
+      this.queue.push(toolCallEnd(toolCallId, "failed"));
+    }
+    this.openTools.clear();
+  }
+  async onStop(payload) {
+    if (this.turn === undefined) {
+      return;
+    }
+    await this.syncTranscript();
+    this.closeTurn(turnCompleted(apiStopReason(this.lastStopReason), text(payload.last_assistant_message) ?? this.lastAssistantText), "stop");
+  }
+  async onStopFailure(payload) {
+    if (this.turn === undefined) {
+      return;
+    }
+    await this.syncTranscript();
+    this.closeTurn(turnFailed(payload), "stop");
+  }
+  onSubagentStart(payload) {
+    const id = text(payload.agent_id);
+    if (id !== undefined) {
+      this.subagents.add(id);
+    }
+    this.queue.push(subagentSpawn(payload));
+  }
+  onSubagentStop(payload) {
+    const id = text(payload.agent_id);
+    if (id === undefined || !this.subagents.delete(id)) {
+      return;
+    }
+    this.queue.push(subagentComplete(payload));
+  }
+  async syncTranscript() {
+    await this.reading;
+    await this.readTranscript();
+  }
+  readTranscript() {
+    if (this.reading === undefined) {
+      this.reading = this.consumeTranscript().finally(() => {
+        this.reading = undefined;
+      });
+    }
+    return this.reading;
+  }
+  async consumeTranscript() {
+    const tail = this.tail;
+    if (tail === undefined || this.closed) {
+      return;
+    }
+    const records = await tail.poll();
+    if (tail.skipped > this.skippedLines) {
+      this.daemon.logger.warn("tmuxd skipped transcript lines that are not JSON", {
+        pane: this.id,
+        skipped: tail.skipped - this.skippedLines
+      });
+      this.skippedLines = tail.skipped;
+    }
+    for (const record of records) {
+      if (record.isSidechain === true) {
+        continue;
+      }
+      this.lastActivityAt = Date.now();
+      if (classifyInterrupt(record) !== null) {
+        this.closeTurn(this.interruptedTurn(), "marker");
+        this.clearDialog();
+        continue;
+      }
+      for (const block of assistantBlocks(record)) {
+        this.queue.push(block.kind === "text" ? outputChunk(block.text) : thinkingChunk(block.text));
+        if (block.kind === "text") {
+          this.lastAssistantText = block.text;
+        }
+      }
+      const counts = this.ledger.take(record);
+      if (counts !== null) {
+        this.queue.push(usage(counts));
+      }
+      if (record.type === "assistant") {
+        this.lastStopReason = assistantStopReason(record);
+        this.settled = this.lastStopReason !== null && this.lastStopReason !== "tool_use";
+      } else if (record.type === "user") {
+        this.settled = false;
+      }
+    }
+  }
+  async monitor() {
+    if (this.monitoring || this.closed) {
+      return;
+    }
+    this.monitoring = true;
+    try {
+      if (!await this.alive()) {
+        await this.onDeath();
+        return;
+      }
+      const quiet = Date.now() - this.lastActivityAt >= this.daemon.timings.watchdogQuietMs;
+      const idle = this.dialog === undefined && this.openTools.size === 0 && !this.compacting && this.settled;
+      if (this.turn !== undefined && quiet && idle) {
+        this.closeTurn(turnCompleted("watchdog", this.lastAssistantText), "watchdog");
+      }
+    } finally {
+      this.monitoring = false;
+    }
+  }
+  async beat() {
+    if (!this.closed && await this.alive()) {
+      this.queue.push(heartbeat());
+    }
+  }
+  async alive() {
+    return await paneAlive(this.pane) && (this.pid === undefined || processAlive(this.pid));
+  }
+  async onDeath() {
+    if (this.closed) {
+      return;
+    }
+    const turnRunning = this.turn !== undefined;
+    this.close();
+    if (this.sessionEndReason !== undefined) {
+      this.queue.push(sessionEnded("stopped"));
+    } else {
+      this.queue.push(sessionEnded("crashed"));
+      this.queue.push(processDied());
+      if (turnRunning) {
+        this.queue.push(sessionFailed("process_died", "claude exited while a turn was running."));
+      }
+    }
+    await this.queue.drain(STOP_DRAIN_MS);
+    this.queue.stop();
+    this.daemon.remove(this);
+  }
+  async abandon() {
+    if (this.closed) {
+      return;
+    }
+    this.close();
+    await this.killLogged();
+    this.daemon.remove(this);
+  }
+  async killLogged() {
+    try {
+      await killPane(this.pane);
+    } catch (error) {
+      if (!(error instanceof PaneError)) {
+        throw error;
+      }
+      this.daemon.logger.error("tmuxd could not kill a pane", { pane: this.id, reason: error.reason });
+    }
+  }
+  async guard(task, run) {
+    try {
+      await run();
+    } catch (error) {
+      this.daemon.logger.error("tmuxd pane task failed", {
+        pane: this.id,
+        task,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}
+
+class LiveDaemon {
+  options;
+  logger;
+  timings;
+  panes = new Map;
+  server;
+  constructor(options) {
+    this.options = options;
+    this.logger = options.logger ?? createLogger({ env: process.env });
+    this.timings = {
+      ...DEFAULT_TIMINGS,
+      ...options.timings
+    };
+  }
+  setTimings(timings) {
+    this.timings = {
+      ...this.timings,
+      ...timings
+    };
+  }
+  async listen() {
+    const { socketPath } = this.options;
+    await mkdir4(dirname4(socketPath), { recursive: true, mode: 448 });
+    if (await Bun.file(socketPath).exists()) {
+      if (await this.answering(socketPath)) {
+        throw new Error(`a tmuxd daemon already listens on ${socketPath}`);
+      }
+      await unlink2(socketPath);
+    }
+    const server = createServer((socket) => this.accept(socket));
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(socketPath, () => {
+        server.off("error", reject);
+        resolve();
+      });
+    });
+    await chmod(socketPath, 384);
+    this.server = server;
+  }
+  async close() {
+    for (const pane of [...this.panes.values()]) {
+      this.panes.delete(pane.id);
+      await pane.dispose();
+    }
+    const server = this.server;
+    this.server = undefined;
+    if (server !== undefined) {
+      await new Promise((resolve) => server.close(() => resolve()));
+      await unlink2(this.options.socketPath).catch((error) => {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      });
+    }
+  }
+  remove(pane) {
+    if (this.panes.get(pane.id) !== pane) {
+      return;
+    }
+    this.panes.delete(pane.id);
+    if (this.panes.size === 0 && this.options.onIdle !== undefined) {
+      setTimeout(this.options.onIdle, 0);
+    }
+  }
+  async hook(paneId, event, payload, signal) {
+    const pane = this.panes.get(paneId);
+    return pane === undefined ? { ok: false } : pane.handleHook(event, payload, signal);
+  }
+  async ctl(verb, args) {
+    switch (verb) {
+      case "start":
+        return this.start(args);
+      case "prompt":
+        return this.prompt(args);
+      case "command":
+        return this.command(args);
+      case "cancel":
+        return this.cancel(args);
+      case "stop":
+        return this.stop(args);
+      case "rotate-token":
+        return this.rotateToken(args);
+      case "status":
+        return this.status(args);
+      default:
+        return refuse("usage_error");
+    }
+  }
+  async start(args) {
+    const envFile = args["env-file"];
+    if (envFile === undefined || !isAbsolute4(envFile)) {
+      return refuse("usage_error");
+    }
+    try {
+      return await this.launch(args, envFile);
+    } finally {
+      await removeFile(envFile);
+    }
+  }
+  async launch(args, envFile) {
+    const { pane: id, cwd, model, resume } = args;
+    const settingsBase = args["settings-base"];
+    if (id === undefined || !PANE_ID2.test(id) || cwd === undefined || !isAbsolute4(cwd)) {
+      return refuse("usage_error");
+    }
+    if (settingsBase === undefined || !isAbsolute4(settingsBase)) {
+      return refuse("usage_error");
+    }
+    if (model !== undefined && !MODEL_NAME.test(model)) {
+      return refuse("usage_error");
+    }
+    if (this.panes.has(id)) {
+      return refuse("pane_exists");
+    }
+    if (this.panes.size >= (this.options.maxPanes ?? DEFAULT_MAX_PANES)) {
+      return refuse("pane_cap");
+    }
+    const content = await readSecretFile(envFile);
+    const env = content === null ? null : parseStartEnv(content);
+    if (env === null) {
+      return refuse("usage_error");
+    }
+    const settingsPath = join7(settingsBase, `${id}.settings.json`);
+    await mkdir4(settingsBase, { recursive: true, mode: 448 });
+    await writePaneSettings(settingsPath, {
+      basePath: this.options.baseSettingsPath ?? DEFAULT_BASE_SETTINGS_PATH,
+      helperArgv: this.options.helperArgv,
+      socketPath: this.options.socketPath,
+      paneId: id
+    });
+    const pane = {
+      id,
+      socket: this.options.tmuxSocket ?? LIVE_SOCKET
+    };
+    const live = new LivePane(pane, env.gen, env.ingestUrl, env.token, Object.values(env.authEnv), this);
+    this.panes.set(id, live);
+    try {
+      await createPane({
+        id,
+        cwd,
+        home: this.options.home,
+        settingsPath,
+        env: env.authEnv,
+        model,
+        resumeSessionId: resume,
+        claudeBin: this.options.claudeBin,
+        socket: pane.socket,
+        confirmStarted: (timeoutMs) => live.started.wait(timeoutMs)
+      });
+    } catch (error) {
+      this.panes.delete(id);
+      live.queue.stop();
+      return refuse(launchFailure(error));
+    }
+    live.pid = await panePid(pane);
+    live.begin();
+    return accept({
+      pane: id,
+      gen: env.gen,
+      pid: live.pid,
+      claudeSessionId: live.claudeSessionId,
+      resumed: resume !== undefined
+    });
+  }
+  async prompt(args) {
+    const { pane: id, file } = args;
+    if (file === undefined || !isAbsolute4(file)) {
+      return refuse("usage_error");
+    }
+    const content = await takeFile(file, readFileOrNull);
+    if (id === undefined || content === null) {
+      return refuse("usage_error");
+    }
+    const live = this.panes.get(id);
+    if (live === undefined) {
+      return notRunning(id);
+    }
+    const refused = this.deliveryRefusal(live);
+    if (refused !== null) {
+      return refused;
+    }
+    let sanitized;
+    try {
+      sanitized = sanitizePrompt(content);
+    } catch (error) {
+      if (error instanceof InputRejectedError) {
+        return refuse("prompt_rejected", { rule: REJECTION_RULES[error.reason] });
+      }
+      throw error;
+    }
+    const promptId = randomUUID5();
+    live.pendingPromptId = promptId;
+    live.submitted.arm();
+    let outcome;
+    try {
+      outcome = await deliverPrompt(live.pane, content, (timeoutMs) => live.submitted.wait(timeoutMs), () => live.dialog !== undefined);
+    } catch (error) {
+      live.pendingPromptId = undefined;
+      return deliveryFailure(error, id);
+    }
+    if (outcome === "aborted") {
+      live.pendingPromptId = undefined;
+      return refuse("dialog_open");
+    }
+    return accept({
+      promptId,
+      bytes: Buffer.byteLength(sanitized)
+    });
+  }
+  async command(args) {
+    const { pane: id, name, arg } = args;
+    if (id === undefined || name === undefined || !COMMAND_NAMES.has(name) || name === "model" !== (arg !== undefined)) {
+      return refuse("usage_error");
+    }
+    let typed;
+    try {
+      typed = sanitizeCommand(arg === undefined ? `/${name}` : `/${name} ${arg}`);
+    } catch (error) {
+      if (error instanceof InputRejectedError) {
+        return refuse("usage_error");
+      }
+      throw error;
+    }
+    const live = this.panes.get(id);
+    if (live === undefined) {
+      return notRunning(id);
+    }
+    const refused = this.deliveryRefusal(live);
+    if (refused !== null) {
+      return refused;
+    }
+    try {
+      await deliverCommand(live.pane, typed);
+    } catch (error) {
+      return deliveryFailure(error, id);
+    }
+    return accept(arg === undefined ? { name } : { name, arg });
+  }
+  async cancel(args) {
+    const id = args.pane;
+    if (id === undefined) {
+      return refuse("usage_error");
+    }
+    const live = this.panes.get(id);
+    if (live === undefined) {
+      return notRunning(id);
+    }
+    if (live.turn === undefined) {
+      return accept({ wasBusy: false });
+    }
+    live.turnClosed.arm();
+    live.clearDialog();
+    try {
+      await cancelPane(live.pane);
+    } catch (error) {
+      return deliveryFailure(error, id);
+    }
+    if (await live.turnClosed.wait(this.timings.cancelTimeoutMs)) {
+      return accept({
+        wasBusy: true,
+        detectedBy: live.lastCloseCause === "marker" ? "transcript_marker" : "timeout"
+      });
+    }
+    live.closeTurn(live.interruptedTurn(), "timeout");
+    return accept({
+      wasBusy: true,
+      detectedBy: "timeout"
+    });
+  }
+  async stop(args) {
+    const id = args.pane;
+    if (id === undefined) {
+      return refuse("usage_error");
+    }
+    const live = this.panes.get(id);
+    if (live === undefined) {
+      return notRunning(id);
+    }
+    try {
+      await live.stop();
+    } catch (error) {
+      if (error instanceof PaneError) {
+        return refuse("timeout");
+      }
+      throw error;
+    } finally {
+      this.remove(live);
+    }
+    return accept({ claudeSessionId: live.claudeSessionId });
+  }
+  async rotateToken(args) {
+    const id = args.pane;
+    const file = args["token-file"];
+    if (file === undefined || !isAbsolute4(file)) {
+      return refuse("usage_error");
+    }
+    const content = await takeFile(file, readSecretFile);
+    if (id === undefined) {
+      return refuse("usage_error");
+    }
+    const live = this.panes.get(id);
+    if (live === undefined) {
+      return notRunning(id);
+    }
+    const token = content?.trim() ?? "";
+    if (token === "" || tokenGen(token) !== live.gen) {
+      return refuse("usage_error");
+    }
+    live.rotate(token);
+    return accept({ gen: live.gen });
+  }
+  status(args) {
+    const id = args.pane;
+    if (id === undefined) {
+      return refuse("usage_error");
+    }
+    const live = this.panes.get(id);
+    if (live === undefined) {
+      return notRunning(id);
+    }
+    return accept({
+      pane: id,
+      running: true,
+      gen: live.gen,
+      busy: live.busy,
+      dialogOpen: live.dialog !== undefined,
+      lastSeq: live.queue.lastSeq,
+      pendingEvents: live.queue.size,
+      claudeSessionId: live.claudeSessionId,
+      model: live.model
+    });
+  }
+  deliveryRefusal(live) {
+    if (live.dialog !== undefined) {
+      return refuse("dialog_open");
+    }
+    if (live.busy || live.pendingPromptId !== undefined) {
+      return refuse("busy");
+    }
+    return null;
+  }
+  accept(socket) {
+    const controller = new AbortController;
+    let buffer = "";
+    let handled = false;
+    socket.on("close", () => controller.abort());
+    socket.on("error", (error) => {
+      controller.abort();
+      this.logger.debug("tmuxd socket client error", { error: error.message });
+    });
+    socket.on("data", (chunk) => {
+      if (handled) {
+        return;
+      }
+      buffer += chunk.toString("utf8");
+      if (buffer.length > MAX_REQUEST_BYTES) {
+        socket.destroy();
+        return;
+      }
+      const newline = buffer.indexOf(`
+`);
+      if (newline === -1) {
+        return;
+      }
+      handled = true;
+      this.answer(buffer.slice(0, newline), controller.signal).then((response) => {
+        if (!socket.destroyed) {
+          socket.end(`${JSON.stringify(response)}
+`);
+        }
+      });
+    });
+  }
+  async answer(line, signal) {
+    const request = parseRequest(line);
+    try {
+      if (request?.kind === "hook" && typeof request.pane === "string" && typeof request.event === "string") {
+        return await this.hook(request.pane, request.event, isRecord(request.payload) ? request.payload : {}, signal);
+      }
+      if (request?.kind === "ctl" && typeof request.verb === "string") {
+        return await this.ctl(request.verb, stringArgs(request.args));
+      }
+    } catch (error) {
+      this.logger.error("tmuxd request failed", {
+        kind: request?.kind,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return refuse("usage_error");
+  }
+  async answering(socketPath) {
+    try {
+      await socketRequest(socketPath, { kind: "ping" }, 1000);
+      return true;
+    } catch (error) {
+      if (error instanceof SocketRequestError) {
+        return error.reason !== "unreachable";
+      }
+      throw error;
+    }
+  }
+}
+function defaultSocketPath(env, tempDir) {
+  const uid = typeof process.getuid === "function" ? process.getuid() : "agent";
+  return join7(env.XDG_RUNTIME_DIR ?? tempDir, `kodizm-live-${uid}`, "tmuxd.sock");
+}
+function tokenGen(token) {
+  if (!token.startsWith(TOKEN_PREFIX)) {
+    return null;
+  }
+  const [payload] = token.slice(TOKEN_PREFIX.length).split(".");
+  try {
+    const claims = JSON.parse(Buffer.from(payload ?? "", "base64url").toString("utf8"));
+    return isRecord(claims) && Number.isInteger(claims.gen) ? claims.gen : null;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+}
+function parseStartEnv(content) {
+  const values = {};
+  for (const line of content.split(`
+`)) {
+    if (line.trim() === "") {
+      continue;
+    }
+    const separator = line.indexOf("=");
+    const key = line.slice(0, separator);
+    if (separator <= 0 || !ENV_KEY.test(key)) {
+      return null;
+    }
+    values[key] = line.slice(separator + 1);
+  }
+  const ingestUrl = values.KODIZM_LIVE_INGEST_URL ?? "";
+  const token = values.KODIZM_LIVE_TOKEN ?? "";
+  const gen = Number(values.KODIZM_LIVE_GEN);
+  if (!/^https?:\/\//.test(ingestUrl) || !Number.isInteger(gen) || gen < 1 || tokenGen(token) !== gen) {
+    return null;
+  }
+  return {
+    ingestUrl: ingestUrl.replace(/\/+$/, ""),
+    token,
+    gen,
+    authEnv: Object.fromEntries(Object.entries(values).filter(([key]) => !key.startsWith(LIVE_KEY_PREFIX)))
+  };
+}
+async function readSecretFile(path) {
+  const info = await stat3(path).catch((error) => {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  });
+  if (info === null || !info.isFile() || (info.mode & 511) !== 384) {
+    return null;
+  }
+  return readFile4(path, "utf8");
+}
+async function readFileOrNull(path) {
+  return readFile4(path, "utf8").catch((error) => {
+    if (error.code === "ENOENT" || error.code === "EISDIR") {
+      return null;
+    }
+    throw error;
+  });
+}
+async function takeFile(path, read) {
+  try {
+    return await read(path);
+  } finally {
+    await removeFile(path);
+  }
+}
+async function removeFile(path) {
+  await unlink2(path).catch((error) => {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  });
+}
+function decisionFrom(body) {
+  const status = isRecord(body) ? body.status : undefined;
+  switch (status) {
+    case "pending":
+      return "pending";
+    case "allowed":
+      return { behavior: "allow" };
+    case "denied":
+      return {
+        behavior: "deny",
+        message: (isRecord(body) ? text(body.message) : undefined) ?? "Denied by the operator."
+      };
+    case "expired":
+      return {
+        behavior: "deny",
+        message: "The permission request expired."
+      };
+    default:
+      return;
+  }
+}
+async function fetchJson(url, options) {
+  const timeout = AbortSignal.timeout(options.timeoutMs);
+  const signal = options.signal === undefined ? timeout : AbortSignal.any([options.signal, timeout]);
+  let status;
+  let raw;
+  try {
+    const response = await fetch(url, {
+      method: options.method,
+      headers: {
+        authorization: `Bearer ${options.bearer}`,
+        accept: "application/json",
+        ...options.body === undefined ? {} : { "content-type": "application/json" }
+      },
+      body: options.body === undefined ? undefined : JSON.stringify(options.body),
+      signal
+    });
+    status = response.status;
+    raw = await response.text();
+  } catch (error) {
+    if (error instanceof TypeError || error instanceof DOMException && isAbort(error)) {
+      return { status: 0, body: undefined };
+    }
+    throw error;
+  }
+  let body;
+  try {
+    body = raw === "" ? undefined : JSON.parse(raw);
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) {
+      throw error;
+    }
+  }
+  return {
+    status,
+    body
+  };
+}
+function isAbort(error) {
+  return error.name === "AbortError" || error.name === "TimeoutError";
+}
+function launchFailure(error) {
+  if (error instanceof PaneError) {
+    return error.reason === "start_timeout" ? "timeout" : "usage_error";
+  }
+  if (isErrno(error)) {
+    return "usage_error";
+  }
+  throw error;
+}
+function deliveryFailure(error, id) {
+  if (!(error instanceof PaneError)) {
+    throw error;
+  }
+  return error.reason === "pane_dead" ? notRunning(id) : refuse("timeout");
+}
+function isErrno(error) {
+  return error instanceof Error && typeof error.code === "string";
+}
+async function panePid(pane) {
+  const tmux = Bun.which("tmux");
+  if (tmux === null) {
+    return;
+  }
+  const env = {
+    PATH: process.env.PATH ?? "/usr/bin:/bin"
+  };
+  if (process.env.TMUX_TMPDIR !== undefined) {
+    env.TMUX_TMPDIR = process.env.TMUX_TMPDIR;
+  }
+  const child = Bun.spawn([tmux, "-L", pane.socket, "display-message", "-p", "-t", `=${pane.id}:`, "#{pane_pid}"], {
+    env,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "ignore"
+  });
+  const [exitCode, output] = await Promise.all([child.exited, new Response(child.stdout).text()]);
+  const pid = Number(output.trim());
+  return exitCode === 0 && Number.isInteger(pid) && pid > 0 ? pid : undefined;
+}
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (isErrno(error) && error.code === "ESRCH") {
+      return false;
+    }
+    if (isErrno(error) && error.code === "EPERM") {
+      return true;
+    }
+    throw error;
+  }
+}
+function sameJson(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function parseRequest(line) {
+  try {
+    const value = JSON.parse(line);
+    return isRecord(value) ? value : null;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+}
+function stringArgs(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+function accept(data) {
+  return {
+    ok: true,
+    code: "ok",
+    data: Object.fromEntries(Object.entries(data).filter(([, value]) => value !== undefined))
+  };
+}
+function refuse(code, data) {
+  return data === undefined ? { ok: false, code } : { ok: false, code, data };
+}
+function notRunning(id) {
+  return refuse("pane_not_running", {
+    pane: id,
+    running: false
+  });
+}
+var HEARTBEAT_INTERVAL_MS = 20000, WATCHDOG_QUIET_MS = 30000, CANCEL_TIMEOUT_MS = 3000, PERMISSION_POLL_MS = 1500, INGEST_TIMEOUT_MS = 1e4, MAX_BATCH = 200, DEFAULT_MAX_PANES = 4, STOP_DRAIN_MS = 1e4, PERMISSION_WAIT_MS, MIN_SECRET_LENGTH = 8, MAX_REQUEST_BYTES, PANE_ID2, ENV_KEY, LIVE_KEY_PREFIX = "KODIZM_LIVE_", TOKEN_PREFIX = "kdz-int-jwt.", COMMAND_NAMES, REJECTION_RULES, EXIT_CODES, DEFAULT_TIMINGS;
+var init_daemon = __esm(() => {
+  init_logger();
+  init_events2();
+  init_hooks();
+  init_input();
+  init_pane();
+  init_transcript();
+  PERMISSION_WAIT_MS = PERMISSION_HOOK_TIMEOUT_S * 1000 - 1e4;
+  MAX_REQUEST_BYTES = 8 * 1024 * 1024;
+  PANE_ID2 = /^[A-Za-z0-9_-]{1,64}$/;
+  ENV_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+  COMMAND_NAMES = new Set(["compact", "clear", "model"]);
+  REJECTION_RULES = {
+    slash_command: "leading_slash",
+    bash_mode: "leading_bang",
+    empty: "empty",
+    unknown_command: "unknown_command",
+    invalid_model_alias: "invalid_model_alias"
+  };
+  EXIT_CODES = {
+    ok: 0,
+    usage_error: 2,
+    dialog_open: 3,
+    prompt_rejected: 3,
+    pane_cap: 3,
+    pane_exists: 3,
+    busy: 3,
+    pane_not_running: 4,
+    timeout: 5
+  };
+  DEFAULT_TIMINGS = {
+    heartbeatMs: HEARTBEAT_INTERVAL_MS,
+    watchdogQuietMs: WATCHDOG_QUIET_MS,
+    cancelTimeoutMs: CANCEL_TIMEOUT_MS,
+    permissionPollMs: PERMISSION_POLL_MS,
+    ingestTimeoutMs: INGEST_TIMEOUT_MS,
+    monitorMs: 2000,
+    transcriptPollMs: 250,
+    retryBaseMs: 250,
+    retryMaxMs: 1e4
+  };
+});
+
+// src/live/ctl.ts
+import { spawn as spawn2 } from "child_process";
+import { homedir as homedir2, tmpdir } from "os";
+import { resolve as resolve5 } from "path";
+async function runTmuxd(args) {
+  const [command, ...rest] = args;
+  switch (command) {
+    case "ctl":
+      return runCtl(rest);
+    case "hook":
+      return runHook(rest);
+    case "daemon":
+      return runDaemon();
+    case undefined:
+    case "--help":
+    case "help":
+      process.stdout.write(USAGE);
+      return 0;
+    default:
+      process.stderr.write(USAGE);
+      return 2;
+  }
+}
+async function runCtl(args) {
+  const [verb, ...rest] = args;
+  const flags = parseFlags(rest);
+  if (verb === undefined || !VERBS.has(verb) || flags === null) {
+    await discardHandoff(verb, rest);
+    return print({ ok: false, code: "usage_error" });
+  }
+  const socketPath = socketPathFromEnv();
+  const message = {
+    kind: "ctl",
+    verb,
+    args: flags
+  };
+  try {
+    return print(await ask(socketPath, message, verb === "start"));
+  } catch (error) {
+    if (!(error instanceof SocketRequestError)) {
+      throw error;
+    }
+    process.stderr.write(`${JSON.stringify({ level: "warn", message: error.message, verb })}
+`);
+    if (error.reason === "unreachable") {
+      await discardHandoff(verb, rest);
+    }
+    return print(error.reason === "unreachable" ? { ok: false, code: "pane_not_running", data: { pane: flags.pane, running: false } } : { ok: false, code: "timeout" });
+  }
+}
+async function ask(socketPath, message, spawnIfMissing) {
+  try {
+    return toResult(await socketRequest(socketPath, message, CTL_TIMEOUT_MS));
+  } catch (error) {
+    if (!spawnIfMissing || !(error instanceof SocketRequestError) || error.reason !== "unreachable") {
+      throw error;
+    }
+  }
+  spawnDaemon();
+  const deadline = Date.now() + DAEMON_BOOT_MS;
+  for (;; ) {
+    try {
+      return toResult(await socketRequest(socketPath, message, CTL_TIMEOUT_MS));
+    } catch (error) {
+      if (!(error instanceof SocketRequestError) || error.reason !== "unreachable" || Date.now() > deadline) {
+        throw error;
+      }
+      await Bun.sleep(50);
+    }
+  }
+}
+async function runHook(args) {
+  const [event, ...rest] = args;
+  const flags = parseFlags(rest);
+  try {
+    if (event === undefined || flags?.pane === undefined || flags.socket === undefined) {
+      return 0;
+    }
+    const output = await runHookHelper({
+      event,
+      paneId: flags.pane,
+      socketPath: flags.socket,
+      input: await readStdin()
+    });
+    if (output !== "") {
+      process.stdout.write(output);
+    }
+  } catch (error) {
+    process.stderr.write(`${JSON.stringify({
+      level: "error",
+      message: "tmuxd hook failed",
+      event,
+      error: error instanceof Error ? error.message : String(error)
+    })}
+`);
+  }
+  return 0;
+}
+async function runDaemon() {
+  const env = process.env;
+  const maxPanes = Number(env.KODIZM_TMUXD_MAX_PANES);
+  let shutdown = () => {};
+  const stopped = new Promise((resolveStopped) => {
+    shutdown = resolveStopped;
+  });
+  const daemon = new LiveDaemon({
+    socketPath: socketPathFromEnv(),
+    helperArgv: [process.execPath, process.argv[1] ?? ""],
+    home: env.HOME ?? homedir2(),
+    tmuxSocket: env.KODIZM_TMUXD_TMUX_SOCKET ?? LIVE_SOCKET,
+    claudeBin: env.CLAUDE_CODE_PATH,
+    baseSettingsPath: env.KODIZM_LIVE_BASE_SETTINGS ?? DEFAULT_BASE_SETTINGS_PATH,
+    maxPanes: Number.isInteger(maxPanes) && maxPanes > 0 ? maxPanes : DEFAULT_MAX_PANES,
+    logger: createLogger({ env }),
+    onIdle: () => void daemon.close().then(shutdown)
+  });
+  await daemon.listen();
+  for (const signal of ["SIGTERM", "SIGINT"]) {
+    process.on(signal, () => void daemon.close().then(shutdown));
+  }
+  await stopped;
+  return 0;
+}
+function spawnDaemon() {
+  const child = spawn2(process.execPath, [process.argv[1] ?? "", "tmuxd", "daemon"], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  child.unref();
+}
+function socketPathFromEnv() {
+  return process.env.KODIZM_TMUXD_SOCKET ?? defaultSocketPath(process.env, tmpdir());
+}
+function parseFlags(args) {
+  const flags = {};
+  for (let index = 0;index < args.length; index += 2) {
+    const flag = args[index] ?? "";
+    const value = args[index + 1];
+    const name = flag.slice(2);
+    if (!flag.startsWith("--") || name === "" || value === undefined || name in flags) {
+      return null;
+    }
+    flags[name] = PATH_FLAGS.has(name) ? resolve5(value) : value;
+  }
+  return flags;
+}
+async function discardHandoff(verb, args) {
+  const flag = verb === undefined ? undefined : HANDOFF_FLAGS[verb];
+  if (flag === undefined) {
+    return;
+  }
+  for (let index = 0;index < args.length - 1; index += 1) {
+    const value = args[index + 1];
+    if (args[index] === `--${flag}` && value !== undefined) {
+      await removeFile(resolve5(value));
+    }
+  }
+}
+function toResult(response) {
+  const code = typeof response === "object" && response !== null ? response.code : undefined;
+  if (typeof code !== "string" || typeof exitCodeFor(code) !== "number") {
+    throw new SocketRequestError("malformed");
+  }
+  return response;
+}
+function print(result) {
+  process.stdout.write(`${JSON.stringify(result)}
+`);
+  return exitCodeFor(result.code);
+}
+async function readStdin() {
+  let timer;
+  const timeout = new Promise((resolveTimeout) => {
+    timer = setTimeout(() => resolveTimeout(""), STDIN_TIMEOUT_MS);
+  });
+  const input = await Promise.race([Bun.stdin.text(), timeout]);
+  clearTimeout(timer);
+  return input;
+}
+var USAGE, VERBS, PATH_FLAGS, HANDOFF_FLAGS, CTL_TIMEOUT_MS = 60000, DAEMON_BOOT_MS = 5000, STDIN_TIMEOUT_MS = 2000;
+var init_ctl = __esm(() => {
+  init_logger();
+  init_daemon();
+  init_hooks();
+  init_pane();
+  USAGE = `Usage: kodizm-acp tmuxd <command>
+
+Commands:
+  ctl <verb> [flags]                         Drive a Live pane through the daemon; prints one JSON line.
+                                             Verbs: start, prompt, command, cancel, stop, rotate-token, status.
+  hook <Event> --pane <id> --socket <path>   Hook helper the pane settings run; reads the payload on stdin.
+  daemon                                     Run the daemon in the foreground; ctl start spawns it detached.
+
+Environment:
+  KODIZM_TMUXD_SOCKET        daemon socket (default: $XDG_RUNTIME_DIR or the temp dir, kodizm-live-<uid>/tmuxd.sock)
+  KODIZM_TMUXD_TMUX_SOCKET   tmux socket name (default: ${LIVE_SOCKET})
+  KODIZM_TMUXD_MAX_PANES     panes per daemon (default: ${DEFAULT_MAX_PANES})
+  KODIZM_LIVE_BASE_SETTINGS  base settings with the deny list (default: ${DEFAULT_BASE_SETTINGS_PATH})
+  CLAUDE_CODE_PATH           claude binary (default: claude on PATH)
+`;
+  VERBS = new Set(["start", "prompt", "command", "cancel", "stop", "rotate-token", "status"]);
+  PATH_FLAGS = new Set(["settings-base", "env-file", "file", "token-file"]);
+  HANDOFF_FLAGS = {
+    start: "env-file",
+    prompt: "file",
+    "rotate-token": "token-file"
+  };
+});
 // package.json
 var package_default = {
   name: "@kodizm/acp",
-  version: "0.7.0",
+  version: "0.8.0",
   description: "Custom ACP server bridging Claude Code and opencode CLIs through a single Kodizm-flavored protocol surface.",
   type: "module",
   bin: {
@@ -52864,6 +55221,10 @@ async function main() {
   }
 }
 if (import.meta.main) {
+  if (process.argv[2] === "tmuxd") {
+    await Promise.resolve().then(() => init_ctl());
+    process.exit(await runTmuxd(process.argv.slice(3)));
+  }
   await main();
 }
 export {