@bytespell/amux 0.0.1 → 0.0.4

package/dist/bin/cli.js

@@ -1,2178 +1,17 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// bin/cli.ts
-import { program } from "commander";
-
-// src/server.ts
-import express from "express";
-import cors from "cors";
-import { createServer } from "http";
-import { WebSocketServer } from "ws";
-import { createExpressMiddleware } from "@trpc/server/adapters/express";
-import { applyWSSHandler } from "@trpc/server/adapters/ws";
-
-// src/trpc/trpc.ts
-import { initTRPC } from "@trpc/server";
-var t = initTRPC.create();
-var router = t.router;
-var publicProcedure = t.procedure;
-
-// src/trpc/sessions.ts
-import { z } from "zod";
-
-// src/db/index.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
-
-// src/lib/paths.ts
-import path from "path";
-import os from "os";
-import fs from "fs";
-var STARTUP_CWD = process.cwd();
-function getStartupCwd() {
-  return STARTUP_CWD;
-}
-function getDataDir() {
-  const home = os.homedir();
-  let dataDir;
-  switch (process.platform) {
-    case "darwin":
-      dataDir = path.join(home, "Library", "Application Support", "shella");
-      break;
-    case "win32":
-      dataDir = path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"), "shella");
-      break;
-    default:
-      dataDir = path.join(process.env.XDG_DATA_HOME || path.join(home, ".local", "share"), "shella");
-  }
-  return dataDir;
-}
-function isMockMode() {
-  return process.env.SHELLA_MOCK_MODE === "true";
-}
-function getDbPath() {
-  const filename = isMockMode() ? "shella.mock.db" : "shella.db";
-  return path.join(getDataDir(), filename);
-}
-function ensureDir(dir) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
-// src/db/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  agentConfigs: () => agentConfigs,
-  appState: () => appState,
-  sessionEvents: () => sessionEvents,
-  sessions: () => sessions
-});
-import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
-import { sql } from "drizzle-orm";
-var agentConfigs = sqliteTable("agent_configs", {
-  id: text("id").primaryKey(),
-  name: text("name").notNull(),
-  command: text("command").notNull(),
-  args: text("args", { mode: "json" }).$type().default([]),
-  env: text("env", { mode: "json" }).$type().default({}),
-  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
-});
-var sessions = sqliteTable("sessions", {
-  id: text("id").primaryKey(),
-  directory: text("directory").notNull(),
-  agentConfigId: text("agent_config_id").notNull().references(() => agentConfigs.id),
-  // ACP protocol session ID for resuming (internal to agent protocol)
-  acpSessionId: text("acp_session_id"),
-  // Title from agent (via session_info_update)
-  title: text("title"),
-  model: text("model"),
-  mode: text("mode"),
-  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
-});
-var appState = sqliteTable("app_state", {
-  key: text("key").primaryKey(),
-  value: text("value").notNull()
-});
-var sessionEvents = sqliteTable("session_events", {
-  id: text("id").primaryKey(),
-  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
-  turnId: text("turn_id").notNull(),
-  sequenceNum: integer("sequence_num").notNull(),
-  eventKind: text("event_kind").notNull(),
-  payload: text("payload", { mode: "json" }).notNull(),
-  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
-});
-
-// src/db/seed.ts
-import { randomUUID } from "crypto";
-import { execSync } from "child_process";
-var MOCK_AGENT_ID = "mock-agent";
-function commandExists(cmd) {
-  try {
-    execSync(`which ${cmd}`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function detectAgents() {
-  const agents = [];
-  agents.push({
-    id: randomUUID(),
-    name: "Claude",
-    command: "npx",
-    args: ["@zed-industries/claude-code-acp"],
-    env: {}
-  });
-  if (commandExists("opencode")) {
-    agents.push({
-      id: randomUUID(),
-      name: "OpenCode",
-      command: "opencode",
-      args: ["acp"],
-      env: {}
-    });
-  }
-  return agents;
-}
-var MOCK_CONFIGS = [
-  {
-    id: MOCK_AGENT_ID,
-    name: "Test Agent",
-    command: "__stress__",
-    args: [],
-    env: {}
-  }
-];
-function seedAgentConfigs() {
-  if (isMockMode()) {
-    const existing2 = db.select().from(agentConfigs).all();
-    if (existing2.length === 0) {
-      for (const config2 of MOCK_CONFIGS) {
-        db.insert(agentConfigs).values(config2).run();
-      }
-      console.log("[db] Seeded mock agent configs");
-    }
-    seedMockSessions();
-    return;
-  }
-  const detected = detectAgents();
-  const existing = db.select().from(agentConfigs).all();
-  let added = 0;
-  for (const agent of detected) {
-    const alreadyExists = existing.some(
-      (e) => e.command === agent.command && JSON.stringify(e.args) === JSON.stringify(agent.args)
-    );
-    if (!alreadyExists) {
-      db.insert(agentConfigs).values(agent).run();
-      console.log(`[db] Detected new agent: ${agent.name}`);
-      added++;
-    }
-  }
-  if (added === 0 && detected.length > 0) {
-    console.log(`[db] ${detected.length} known agent(s) already configured`);
-  }
-}
-function seedMockSessions() {
-  const existing = db.select().from(sessions).all();
-  if (existing.length > 0) return;
-  const count = getSessionCount(10);
-  for (let i = 1; i <= count; i++) {
-    db.insert(sessions).values({
-      id: randomUUID(),
-      directory: "~",
-      agentConfigId: MOCK_AGENT_ID
-    }).run();
-  }
-  console.log(`[db] Seeded ${count} test sessions`);
-}
-function getSessionCount(defaultCount) {
-  const envCount = process.env.SHELLA_MOCK_SESSIONS ?? process.env.SHELLA_MOCK_WINDOWS;
-  if (envCount) {
-    const parsed = parseInt(envCount, 10);
-    if (!isNaN(parsed) && parsed > 0) {
-      return parsed;
-    }
-  }
-  return defaultCount;
-}
-
-// src/db/index.ts
-ensureDir(getDataDir());
-var sqlite = new Database(getDbPath());
-sqlite.pragma("journal_mode = WAL");
-sqlite.pragma("foreign_keys = ON");
-var db = drizzle(sqlite, { schema: schema_exports });
-sqlite.exec(`
-  CREATE TABLE IF NOT EXISTS agent_configs (
-    id TEXT PRIMARY KEY,
-    name TEXT NOT NULL,
-    command TEXT NOT NULL,
-    args TEXT DEFAULT '[]',
-    env TEXT DEFAULT '{}',
-    created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-  );
-
-  CREATE TABLE IF NOT EXISTS sessions (
-    id TEXT PRIMARY KEY,
-    directory TEXT NOT NULL,
-    agent_config_id TEXT NOT NULL REFERENCES agent_configs(id),
-    acp_session_id TEXT,
-    title TEXT,
-    model TEXT,
-    mode TEXT,
-    created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-  );
-
-  CREATE TABLE IF NOT EXISTS app_state (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS session_events (
-    id TEXT PRIMARY KEY,
-    session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-    turn_id TEXT NOT NULL,
-    sequence_num INTEGER NOT NULL,
-    event_kind TEXT NOT NULL,
-    payload TEXT NOT NULL,
-    created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-  );
-`);
-try {
-  const oldExists = sqlite.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='client_windows'`).get();
-  const newCount = sqlite.prepare(`SELECT COUNT(*) as count FROM sessions`).get();
-  if (oldExists && newCount.count === 0) {
-    console.log("[db] Migrating from client_windows/window_events to sessions/session_events...");
-    sqlite.exec(`
-      INSERT INTO sessions (id, directory, agent_config_id, acp_session_id, model, mode, created_at)
-      SELECT id, directory, agent_config_id, session_id, model, mode, created_at
-      FROM client_windows;
-
-      INSERT INTO session_events (id, session_id, turn_id, sequence_num, event_kind, payload, created_at)
-      SELECT id, window_id, turn_id, sequence_num, event_kind, payload, created_at
-      FROM window_events;
-
-      -- Migrate custom titles to app_state
-      INSERT OR IGNORE INTO app_state (key, value)
-      SELECT 'window_title_' || id, title
-      FROM client_windows
-      WHERE has_custom_title = 1 AND title != '';
-
-      -- Migrate active window
-      INSERT OR REPLACE INTO app_state (key, value)
-      SELECT 'active_window_id', value
-      FROM app_state
-      WHERE key = 'active_window_id';
-    `);
-    sqlite.exec(`
-      DROP TABLE IF EXISTS window_events;
-      DROP TABLE IF EXISTS client_windows;
-    `);
-    console.log("[db] Migration complete");
-  }
-} catch (e) {
-}
-try {
-  sqlite.exec(`ALTER TABLE sessions ADD COLUMN title TEXT`);
-} catch (e) {
-}
-var orphanedTurns = sqlite.prepare(`
-  SELECT DISTINCT turn_id, session_id
-  FROM session_events
-  WHERE event_kind = 'turn_start'
-    AND turn_id NOT IN (
-      SELECT turn_id FROM session_events WHERE event_kind = 'turn_end'
-    )
-`).all();
-if (orphanedTurns.length > 0) {
-  const getMaxSeq = sqlite.prepare(`
-    SELECT COALESCE(MAX(sequence_num), 0) + 1 as next_seq
-    FROM session_events WHERE turn_id = ?
-  `);
-  const insert = sqlite.prepare(`
-    INSERT INTO session_events (id, session_id, turn_id, sequence_num, event_kind, payload)
-    VALUES (?, ?, ?, ?, 'turn_end', '{"amuxEvent":"turn_end"}')
-  `);
-  for (const turn of orphanedTurns) {
-    const { next_seq } = getMaxSeq.get(turn.turn_id);
-    insert.run(randomUUID2(), turn.session_id, turn.turn_id, next_seq);
-  }
-  console.log(`[db] Fixed ${orphanedTurns.length} orphaned turn(s) from previous session`);
-}
-seedAgentConfigs();
-
-// src/trpc/sessions.ts
-import { eq as eq3 } from "drizzle-orm";
-import { randomUUID as randomUUID8 } from "crypto";
-
-// src/agents/manager.ts
-import { EventEmitter } from "events";
-import { eq as eq2 } from "drizzle-orm";
-
-// src/types.ts
-function isSessionUpdate(update) {
-  return "sessionUpdate" in update;
-}
-function isAmuxEvent(update) {
-  return "amuxEvent" in update;
-}
-
-// src/agents/eventStore.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { eq, asc } from "drizzle-orm";
-var turnState = /* @__PURE__ */ new Map();
-function startTurn(sessionId) {
-  const turnId = randomUUID3();
-  turnState.set(sessionId, { turnId, seq: 0 });
-  return turnId;
-}
-function storeEvent(sessionId, update) {
-  let eventKind;
-  if (isSessionUpdate(update)) {
-    eventKind = update.sessionUpdate;
-  } else if (isAmuxEvent(update) && (update.amuxEvent === "turn_start" || update.amuxEvent === "turn_end")) {
-    eventKind = update.amuxEvent;
-  } else {
-    return;
-  }
-  let state = turnState.get(sessionId);
-  if (!state) {
-    state = { turnId: randomUUID3(), seq: 0 };
-    turnState.set(sessionId, state);
-  }
-  const seq = state.seq++;
-  db.insert(sessionEvents).values({
-    id: randomUUID3(),
-    sessionId,
-    turnId: state.turnId,
-    sequenceNum: seq,
-    eventKind,
-    payload: update
-  }).run();
-}
-function endTurn(sessionId) {
-  turnState.delete(sessionId);
-}
-function getEventsForSession(sessionId) {
-  const rows = db.select().from(sessionEvents).where(eq(sessionEvents.sessionId, sessionId)).orderBy(asc(sessionEvents.createdAt), asc(sessionEvents.sequenceNum)).all();
-  return rows.map((row) => row.payload);
-}
-function clearEventsForSession(sessionId) {
-  db.delete(sessionEvents).where(eq(sessionEvents.sessionId, sessionId)).run();
-}
-
-// src/agents/backends/acp.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { spawn as nodeSpawn } from "child_process";
-import { Readable, Writable } from "stream";
-import * as fs2 from "fs/promises";
 import {
-  ClientSideConnection,
-  ndJsonStream
-} from "@agentclientprotocol/sdk";
-
-// src/agents/process.ts
-import { execa } from "execa";
-import treeKill from "tree-kill";
-function spawn(options) {
-  const { command, args = [], cwd, env, timeoutMs } = options;
-  const subprocess = execa(command, args, {
-    cwd,
-    env: { ...process.env, ...env },
-    stdin: "pipe",
-    stdout: "pipe",
-    stderr: "pipe",
-    timeout: timeoutMs,
-    cleanup: true,
-    // Kill on parent exit
-    windowsHide: true
-    // Hide console window on Windows
-  });
-  const pid = subprocess.pid;
-  if (!pid) {
-    throw new Error(`Failed to spawn process: ${command}`);
-  }
-  return {
-    pid,
-    stdin: subprocess.stdin,
-    stdout: subprocess.stdout,
-    stderr: subprocess.stderr,
-    kill: (signal = "SIGTERM") => killTree(pid, signal),
-    wait: async () => {
-      try {
-        const result = await subprocess;
-        return { exitCode: result.exitCode };
-      } catch (err) {
-        return { exitCode: err.exitCode ?? 1 };
-      }
-    }
-  };
-}
-function killTree(pid, signal) {
-  return new Promise((resolve2) => {
-    treeKill(pid, signal, (err) => {
-      if (err && !err.message.includes("No such process")) {
-        console.error(`[process] kill error pid=${pid}:`, err.message);
-      }
-      resolve2();
-    });
-  });
-}
-
-// src/agents/backends/acp.ts
-var INIT_TIMEOUT_MS = 3e4;
-function normalizeSessionUpdate(update) {
-  if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update") {
-    return update;
-  }
-  const content = update.content;
-  if (!content || !Array.isArray(content)) {
-    return update;
-  }
-  const normalizedContent = content.map((item) => {
-    if (item.type !== "diff") return item;
-    if (typeof item.content === "string") return item;
-    const newText = item.newText;
-    const oldText = item.oldText;
-    const path4 = item.path;
-    if (newText === void 0) return item;
-    const filePath = path4 ?? "file";
-    const oldLines = oldText ? oldText.split("\n") : [];
-    const newLines = newText.split("\n");
-    let unifiedDiff = `Index: ${filePath}
-`;
-    unifiedDiff += "===================================================================\n";
-    unifiedDiff += `--- ${filePath}
-`;
-    unifiedDiff += `+++ ${filePath}
-`;
-    unifiedDiff += `@@ -${oldLines.length > 0 ? 1 : 0},${oldLines.length} +1,${newLines.length} @@
-`;
-    for (const line of oldLines) {
-      unifiedDiff += `-${line}
-`;
-    }
-    for (const line of newLines) {
-      unifiedDiff += `+${line}
-`;
-    }
-    return {
-      type: "diff",
-      content: unifiedDiff
-    };
-  });
-  return {
-    ...update,
-    content: normalizedContent
-  };
-}
-function withTimeout(promise, ms, operation) {
-  return Promise.race([
-    promise,
-    new Promise(
-      (_, reject) => setTimeout(() => reject(new Error(`${operation} timed out after ${ms}ms`)), ms)
-    )
-  ]);
-}
-var AcpBackend = class {
-  type = "acp";
-  instances = /* @__PURE__ */ new Map();
-  onSessionIdChanged;
-  matches(config2) {
-    return config2.command !== "__mock__" && config2.command !== "__stress__";
-  }
-  async start(sessionId, config2, cwd, existingAcpSessionId, emit) {
-    if (this.instances.has(sessionId)) {
-      await this.stop(sessionId);
-    }
-    const args = config2.args ?? [];
-    const env = config2.env ?? {};
-    console.log(`[acp] Spawning: ${config2.command} ${args.join(" ")} in ${cwd}`);
-    const proc = spawn({
-      command: config2.command,
-      args,
-      cwd,
-      env
-    });
-    const instance = {
-      process: proc,
-      connection: null,
-      sessionId: "",
-      pendingPermission: null,
-      permissionCallbacks: /* @__PURE__ */ new Map(),
-      emit,
-      terminals: /* @__PURE__ */ new Map()
-    };
-    proc.wait().then(({ exitCode }) => {
-      if (this.instances.has(sessionId)) {
-        emit({ amuxEvent: "error", message: `Agent process exited with code ${exitCode}` });
-        this.instances.delete(sessionId);
-      }
-    });
-    try {
-      const input = Writable.toWeb(proc.stdin);
-      const output = Readable.toWeb(proc.stdout);
-      const stream = ndJsonStream(input, output);
-      const client = this.createClient(sessionId, instance);
-      instance.connection = new ClientSideConnection(() => client, stream);
-      const initResult = await withTimeout(
-        instance.connection.initialize({
-          protocolVersion: 1,
-          clientCapabilities: {
-            fs: { readTextFile: true, writeTextFile: true },
-            terminal: true
-          }
-        }),
-        INIT_TIMEOUT_MS,
-        "Agent initialization"
-      );
-      console.log(`[acp] Initialized agent: ${initResult.agentInfo?.name} v${initResult.agentInfo?.version}`);
-      const canResume = initResult.agentCapabilities?.sessionCapabilities?.resume !== void 0;
-      let acpSessionId;
-      let sessionResult;
-      if (existingAcpSessionId && canResume) {
-        let resumeSucceeded = false;
-        try {
-          console.log(`[acp] Resuming ACP session ${existingAcpSessionId}...`);
-          sessionResult = await withTimeout(
-            instance.connection.unstable_resumeSession({
-              sessionId: existingAcpSessionId,
-              cwd,
-              mcpServers: []
-            }),
-            INIT_TIMEOUT_MS,
-            "Session resume"
-          );
-          await new Promise((resolve2) => setTimeout(resolve2, 100));
-          acpSessionId = existingAcpSessionId;
-          console.log(`[acp] ACP session resumed successfully`);
-          resumeSucceeded = true;
-        } catch (resumeErr) {
-          console.log(`[acp] Resume failed, creating new session:`, resumeErr);
-        }
-        if (!resumeSucceeded) {
-          sessionResult = await withTimeout(
-            instance.connection.newSession({ cwd, mcpServers: [] }),
-            INIT_TIMEOUT_MS,
-            "New session creation"
-          );
-          acpSessionId = sessionResult.sessionId;
-          console.log(`[acp] New ACP session created: ${acpSessionId}`);
-          this.onSessionIdChanged?.(sessionId, acpSessionId);
-        }
-      } else {
-        console.log(`[acp] Creating new ACP session in ${cwd}...`);
-        sessionResult = await withTimeout(
-          instance.connection.newSession({ cwd, mcpServers: [] }),
-          INIT_TIMEOUT_MS,
-          "New session creation"
-        );
-        acpSessionId = sessionResult.sessionId;
-        console.log(`[acp] ACP session created: ${acpSessionId}`);
-        this.onSessionIdChanged?.(sessionId, acpSessionId);
-      }
-      instance.sessionId = acpSessionId;
-      this.instances.set(sessionId, instance);
-      const models = sessionResult?.models?.availableModels;
-      const modes = sessionResult?.modes?.availableModes;
-      if (sessionResult?.modes) {
-        emit({
-          sessionUpdate: "current_mode_update",
-          currentModeId: sessionResult.modes.currentModeId
-        });
-      }
-      return {
-        sessionId: acpSessionId,
-        models,
-        modes
-      };
-    } catch (err) {
-      console.error(`[acp] Error starting agent for session ${sessionId}:`, err);
-      await proc.kill();
-      throw err;
-    }
-  }
-  createClient(_sessionId, instance) {
-    return {
-      async requestPermission(params) {
-        const requestId = randomUUID4();
-        const permission = {
-          requestId,
-          toolCallId: params.toolCall.toolCallId,
-          title: params.toolCall.title ?? "Permission Required",
-          options: params.options.map((o) => ({
-            optionId: o.optionId,
-            name: o.name,
-            kind: o.kind
-          }))
-        };
-        instance.pendingPermission = permission;
-        instance.emit({ amuxEvent: "permission_request", permission });
-        return new Promise((resolve2, reject) => {
-          instance.permissionCallbacks.set(requestId, {
-            resolve: (optionId) => {
-              instance.pendingPermission = null;
-              instance.emit({ amuxEvent: "permission_cleared" });
-              resolve2({ outcome: { outcome: "selected", optionId } });
-            },
-            reject
-          });
-        });
-      },
-      async sessionUpdate(params) {
-        console.log(`[acp] sessionUpdate received:`, JSON.stringify(params));
-        const normalized = normalizeSessionUpdate(params.update);
-        instance.emit(normalized);
-      },
-      async readTextFile(params) {
-        const content = await fs2.readFile(params.path, "utf-8");
-        return { content };
-      },
-      async writeTextFile(params) {
-        await fs2.writeFile(params.path, params.content);
-        return {};
-      },
-      async createTerminal(params) {
-        console.log(`[acp] createTerminal request:`, JSON.stringify(params));
-        const terminalId = randomUUID4();
-        const outputByteLimit = params.outputByteLimit ?? 1024 * 1024;
-        const termProc = nodeSpawn(params.command, params.args ?? [], {
-          cwd: params.cwd ?? void 0,
-          env: params.env ? { ...process.env, ...Object.fromEntries(params.env.map((e) => [e.name, e.value])) } : process.env,
-          shell: true,
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        const terminal = {
-          process: termProc,
-          output: "",
-          exitCode: null,
-          signal: null,
-          truncated: false,
-          outputByteLimit
-        };
-        const appendOutput = (data) => {
-          terminal.output += data.toString();
-          if (terminal.output.length > terminal.outputByteLimit) {
-            terminal.output = terminal.output.slice(-terminal.outputByteLimit);
-            terminal.truncated = true;
-          }
-        };
-        termProc.stdout?.on("data", appendOutput);
-        termProc.stderr?.on("data", appendOutput);
-        termProc.on("exit", (code, signal) => {
-          console.log(`[acp] Terminal ${terminalId} exited with code ${code}, signal ${signal}`);
-          terminal.exitCode = code ?? null;
-          terminal.signal = signal ?? null;
-        });
-        termProc.on("error", (err) => {
-          console.error(`[acp] Terminal ${terminalId} error:`, err.message);
-          terminal.output += `
-Error: ${err.message}`;
-          terminal.exitCode = -1;
-        });
-        instance.terminals.set(terminalId, terminal);
-        console.log(`[acp] Created terminal ${terminalId} for command: ${params.command}`);
-        return { terminalId };
-      },
-      async terminalOutput(params) {
-        console.log(`[acp] terminalOutput request for terminal ${params.terminalId}`);
-        const terminal = instance.terminals.get(params.terminalId);
-        if (!terminal) {
-          throw new Error(`Terminal ${params.terminalId} not found`);
-        }
-        return {
-          output: terminal.output,
-          truncated: terminal.truncated,
-          exitStatus: terminal.exitCode !== null || terminal.signal !== null ? {
-            exitCode: terminal.exitCode,
-            signal: terminal.signal
-          } : void 0
-        };
-      },
-      async waitForTerminalExit(params) {
-        console.log(`[acp] waitForTerminalExit request for terminal ${params.terminalId}`);
-        const terminal = instance.terminals.get(params.terminalId);
-        if (!terminal) {
-          throw new Error(`Terminal ${params.terminalId} not found`);
-        }
-        if (terminal.exitCode !== null || terminal.signal !== null) {
-          return {
-            exitCode: terminal.exitCode,
-            signal: terminal.signal
-          };
-        }
-        return new Promise((resolve2) => {
-          terminal.process.on("exit", (code, signal) => {
-            resolve2({
-              exitCode: code ?? null,
-              signal: signal ?? null
-            });
-          });
-        });
-      },
-      // Note: killTerminalCommand not in SDK Client interface yet, but we implement handlers
-      // for completeness when the SDK adds support
-      async killTerminal(params) {
-        console.log(`[acp] killTerminal request for terminal ${params.terminalId}`);
-        const terminal = instance.terminals.get(params.terminalId);
-        if (!terminal) {
-          throw new Error(`Terminal ${params.terminalId} not found`);
-        }
-        terminal.process.kill("SIGTERM");
-        return {};
-      },
-      async releaseTerminal(params) {
-        console.log(`[acp] releaseTerminal request for terminal ${params.terminalId}`);
-        const terminal = instance.terminals.get(params.terminalId);
-        if (terminal) {
-          if (terminal.exitCode === null) {
-            terminal.process.kill("SIGKILL");
-          }
-          instance.terminals.delete(params.terminalId);
-        }
-        return {};
-      }
-    };
-  }
-  async prompt(sessionId, content, _emit) {
-    const instance = this.instances.get(sessionId);
-    if (!instance) throw new Error(`No ACP instance for window ${sessionId}`);
-    console.log(`[acp] Sending prompt to session ${instance.sessionId} with ${content.length} content block(s)...`);
-    const result = await instance.connection.prompt({
-      sessionId: instance.sessionId,
-      prompt: content
-    });
-    console.log(`[acp] Prompt complete, stopReason: ${result.stopReason}`);
-  }
-  async stop(sessionId) {
-    const instance = this.instances.get(sessionId);
-    if (!instance) return;
-    for (const [, callback] of instance.permissionCallbacks) {
-      callback.reject(new Error("Agent stopped"));
-    }
-    instance.permissionCallbacks.clear();
-    instance.pendingPermission = null;
-    this.instances.delete(sessionId);
-    await instance.process.kill();
-  }
-  async stopAll() {
-    const sessionIds = [...this.instances.keys()];
-    await Promise.all(sessionIds.map((id) => this.stop(id)));
-  }
-  isRunning(sessionId) {
-    return this.instances.has(sessionId);
-  }
-  respondToPermission(sessionId, requestId, optionId) {
-    const instance = this.instances.get(sessionId);
-    const callback = instance?.permissionCallbacks.get(requestId);
-    if (!callback) {
-      throw new Error(`No pending permission request ${requestId}`);
-    }
-    callback.resolve(optionId);
-    instance.permissionCallbacks.delete(requestId);
-  }
-  getPendingPermission(sessionId) {
-    const instance = this.instances.get(sessionId);
-    return instance?.pendingPermission ?? null;
-  }
-  async cancel(sessionId) {
-    const instance = this.instances.get(sessionId);
-    if (!instance) return;
-    await instance.connection.cancel({ sessionId: instance.sessionId });
-  }
-  async setMode(sessionId, modeId) {
-    const instance = this.instances.get(sessionId);
-    if (!instance) throw new Error(`No ACP instance for window ${sessionId}`);
-    await instance.connection.setSessionMode({
-      sessionId: instance.sessionId,
-      modeId
-    });
-  }
-  async setModel(sessionId, modelId) {
-    const instance = this.instances.get(sessionId);
-    if (!instance) throw new Error(`No ACP instance for window ${sessionId}`);
-    await instance.connection.unstable_setSessionModel({
-      sessionId: instance.sessionId,
-      modelId
-    });
-  }
-};
-
-// src/agents/backends/mock.ts
-import { randomUUID as randomUUID5 } from "crypto";
-function delay(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-var MockBackend = class {
-  type = "mock";
-  running = /* @__PURE__ */ new Set();
-  matches(config2) {
-    return config2.command === "__mock__";
-  }
-  async start(sessionId, _config, _cwd, _existingAcpSessionId, emit) {
-    console.log(`[mock] Starting mock agent for session ${sessionId}`);
-    emit({
-      sessionUpdate: "current_mode_update",
-      currentModeId: "mock"
-    });
-    console.log(`[mock] Mock agent ready for session ${sessionId}`);
-    this.running.add(sessionId);
-    return {
-      sessionId: randomUUID5(),
-      models: [{ modelId: "mock-model", name: "Mock Model" }],
-      modes: [{ id: "mock", name: "Mock Mode" }]
-    };
-  }
-  async prompt(sessionId, content, emit) {
-    const text2 = content.filter((b) => b.type === "text").map((b) => b.text).join("");
-    console.log(`[mock] Mock prompt for session ${sessionId}: "${text2.slice(0, 50)}..."`);
-    const words = [
-      "This",
-      "is",
-      "a",
-      "mock",
-      "response",
-      "from",
-      "the",
-      "mock",
-      "agent.",
-      "It",
-      "simulates",
-      "streaming",
-      "text",
-      "chunks",
-      "for",
-      "performance",
-      "testing.",
-      "The",
-      "response",
-      "arrives",
-      "in",
-      "small",
-      "pieces",
-      "to",
-      "test",
-      "UI",
-      "rendering."
-    ];
-    for (let i = 0; i < words.length; i += 3) {
-      const chunk = words.slice(i, i + 3).join(" ") + " ";
-      emit({
-        sessionUpdate: "agent_message_chunk",
-        content: { type: "text", text: chunk }
-      });
-      await delay(50);
-    }
-  }
-  async stop(sessionId) {
-    console.log(`[mock] Stopping mock agent for session ${sessionId}`);
-    this.running.delete(sessionId);
-  }
-  async stopAll() {
-    const sessionIds = [...this.running];
-    await Promise.all(sessionIds.map((id) => this.stop(id)));
-  }
-  isRunning(sessionId) {
-    return this.running.has(sessionId);
-  }
-};
-
-// src/agents/backends/stress.ts
-import { randomUUID as randomUUID7 } from "crypto";
-
-// src/stress/generators.ts
-import { randomUUID as randomUUID6 } from "crypto";
-var DEFAULT_STRESS_CONFIG = {
-  eventsPerTurn: 50,
-  toolCallProbability: 0.4,
-  thoughtProbability: 0.6,
-  planProbability: 0.3,
-  chunkSize: 50,
-  delayMs: 0
-};
-var MARKDOWN_SAMPLES = [
-  // Sample 1: Code block with TypeScript
-  `Here's a React component that handles user authentication:
-
-\`\`\`typescript
-import { useState, useEffect } from 'react';
-import { useAuth } from '@/hooks/useAuth';
-
-interface AuthProviderProps {
-  children: React.ReactNode;
-}
-
-export function AuthProvider({ children }: AuthProviderProps) {
-  const [isLoading, setIsLoading] = useState(true);
-  const { user, login, logout } = useAuth();
-
-  useEffect(() => {
-    // Check for existing session
-    const checkSession = async () => {
-      try {
-        await validateToken();
-      } finally {
-        setIsLoading(false);
-      }
-    };
-    checkSession();
-  }, []);
-
-  if (isLoading) {
-    return <LoadingSpinner />;
-  }
-
-  return (
-    <AuthContext.Provider value={{ user, login, logout }}>
-      {children}
-    </AuthContext.Provider>
-  );
-}
-\`\`\`
-
-This component wraps your app and provides authentication context.`,
-  // Sample 2: Multiple code blocks
-  `Let me show you how to set up the API client:
-
-First, install the dependencies:
-
-\`\`\`bash
-npm install @tanstack/react-query axios
-\`\`\`
-
-Then create the client:
-
-\`\`\`typescript
-// src/lib/api.ts
-import axios from 'axios';
-
-export const apiClient = axios.create({
-  baseURL: process.env.NEXT_PUBLIC_API_URL,
-  timeout: 10000,
-  headers: {
-    'Content-Type': 'application/json',
-  },
-});
-
-// Add auth interceptor
-apiClient.interceptors.request.use((config) => {
-  const token = localStorage.getItem('auth_token');
-  if (token) {
-    config.headers.Authorization = \`Bearer \${token}\`;
-  }
-  return config;
-});
-\`\`\`
-
-And set up React Query:
-
-\`\`\`typescript
-// src/providers/QueryProvider.tsx
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-
-const queryClient = new QueryClient({
-  defaultOptions: {
-    queries: {
-      staleTime: 5 * 60 * 1000,
-      retry: 1,
-    },
-  },
-});
-
-export function QueryProvider({ children }: { children: React.ReactNode }) {
-  return (
-    <QueryClientProvider client={queryClient}>
-      {children}
-    </QueryClientProvider>
-  );
-}
-\`\`\``,
-  // Sample 3: Lists and inline code
-  `Here's what I found in the codebase:
-
-1. **Components** - Located in \`src/components/\`
-   - \`Button.tsx\` - Primary button component
-   - \`Input.tsx\` - Form input with validation
-   - \`Modal.tsx\` - Accessible modal dialog
-
-2. **Hooks** - Custom React hooks in \`src/hooks/\`
-   - \`useDebounce\` - Debounces rapidly changing values
-   - \`useLocalStorage\` - Syncs state with localStorage
-   - \`useMediaQuery\` - Responsive breakpoint detection
-
-3. **Utils** - Helper functions in \`src/lib/\`
-   - \`cn()\` - Class name merger (tailwind-merge + clsx)
-   - \`formatDate()\` - Date formatting with Intl API
-   - \`validateEmail()\` - Email validation regex
-
-The main entry point is \`src/App.tsx\` which sets up routing and providers.`,
-  // Sample 4: Table and code
-  `Here's a comparison of the state management options:
-
-| Feature | Zustand | Redux | Jotai |
-|---------|---------|-------|-------|
-| Bundle size | 1.5kb | 7kb | 2kb |
-| Boilerplate | Low | High | Low |
-| DevTools | Yes | Yes | Yes |
-| TypeScript | Excellent | Good | Excellent |
-
-Based on your requirements, I recommend Zustand:
-
-\`\`\`typescript
-import { create } from 'zustand';
-
-interface AppState {
-  count: number;
-  increment: () => void;
-  decrement: () => void;
-}
-
-export const useAppStore = create<AppState>((set) => ({
-  count: 0,
-  increment: () => set((state) => ({ count: state.count + 1 })),
-  decrement: () => set((state) => ({ count: state.count - 1 })),
-}));
-\`\`\``,
-  // Sample 5: Error explanation with code
-  `I found the issue! The error occurs because of a race condition:
-
-\`\`\`typescript
-// \u274C Bug: Race condition
-useEffect(() => {
-  fetchData().then(setData);
-}, [id]);
-
-// \u2705 Fix: Cleanup function prevents stale updates
-useEffect(() => {
-  let cancelled = false;
-
-  fetchData().then((result) => {
-    if (!cancelled) {
-      setData(result);
-    }
-  });
-
-  return () => {
-    cancelled = true;
-  };
-}, [id]);
-\`\`\`
-
-The fix adds a cleanup function that sets a \`cancelled\` flag when the effect re-runs or the component unmounts.`
-];
-var THOUGHT_PREFIXES = [
-  "Let me analyze",
-  "I should check",
-  "Looking at",
-  "Considering",
-  "The approach here is",
-  "Based on the code",
-  "I need to",
-  "First",
-  "Next",
-  "This suggests",
-  "The pattern shows",
-  "Examining"
-];
-var LOREM_WORDS = [
-  "Lorem",
-  "ipsum",
-  "dolor",
-  "sit",
-  "amet",
-  "consectetur",
-  "adipiscing",
-  "elit",
-  "sed",
-  "do",
-  "eiusmod",
-  "tempor",
-  "incididunt",
-  "ut",
-  "labore",
-  "et",
-  "dolore",
-  "magna",
-  "aliqua",
-  "Ut",
-  "enim",
-  "ad",
-  "minim",
-  "veniam",
-  "quis",
-  "nostrud"
-];
-var PLAN_TASKS = [
-  "Analyze the current implementation",
-  "Identify areas for improvement",
-  "Refactor the component structure",
-  "Update the test suite",
-  "Fix type errors",
-  "Add documentation",
-  "Optimize performance",
-  "Review dependencies"
-];
-var RICH_TOOL_CALLS = [
-  // Bash tool with command and output
-  {
-    toolName: "Bash",
-    kind: "execute",
-    title: "List files in src directory",
-    input: {
-      command: "ls -la src/",
-      description: "List files in src directory"
-    },
-    output: `total 48
-drwxr-xr-x  8 user user 4096 Jan 10 14:30 .
-drwxr-xr-x 12 user user 4096 Jan 10 14:25 ..
-drwxr-xr-x  4 user user 4096 Jan 10 14:30 components
-drwxr-xr-x  2 user user 4096 Jan 10 14:28 hooks
-drwxr-xr-x  2 user user 4096 Jan 10 14:27 lib
--rw-r--r--  1 user user 1245 Jan 10 14:30 App.tsx
--rw-r--r--  1 user user  892 Jan 10 14:25 main.tsx
--rw-r--r--  1 user user 2341 Jan 10 14:29 index.css`
-  },
-  // Read tool with file contents
-  {
-    toolName: "Read",
-    kind: "read",
-    title: "Read ~/repos/project/src/utils.ts",
-    input: {
-      file_path: "/home/user/repos/project/src/utils.ts"
-    },
-    output: `export function cn(...classes: string[]): string {
-  return classes.filter(Boolean).join(' ');
-}
-
-export function formatDate(date: Date): string {
-  return new Intl.DateTimeFormat('en-US', {
-    year: 'numeric',
-    month: 'long',
-    day: 'numeric',
-  }).format(date);
-}
-
-export function debounce<T extends (...args: unknown[]) => void>(
-  fn: T,
-  delay: number
-): T {
-  let timeoutId: NodeJS.Timeout;
-  return ((...args) => {
-    clearTimeout(timeoutId);
-    timeoutId = setTimeout(() => fn(...args), delay);
-  }) as T;
-}`
-  },
-  // Edit tool with diff
-  {
-    toolName: "Edit",
-    kind: "edit",
-    title: "Edit ~/repos/project/src/config.ts",
-    input: {
-      file_path: "/home/user/repos/project/src/config.ts",
-      old_string: "timeout: 5000",
-      new_string: "timeout: 10000"
-    },
-    diff: `--- a/src/config.ts
-+++ b/src/config.ts
-@@ -5,7 +5,7 @@ export const config = {
-   apiUrl: process.env.API_URL,
-   environment: process.env.NODE_ENV,
-   features: {
--    timeout: 5000,
-+    timeout: 10000,
-     retries: 3,
-     cacheEnabled: true,
-   },`
-  },
-  // Glob tool
-  {
-    toolName: "Glob",
-    kind: "search",
-    title: 'Glob "**/*.test.ts"',
-    input: {
-      pattern: "**/*.test.ts",
-      path: "/home/user/repos/project"
-    },
-    output: `src/components/Button.test.ts
-src/components/Input.test.ts
-src/hooks/useAuth.test.ts
-src/lib/utils.test.ts
-src/lib/api.test.ts`
-  },
-  // Grep tool
-  {
-    toolName: "Grep",
-    kind: "search",
-    title: 'Grep "useState" in src/',
-    input: {
-      pattern: "useState",
-      path: "/home/user/repos/project/src"
-    },
-    output: `src/components/Counter.tsx:3:import { useState } from 'react';
-src/components/Form.tsx:1:import { useState, useCallback } from 'react';
-src/hooks/useToggle.ts:1:import { useState } from 'react';
-src/App.tsx:2:import { useState, useEffect } from 'react';`
-  },
-  // Task/subagent tool
-  {
-    toolName: "Task",
-    kind: "think",
-    title: "Explore Task",
-    input: {
-      subagent_type: "Explore",
-      description: "Find authentication implementation",
-      prompt: "Search for authentication-related files and understand the auth flow"
-    },
-    output: `Found 3 relevant files:
-- src/hooks/useAuth.ts (main auth hook)
-- src/context/AuthContext.tsx (auth provider)
-- src/lib/auth.ts (token management)
-
-The app uses JWT tokens stored in localStorage with automatic refresh.`
-  },
-  // Write tool
-  {
-    toolName: "Write",
-    kind: "edit",
-    title: "Write ~/repos/project/src/newFile.ts",
-    input: {
-      file_path: "/home/user/repos/project/src/newFile.ts",
-      content: 'export const VERSION = "1.0.0";'
-    },
-    output: "File created successfully"
-  },
-  // WebFetch tool
-  {
-    toolName: "WebFetch",
-    kind: "fetch",
-    title: "Fetch https://api.example.com/docs",
-    input: {
-      url: "https://api.example.com/docs",
-      prompt: "Get the API documentation"
-    },
-    output: `# API Documentation
-
-## Authentication
-All requests require a Bearer token in the Authorization header.
-
-## Endpoints
-- GET /users - List all users
-- POST /users - Create a user
-- GET /users/:id - Get user by ID`
-  }
-];
-function randomInt(min, max) {
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-function randomChoice(arr) {
-  return arr[Math.floor(Math.random() * arr.length)];
-}
-function generateText(length) {
-  const words = [];
-  while (words.join(" ").length < length) {
-    words.push(randomChoice(LOREM_WORDS));
-  }
-  return words.join(" ").slice(0, length);
-}
-function generateMessageChunks(totalLength, chunkSize, kind = "agent_message_chunk") {
-  const text2 = generateText(totalLength);
-  const chunks = [];
-  for (let i = 0; i < text2.length; i += chunkSize) {
-    const chunk = text2.slice(i, i + chunkSize);
-    chunks.push({
-      sessionUpdate: kind,
-      content: { type: "text", text: chunk }
-    });
-  }
-  return chunks;
-}
-function generateMarkdownChunks(chunkSize = 50) {
-  const markdown = randomChoice(MARKDOWN_SAMPLES);
-  const chunks = [];
-  for (let i = 0; i < markdown.length; i += chunkSize) {
-    const chunk = markdown.slice(i, i + chunkSize);
-    chunks.push({
-      sessionUpdate: "agent_message_chunk",
-      content: { type: "text", text: chunk }
-    });
-  }
-  return chunks;
-}
-function generateThoughtChunks(totalLength) {
-  const prefix = randomChoice(THOUGHT_PREFIXES);
-  const rest = generateText(totalLength - prefix.length);
-  const text2 = `${prefix} ${rest}`;
-  const chunkSize = randomInt(30, 60);
-  const chunks = [];
-  for (let i = 0; i < text2.length; i += chunkSize) {
-    const chunk = text2.slice(i, i + chunkSize);
-    chunks.push({
-      sessionUpdate: "agent_thought_chunk",
-      content: { type: "text", text: chunk }
-    });
-  }
-  return chunks;
-}
-function generateRichToolCall(config2) {
-  const toolCallId = randomUUID6();
-  const toolConfig = config2 ?? randomChoice(RICH_TOOL_CALLS);
-  const call = {
-    sessionUpdate: "tool_call",
-    toolCallId,
-    title: toolConfig.title,
-    status: "in_progress",
-    kind: toolConfig.kind,
-    rawInput: toolConfig.input,
-    _meta: {
-      claudeCode: {
-        toolName: toolConfig.toolName
-      }
-    }
-  };
-  const toolResponse = [];
-  if (toolConfig.output) {
-    toolResponse.push({ type: "text", text: toolConfig.output });
-  }
-  const content = [];
-  if (toolConfig.diff) {
-    content.push({ type: "diff", content: toolConfig.diff });
-  }
-  const update = {
-    sessionUpdate: "tool_call_update",
-    toolCallId,
-    status: "completed",
-    // Title update (sometimes tools update their title)
-    title: toolConfig.title.replace("...", ""),
-    _meta: {
-      claudeCode: {
-        toolName: toolConfig.toolName,
-        toolResponse: toolResponse.length > 0 ? toolResponse : void 0
-      }
-    },
-    ...content.length > 0 && { content }
-  };
-  return { call, update, toolCallId };
-}
-function generatePlan(entryCount) {
-  const entries = [];
-  const completedCount = randomInt(0, Math.floor(entryCount / 2));
-  for (let i = 0; i < entryCount; i++) {
-    const status = i < completedCount ? "completed" : i === completedCount ? "in_progress" : "pending";
-    entries.push({
-      content: randomChoice(PLAN_TASKS),
-      priority: randomChoice(["high", "medium", "low"]),
-      status
-    });
-  }
-  return {
-    sessionUpdate: "plan",
-    entries
-  };
-}
-function generateRealisticTurn(config2 = DEFAULT_STRESS_CONFIG) {
-  const events = [];
-  if (Math.random() < config2.thoughtProbability) {
-    const thoughtLength = randomInt(100, 300);
-    events.push(...generateThoughtChunks(thoughtLength));
-  }
-  if (Math.random() < config2.planProbability) {
-    events.push(generatePlan(randomInt(3, 6)));
-  }
-  if (Math.random() < config2.toolCallProbability) {
-    const toolCount = randomInt(1, 3);
-    for (let i = 0; i < toolCount; i++) {
-      const { call, update } = generateRichToolCall();
-      events.push(call);
-      if (Math.random() < 0.3) {
-        events.push(...generateThoughtChunks(randomInt(50, 100)));
-      }
-      events.push(update);
-    }
-  }
-  if (Math.random() < 0.7) {
-    events.push(...generateMarkdownChunks(config2.chunkSize));
-  } else {
-    const responseLength = randomInt(100, config2.eventsPerTurn * config2.chunkSize);
-    events.push(...generateMessageChunks(responseLength, config2.chunkSize));
-  }
-  return events;
-}
-
-// src/stress/config.ts
-var config = {
-  turnDelay: 5,
-  eventsPerTurn: 50,
-  eventDelay: 30,
-  // 30ms between events for visible streaming
-  chunkSize: 20
-  // smaller chunks look more like streaming
-};
-function getStressRuntimeConfig() {
-  return { ...config };
-}
-function setStressRuntimeConfig(updates) {
-  if (updates.turnDelay !== void 0) {
-    config.turnDelay = Math.max(0, Math.min(60, updates.turnDelay));
-  }
-  if (updates.eventsPerTurn !== void 0) {
-    config.eventsPerTurn = Math.max(10, Math.min(500, updates.eventsPerTurn));
-  }
-  if (updates.eventDelay !== void 0) {
-    config.eventDelay = Math.max(0, Math.min(200, updates.eventDelay));
-  }
-  if (updates.chunkSize !== void 0) {
-    config.chunkSize = Math.max(5, Math.min(100, updates.chunkSize));
-  }
-}
-
-// src/agents/backends/stress.ts
-function delay2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-var StressBackend = class {
-  type = "stress";
-  running = /* @__PURE__ */ new Map();
-  constructor() {
-  }
-  getConfig() {
-    const runtime = getStressRuntimeConfig();
-    return {
-      eventsPerTurn: runtime.eventsPerTurn,
-      toolCallProbability: 0.4,
-      thoughtProbability: 0.6,
-      planProbability: 0.3,
-      chunkSize: runtime.chunkSize,
-      delayMs: runtime.eventDelay
-    };
-  }
-  matches(config2) {
-    return config2.command === "__stress__";
-  }
-  async start(sessionId, _config, _cwd, _existingAcpSessionId, emit) {
-    console.log(`[stress] Starting stress agent for session ${sessionId}`);
-    emit({
-      sessionUpdate: "current_mode_update",
-      currentModeId: "stress"
-    });
-    const agent = { emit, stopped: false };
-    this.running.set(sessionId, agent);
-    this.runEventLoop(sessionId, agent);
-    console.log(`[stress] Stress agent ready for session ${sessionId}`);
-    return {
-      sessionId: randomUUID7(),
-      models: [{ modelId: "stress-model", name: "Stress Model" }],
-      modes: [{ id: "stress", name: "Stress Mode" }]
-    };
-  }
-  getTurnDelayMs() {
-    const { turnDelay } = getStressRuntimeConfig();
-    if (turnDelay === 0) {
-      return 0;
-    }
-    const variance = turnDelay * 0.5;
-    return (turnDelay - variance + Math.random() * variance * 2) * 1e3;
-  }
-  async runEventLoop(sessionId, agent) {
-    await delay2(1e3);
-    let turnCount = 0;
-    while (!agent.stopped) {
-      turnCount++;
-      agent.emit({ amuxEvent: "turn_start" });
-      agent.emit({
-        sessionUpdate: "user_message_chunk",
-        content: { type: "text", text: `[Stress test turn ${turnCount}]` }
-      });
-      const config2 = this.getConfig();
-      const events = generateRealisticTurn(config2);
-      for (const event of events) {
-        if (agent.stopped) break;
-        agent.emit(event);
-        if (config2.delayMs > 0) {
-          await delay2(config2.delayMs);
-        }
-      }
-      if (!agent.stopped) {
-        agent.emit({ amuxEvent: "turn_end" });
-      }
-      const turnDelay = this.getTurnDelayMs();
-      await delay2(turnDelay);
-    }
-    console.log(`[stress] Event loop stopped for session ${sessionId}`);
-  }
-  async prompt(sessionId, content, emit) {
-    const text2 = content.filter((b) => b.type === "text").map((b) => b.text).join("");
-    console.log(`[stress] Prompt for session ${sessionId}: "${text2.slice(0, 50)}..."`);
-    const config2 = this.getConfig();
-    const events = generateRealisticTurn(config2);
-    for (const event of events) {
-      emit(event);
-      if (config2.delayMs > 0) {
-        await delay2(config2.delayMs);
-      }
-    }
-  }
-  async stop(sessionId) {
-    console.log(`[stress] Stopping stress agent for session ${sessionId}`);
-    const agent = this.running.get(sessionId);
-    if (agent) {
-      agent.stopped = true;
-      this.running.delete(sessionId);
-    }
-  }
-  async stopAll() {
-    const sessionIds = [...this.running.keys()];
-    await Promise.all(sessionIds.map((id) => this.stop(id)));
-  }
-  isRunning(sessionId) {
-    return this.running.has(sessionId);
-  }
-};
-
-// src/lib/mentions.ts
-import path2 from "path";
-function parseMessageToContentBlocks(message, workingDir) {
-  const blocks = [];
-  const mentionRegex = /@(\.{0,2}[\w\/\.\-]+)/g;
-  let lastIndex = 0;
-  for (const match of message.matchAll(mentionRegex)) {
-    if (match.index > lastIndex) {
-      const text2 = message.slice(lastIndex, match.index);
-      if (text2.trim()) {
-        blocks.push({ type: "text", text: text2 });
-      }
-    }
-    const relativePath = match[1];
-    const absolutePath = path2.resolve(workingDir, relativePath);
-    blocks.push({
-      type: "resource_link",
-      uri: `file://${absolutePath}`,
-      name: relativePath
-      // Required per ACP spec - use the path the user typed
-    });
-    lastIndex = match.index + match[0].length;
-  }
-  if (lastIndex < message.length) {
-    const text2 = message.slice(lastIndex);
-    if (text2.trim()) {
-      blocks.push({ type: "text", text: text2 });
-    }
-  }
-  return blocks.length > 0 ? blocks : [{ type: "text", text: message }];
-}
-
-// src/agents/manager.ts
-function generateTitleFromMessage(message) {
-  const cleaned = message.replace(/@[\w./~-]+/g, "").replace(/\s+/g, " ").trim();
-  const firstLine = cleaned.split("\n")[0] || cleaned;
-  if (firstLine.length <= 50) return firstLine;
-  const truncated = firstLine.slice(0, 50);
-  const lastSpace = truncated.lastIndexOf(" ");
-  return lastSpace > 20 ? truncated.slice(0, lastSpace) + "..." : truncated + "...";
-}
-var AgentManager = class extends EventEmitter {
-  backends;
-  agents = /* @__PURE__ */ new Map();
-  constructor() {
-    super();
-    const acpBackend = new AcpBackend();
-    acpBackend.onSessionIdChanged = (sessionId, acpSessionId) => {
-      db.update(sessions).set({ acpSessionId }).where(eq2(sessions.id, sessionId)).run();
-    };
-    this.backends = [acpBackend, new MockBackend(), new StressBackend()];
-  }
-  getBackendForConfig(config2) {
-    const backend = this.backends.find((b) => b.matches(config2));
-    if (!backend) {
-      throw new Error(`No backend for agent config: ${config2.command}`);
-    }
-    return backend;
-  }
-  emitUpdate(sessionId, update) {
-    storeEvent(sessionId, update);
-    if (isSessionUpdate(update) && update.sessionUpdate === "session_info_update") {
-      const title = update.title;
-      if (title !== void 0) {
-        db.update(sessions).set({ title }).where(eq2(sessions.id, sessionId)).run();
-      }
-    }
-    this.emit("update", { sessionId, update });
-  }
-  async startForSession(sessionId) {
-    const existing = this.agents.get(sessionId);
-    if (existing?.status === "ready") {
-      const replayEvents2 = getEventsForSession(sessionId);
-      return {
-        acpSessionId: existing.session.sessionId,
-        replayEvents: replayEvents2,
-        models: existing.session.models,
-        modes: existing.session.modes
-      };
-    }
-    if (existing?.status === "starting") {
-      return new Promise((resolve2, reject) => {
-        const checkReady = () => {
-          const agent = this.agents.get(sessionId);
-          if (agent?.status === "ready") {
-            const replayEvents2 = getEventsForSession(sessionId);
-            resolve2({
-              acpSessionId: agent.session.sessionId,
-              replayEvents: replayEvents2,
-              models: agent.session.models,
-              modes: agent.session.modes
-            });
-          } else if (agent?.status === "dead") {
-            reject(new Error("Agent failed to start"));
-          } else {
-            setTimeout(checkReady, 100);
-          }
-        };
-        checkReady();
-      });
-    }
-    const session = db.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
-    if (!session) throw new Error(`Session ${sessionId} not found`);
-    const dbConfig = db.select().from(agentConfigs).where(eq2(agentConfigs.id, session.agentConfigId)).get();
-    if (!dbConfig) throw new Error(`Agent config ${session.agentConfigId} not found`);
-    const config2 = {
-      id: dbConfig.id,
-      name: dbConfig.name,
-      command: dbConfig.command,
-      args: dbConfig.args ?? [],
-      env: dbConfig.env ?? {}
-    };
-    const backend = this.getBackendForConfig(config2);
-    const emit = (update) => this.emitUpdate(sessionId, update);
-    this.agents.set(sessionId, {
-      backend,
-      session: { sessionId: "" },
-      status: "starting"
-    });
-    const replayEvents = getEventsForSession(sessionId);
-    try {
-      const agentSession = await backend.start(sessionId, config2, session.directory, session.acpSessionId ?? null, emit);
-      this.agents.set(sessionId, {
-        backend,
-        session: agentSession,
-        status: "ready"
-      });
-      console.log(`[agents] Agent ready for session ${sessionId}`);
-      return {
-        acpSessionId: agentSession.sessionId,
-        replayEvents,
-        models: agentSession.models,
-        modes: agentSession.modes
-      };
-    } catch (err) {
-      this.agents.set(sessionId, {
-        backend,
-        session: { sessionId: "" },
-        status: "dead"
-      });
-      throw err;
-    }
-  }
-  // Legacy alias for compatibility during migration
-  /** @deprecated Use startForSession instead */
-  startForWindow = this.startForSession.bind(this);
-  async prompt(sessionId, message) {
-    console.log(`[agents] prompt() called for session ${sessionId}: "${message.slice(0, 50)}..."`);
-    const agent = this.agents.get(sessionId);
-    if (!agent || agent.status !== "ready") {
-      throw new Error(`Agent not ready for session ${sessionId}`);
-    }
-    const session = db.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
-    if (!session) throw new Error(`Session ${sessionId} not found`);
-    if (!session.title) {
-      const title = generateTitleFromMessage(message);
-      if (title) {
-        db.update(sessions).set({ title }).where(eq2(sessions.id, sessionId)).run();
-        this.emitUpdate(sessionId, {
-          sessionUpdate: "session_info_update",
-          title
-        });
-      }
-    }
-    startTurn(sessionId);
-    this.emitUpdate(sessionId, { amuxEvent: "turn_start" });
-    this.emitUpdate(sessionId, {
-      sessionUpdate: "user_message_chunk",
-      content: { type: "text", text: message }
-    });
-    const content = parseMessageToContentBlocks(message, session.directory);
-    const emit = (update) => this.emitUpdate(sessionId, update);
-    try {
-      await agent.backend.prompt(sessionId, content, emit);
-    } finally {
-      endTurn(sessionId);
-      this.emitUpdate(sessionId, { amuxEvent: "turn_end" });
-    }
-  }
-  async setMode(sessionId, modeId) {
-    const agent = this.agents.get(sessionId);
-    if (!agent || agent.status !== "ready") {
-      throw new Error(`Agent not ready for session ${sessionId}`);
-    }
-    if (!agent.backend.setMode) {
-      throw new Error(`Backend ${agent.backend.type} does not support setMode`);
-    }
-    await agent.backend.setMode(sessionId, modeId);
-  }
-  async setModel(sessionId, modelId) {
-    const agent = this.agents.get(sessionId);
-    if (!agent || agent.status !== "ready") {
-      throw new Error(`Agent not ready for session ${sessionId}`);
-    }
-    if (!agent.backend.setModel) {
-      throw new Error(`Backend ${agent.backend.type} does not support setModel`);
-    }
-    await agent.backend.setModel(sessionId, modelId);
-  }
-  async cancel(sessionId) {
-    const agent = this.agents.get(sessionId);
-    if (!agent?.backend.cancel) return;
-    await agent.backend.cancel(sessionId);
-  }
-  respondPermission(sessionId, requestId, optionId) {
-    const agent = this.agents.get(sessionId);
-    if (!agent) {
-      console.warn(`[AgentManager] No agent running for session ${sessionId}, ignoring permission response`);
-      return;
-    }
-    if (!agent.backend.respondToPermission) {
-      throw new Error(`Backend ${agent.backend.type} does not support permissions`);
-    }
-    agent.backend.respondToPermission(sessionId, requestId, optionId);
-  }
-  async stopForSession(sessionId) {
-    const agent = this.agents.get(sessionId);
-    if (agent) {
-      await agent.backend.stop(sessionId);
-    }
-    this.agents.delete(sessionId);
-  }
-  // Legacy alias for compatibility during migration
-  /** @deprecated Use stopForSession instead */
-  stopForWindow = this.stopForSession.bind(this);
-  async stopAll() {
-    const sessionIds = Array.from(this.agents.keys());
-    await Promise.all(sessionIds.map((id) => this.stopForSession(id)));
-  }
-  getForSession(sessionId) {
-    return this.agents.get(sessionId);
-  }
-  getPendingPermission(sessionId) {
-    const agent = this.agents.get(sessionId);
-    if (!agent?.backend.getPendingPermission) return null;
-    return agent.backend.getPendingPermission(sessionId);
-  }
-  // Legacy alias for compatibility during migration
-  /** @deprecated Use getForSession instead */
-  getForWindow = this.getForSession.bind(this);
-  registerBackend(backend) {
-    this.backends.unshift(backend);
-  }
-};
-var agentManager = new AgentManager();
-
-// src/trpc/sessions.ts
-var sessionsRouter = router({
-  /**
-   * List all sessions with agent configs.
-   * Note: No activeSessionId - that's a UI concern (Shella).
-   */
-  list: publicProcedure.query(async () => {
-    const allSessions = db.select().from(sessions).orderBy(sessions.createdAt).all();
-    const configs = db.select().from(agentConfigs).all();
-    const lastUsedRow = db.select().from(appState).where(eq3(appState.key, "last_used_agent_config_id")).get();
-    return {
-      sessions: allSessions,
-      agentConfigs: configs,
-      lastUsedAgentConfigId: lastUsedRow?.value ?? configs[0]?.id ?? null
-    };
-  }),
-  /**
-   * Get a single session by ID.
-   */
-  get: publicProcedure.input(z.object({ id: z.string() })).query(async ({ input }) => {
-    const session = db.select().from(sessions).where(eq3(sessions.id, input.id)).get();
-    if (!session) {
-      throw new Error(`Session ${input.id} not found`);
-    }
-    return session;
-  }),
-  /**
-   * Create a new session.
-   * Note: No title - that's a UI concern (Shella).
-   */
-  create: publicProcedure.input(z.object({
-    id: z.string().optional(),
-    // Client can provide ID for optimistic updates
-    directory: z.string().optional(),
-    agentConfigId: z.string().optional()
-  })).mutation(async ({ input }) => {
-    let configId = input.agentConfigId;
-    if (!configId) {
-      const lastUsedRow = db.select().from(appState).where(eq3(appState.key, "last_used_agent_config_id")).get();
-      if (lastUsedRow?.value) {
-        const config2 = db.select().from(agentConfigs).where(eq3(agentConfigs.id, lastUsedRow.value)).get();
-        if (config2) configId = config2.id;
-      }
-      if (!configId) {
-        const firstConfig = db.select().from(agentConfigs).get();
-        if (!firstConfig) {
-          throw new Error("No agent configs available");
-        }
-        configId = firstConfig.id;
-      }
-    } else {
-      db.insert(appState).values({ key: "last_used_agent_config_id", value: configId }).onConflictDoUpdate({ target: appState.key, set: { value: configId } }).run();
-    }
-    const id = input.id ?? randomUUID8();
-    const now = /* @__PURE__ */ new Date();
-    db.insert(sessions).values({
-      id,
-      directory: input.directory ?? getStartupCwd(),
-      agentConfigId: configId,
-      acpSessionId: null,
-      model: null,
-      mode: null,
-      createdAt: now
-    }).run();
-    return db.select().from(sessions).where(eq3(sessions.id, id)).get();
-  }),
-  /**
-   * Update a session.
-   * Note: No title/hasCustomTitle/lastAccessedAt - those are UI concerns (Shella).
-   */
-  update: publicProcedure.input(z.object({
-    id: z.string(),
-    directory: z.string().optional(),
-    agentConfigId: z.string().optional(),
-    acpSessionId: z.string().nullable().optional(),
-    model: z.string().nullable().optional(),
-    mode: z.string().nullable().optional()
-  })).mutation(async ({ input }) => {
-    const { id, ...updates } = input;
-    db.update(sessions).set(updates).where(eq3(sessions.id, id)).run();
-    if (input.agentConfigId) {
-      db.insert(appState).values({ key: "last_used_agent_config_id", value: input.agentConfigId }).onConflictDoUpdate({ target: appState.key, set: { value: input.agentConfigId } }).run();
-    }
-    return db.select().from(sessions).where(eq3(sessions.id, id)).get();
-  }),
-  /**
-   * Delete a session.
-   * Note: No active session management - that's a UI concern (Shella).
-   */
-  delete: publicProcedure.input(z.object({ id: z.string() })).mutation(async ({ input }) => {
-    await agentManager.stopForSession(input.id);
-    clearEventsForSession(input.id);
-    db.delete(sessions).where(eq3(sessions.id, input.id)).run();
-    return { ok: true };
-  })
-});
-
-// src/trpc/agents.ts
-import { z as z2 } from "zod";
-import { observable } from "@trpc/server/observable";
-import { eq as eq4 } from "drizzle-orm";
-
-// src/lib/shutdown.ts
-var isShuttingDown = false;
-function setShuttingDown(value) {
-  isShuttingDown = value;
-}
-
-// src/trpc/agents.ts
-var sessionIdInput = z2.object({
-  sessionId: z2.string()
-});
-var agentsRouter = router({
-  start: publicProcedure.input(sessionIdInput).mutation(async ({ input }) => {
-    if (isShuttingDown) {
-      throw new Error("Server is shutting down");
-    }
-    return agentManager.startForSession(input.sessionId);
-  }),
-  stop: publicProcedure.input(sessionIdInput).mutation(async ({ input }) => {
-    await agentManager.stopForSession(input.sessionId);
-    return { ok: true };
-  }),
-  switchAgent: publicProcedure.input(z2.object({
-    sessionId: z2.string(),
-    agentConfigId: z2.string()
-  })).mutation(async ({ input }) => {
-    const { sessionId, agentConfigId } = input;
-    await agentManager.stopForSession(sessionId);
-    clearEventsForSession(sessionId);
-    db.update(sessions).set({
-      agentConfigId,
-      acpSessionId: null,
-      model: null,
-      mode: null
-    }).where(eq4(sessions.id, sessionId)).run();
-    db.insert(appState).values({ key: "last_used_agent_config_id", value: agentConfigId }).onConflictDoUpdate({ target: appState.key, set: { value: agentConfigId } }).run();
-    return { ok: true };
-  }),
-  prompt: publicProcedure.input(z2.object({
-    sessionId: z2.string(),
-    message: z2.string()
-  })).mutation(async ({ input }) => {
-    await agentManager.prompt(input.sessionId, input.message);
-    return { ok: true };
-  }),
-  cancel: publicProcedure.input(sessionIdInput).mutation(async ({ input }) => {
-    await agentManager.cancel(input.sessionId);
-    return { ok: true };
-  }),
-  setMode: publicProcedure.input(z2.object({
-    sessionId: z2.string(),
-    modeId: z2.string()
-  })).mutation(async ({ input }) => {
-    await agentManager.setMode(input.sessionId, input.modeId);
-    return { ok: true };
-  }),
-  setModel: publicProcedure.input(z2.object({
-    sessionId: z2.string(),
-    modelId: z2.string()
-  })).mutation(async ({ input }) => {
-    await agentManager.setModel(input.sessionId, input.modelId);
-    return { ok: true };
-  }),
-  respondPermission: publicProcedure.input(z2.object({
-    sessionId: z2.string(),
-    requestId: z2.string(),
-    optionId: z2.string()
-  })).mutation(({ input }) => {
-    agentManager.respondPermission(input.sessionId, input.requestId, input.optionId);
-    return { ok: true };
-  }),
-  subscribe: publicProcedure.input(sessionIdInput).subscription(({ input }) => {
-    return observable((emit) => {
-      const handler = (event) => {
-        if (event.sessionId === input.sessionId) {
-          emit.next(event.update);
-        }
-      };
-      agentManager.on("update", handler);
-      return () => agentManager.off("update", handler);
-    });
-  }),
-  subscribeAll: publicProcedure.subscription(() => {
-    return observable((emit) => {
-      const handler = (event) => emit.next(event);
-      agentManager.on("update", handler);
-      return () => agentManager.off("update", handler);
-    });
-  }),
-  // Stress testing config
-  setStressConfig: publicProcedure.input(z2.object({
-    turnDelay: z2.number().min(0).max(60).optional(),
-    eventsPerTurn: z2.number().min(10).max(500).optional(),
-    eventDelay: z2.number().min(0).max(200).optional(),
-    chunkSize: z2.number().min(5).max(100).optional()
-  })).mutation(({ input }) => {
-    setStressRuntimeConfig(input);
-    return { ok: true };
-  }),
-  getStressConfig: publicProcedure.query(() => {
-    return getStressRuntimeConfig();
-  })
-});
-
-// src/trpc/agentConfigs.ts
-import { z as z3 } from "zod";
-import { eq as eq5 } from "drizzle-orm";
-import { randomUUID as randomUUID9 } from "crypto";
-var agentConfigsRouter = router({
-  list: publicProcedure.query(async () => {
-    return db.select().from(agentConfigs).all();
-  }),
-  get: publicProcedure.input(z3.object({ id: z3.string() })).query(async ({ input }) => {
-    return db.select().from(agentConfigs).where(eq5(agentConfigs.id, input.id)).get();
-  }),
-  create: publicProcedure.input(z3.object({
-    name: z3.string(),
-    command: z3.string(),
-    args: z3.array(z3.string()).default([]),
-    env: z3.record(z3.string()).default({})
-  })).mutation(async ({ input }) => {
-    const id = randomUUID9();
-    db.insert(agentConfigs).values({ id, ...input }).run();
-    return db.select().from(agentConfigs).where(eq5(agentConfigs.id, id)).get();
-  }),
-  update: publicProcedure.input(z3.object({
-    id: z3.string(),
-    name: z3.string().optional(),
-    command: z3.string().optional(),
-    args: z3.array(z3.string()).optional(),
-    env: z3.record(z3.string()).optional()
-  })).mutation(async ({ input }) => {
-    const { id, ...updates } = input;
-    db.update(agentConfigs).set(updates).where(eq5(agentConfigs.id, id)).run();
-    return db.select().from(agentConfigs).where(eq5(agentConfigs.id, id)).get();
-  }),
-  delete: publicProcedure.input(z3.object({ id: z3.string() })).mutation(async ({ input }) => {
-    db.delete(agentConfigs).where(eq5(agentConfigs.id, input.id)).run();
-    return { ok: true };
-  })
-});
-
-// src/trpc/files.ts
-import { z as z4 } from "zod";
-import { eq as eq6 } from "drizzle-orm";
-import * as fs3 from "fs/promises";
-import * as path3 from "path";
-import { glob } from "glob";
-async function listFilesForAutocomplete(workingDir, partialPath, limit) {
-  const normalized = partialPath.startsWith("./") ? partialPath.slice(2) : partialPath;
-  if (normalized.includes("/")) {
-    return listFilesPrefix(workingDir, normalized, limit);
-  }
-  return listFilesFuzzy(workingDir, normalized, limit);
-}
-async function listFilesPrefix(workingDir, partialPath, limit) {
-  const lastSlash = partialPath.lastIndexOf("/");
-  const dirPart = lastSlash >= 0 ? partialPath.slice(0, lastSlash) : "";
-  const prefix = lastSlash >= 0 ? partialPath.slice(lastSlash + 1) : partialPath;
-  const targetDir = path3.resolve(workingDir, dirPart);
-  const normalizedWorkingDir = path3.resolve(workingDir);
-  const normalizedTargetDir = path3.resolve(targetDir);
-  if (!normalizedTargetDir.startsWith(normalizedWorkingDir)) {
-    return [];
-  }
-  try {
-    const entries = await fs3.readdir(targetDir, { withFileTypes: true });
-    const matching = entries.filter((e) => !e.name.startsWith(".")).filter((e) => prefix === "" || e.name.toLowerCase().startsWith(prefix.toLowerCase())).slice(0, limit * 2).map((e) => ({
-      name: e.name,
-      path: dirPart ? `${dirPart}/${e.name}` : e.name,
-      isDirectory: e.isDirectory()
-    }));
-    matching.sort((a, b) => {
-      if (a.isDirectory !== b.isDirectory) {
-        return a.isDirectory ? -1 : 1;
-      }
-      return a.name.localeCompare(b.name);
-    });
-    return matching.slice(0, limit);
-  } catch {
-    return [];
-  }
-}
-async function listFilesFuzzy(workingDir, query, limit) {
-  if (!query.trim()) return [];
-  try {
-    const pattern = `{*${query}*,**/*${query}*}`;
-    const matches = await glob(pattern, {
-      cwd: workingDir,
-      nodir: false,
-      dot: false,
-      // Skip hidden files
-      ignore: ["**/node_modules/**", "**/.git/**"],
-      maxDepth: 10
-    });
-    const results = [];
-    for (const match of matches.slice(0, limit * 2)) {
-      try {
-        const fullPath = path3.join(workingDir, match);
-        const stat2 = await fs3.stat(fullPath);
-        results.push({
-          name: path3.basename(match),
-          path: match,
-          isDirectory: stat2.isDirectory()
-        });
-      } catch {
-      }
-    }
-    results.sort((a, b) => {
-      if (a.isDirectory !== b.isDirectory) {
-        return a.isDirectory ? -1 : 1;
-      }
-      const aDepth = a.path.split("/").length;
-      const bDepth = b.path.split("/").length;
-      if (aDepth !== bDepth) {
-        return aDepth - bDepth;
-      }
-      return a.path.localeCompare(b.path);
-    });
-    return results.slice(0, limit);
-  } catch {
-    return [];
-  }
-}
-var filesRouter = router({
-  /**
-   * List files/directories matching a partial path for autocomplete.
-   * Returns files in the session's working directory.
-   */
-  listForAutocomplete: publicProcedure.input(z4.object({
-    sessionId: z4.string(),
-    partialPath: z4.string(),
-    limit: z4.number().default(20)
-  })).query(async ({ input }) => {
-    const session = db.select().from(sessions).where(eq6(sessions.id, input.sessionId)).get();
-    if (!session) throw new Error(`Session ${input.sessionId} not found`);
-    return listFilesForAutocomplete(
-      session.directory,
-      input.partialPath,
-      input.limit
-    );
-  })
-});
-
-// src/trpc/router.ts
-var appRouter = router({
-  sessions: sessionsRouter,
-  agents: agentsRouter,
-  agentConfigs: agentConfigsRouter,
-  files: filesRouter
-});
-
-// src/server.ts
-function createAmuxServer(options = {}) {
-  const app = express();
-  app.use(cors());
-  app.use(express.json());
-  app.use("/trpc", createExpressMiddleware({ router: appRouter }));
-  app.get("/health", (_req, res) => res.json({ status: "ok", dbPath: getDbPath() }));
-  const server = createServer(app);
-  const wss = new WebSocketServer({ server, path: "/trpc" });
-  applyWSSHandler({ wss, router: appRouter });
-  return {
-    app,
-    server,
-    wss,
-    start: (port) => {
-      return new Promise((resolve2) => {
-        server.listen(port, () => {
-          console.log(`[amux] Running on http://localhost:${port}`);
-          console.log(`[amux] WebSocket at ws://localhost:${port}/trpc`);
-          console.log(`[amux] Database at ${getDbPath()}`);
-          options.onReady?.(port);
-          resolve2();
-        });
-      });
-    },
-    stop: async () => {
-      setShuttingDown(true);
-      console.log("[amux] Shutting down...");
-      wss.close();
-      await agentManager.stopAll();
-      console.log("[amux] Agents stopped");
-      server.close();
-    }
-  };
-}
+  createAmuxServer
+} from "../chunk-YYN3GXYP.js";
+import "../chunk-2NON2HR2.js";
+import "../chunk-SX7NC3ZM.js";
+import "../chunk-226DBKL3.js";
+import "../chunk-5IPYOXBE.js";
+import "../chunk-L4DBPVMA.js";
+import "../chunk-OQ5K5ON2.js";
+import "../chunk-PZ5AY32C.js";
 
 // bin/cli.ts
+import { program } from "commander";
 var VERSION = "0.1.0";
 program.name("amux").description("Agent Multiplexer - headless server for AI coding agents").version(VERSION).option("-p, --port <port>", "Server port", "3078").action(async (options) => {
   const port = parseInt(options.port, 10);