@bytespell/amux 0.0.1 → 0.0.2

package/dist/src/agents/manager.js

@@ -1,1744 +1,11 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/agents/manager.ts
-import { EventEmitter } from "events";
-
-// 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 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/agents/manager.ts
-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);
-}
-
-// 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((resolve) => {
-    treeKill(pid, signal, (err) => {
-      if (err && !err.message.includes("No such process")) {
-        console.error(`[process] kill error pid=${pid}:`, err.message);
-      }
-      resolve();
-    });
-  });
-}
-
-// 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 path3 = item.path;
-    if (newText === void 0) return item;
-    const filePath = path3 ?? "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((resolve) => setTimeout(resolve, 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((resolve, reject) => {
-          instance.permissionCallbacks.set(requestId, {
-            resolve: (optionId) => {
-              instance.pendingPermission = null;
-              instance.emit({ amuxEvent: "permission_cleared" });
-              resolve({ 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((resolve) => {
-          terminal.process.on("exit", (code, signal) => {
-            resolve({
-              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((resolve) => setTimeout(resolve, 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 };
-}
-
-// src/agents/backends/stress.ts
-function delay2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, 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((resolve, reject) => {
-        const checkReady = () => {
-          const agent = this.agents.get(sessionId);
-          if (agent?.status === "ready") {
-            const replayEvents2 = getEventsForSession(sessionId);
-            resolve({
-              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();
+  agentManager
+} from "../../chunk-RSLSN7F2.js";
+import "../../chunk-SX7NC3ZM.js";
+import "../../chunk-226DBKL3.js";
+import "../../chunk-5IPYOXBE.js";
+import "../../chunk-OQ5K5ON2.js";
+import "../../chunk-PZ5AY32C.js";
 export {
   agentManager
 };