aemeathcli 1.0.0

package/dist/index.js

@@ -0,0 +1,1419 @@
+export { AgentProcess, MessageBus, PlanApproval, TaskStore, TeamManager } from './chunk-HMJRPNPZ.js';
+export { MCPClient, MCPServerManager } from './chunk-MFBHNWGV.js';
+export { SkillLoader, SkillRegistry } from './chunk-TEVZS4FA.js';
+export { ConfigStore } from './chunk-IYW62KKR.js';
+export { SkillExecutor } from './chunk-LSOYPSAT.js';
+export { ContextManager, CostTracker, ModelRouter, PermissionManager, TaskOrchestrator, createModelRouter } from './chunk-DAHGLHNR.js';
+export { ToolRegistry, createDefaultRegistry } from './chunk-Y5XVD2CD.js';
+export { ClaudeAdapter } from './chunk-WAHVZH7V.js';
+export { ClaudeNativeCLIAdapter, CodexNativeCLIAdapter, GeminiNativeCLIAdapter, KimiNativeCLIAdapter } from './chunk-6PDJ45T4.js';
+export { OpenAIAdapter } from './chunk-WPP3PEDE.js';
+export { GeminiAdapter } from './chunk-UY2SYSEZ.js';
+export { KimiAdapter } from './chunk-MXZSI3AY.js';
+export { OllamaAdapter } from './chunk-H66O5Z2V.js';
+export { ProviderRegistry } from './chunk-O3ZF22SW.js';
+export { LayoutEngine, TmuxManager } from './chunk-CARHU3DO.js';
+import { getEventBus } from './chunk-YL5XFHR3.js';
+export { getEventBus } from './chunk-YL5XFHR3.js';
+export { SessionManager } from './chunk-SUSJPZU2.js';
+import './chunk-I5PZ4JTS.js';
+export { CredentialStore } from './chunk-4IJD72YB.js';
+import { withRetry, sleep } from './chunk-CGEV3ARR.js';
+export { DEFAULT_CONFIG } from './chunk-CYQNBB25.js';
+import { getDatabasePath, ensureDirectory, getDatabaseDir, getIPCSocketPath, ensureSecureDirectory, getIPCSocketDir } from './chunk-NBR3GHMT.js';
+import './chunk-CS5X3BWX.js';
+export { DEFAULT_MODEL_ID, SUPPORTED_MODELS } from './chunk-HCIHOHLX.js';
+import { AgentSpawnError, IPCError, ToolCallError } from './chunk-ZGOHARPV.js';
+export { AemeathError, AgentSpawnError, AuthenticationError, ContextOverflowError, ExecutionTimeoutError, FileNotFoundError, IPCError, InvalidConfigError, MissingConfigError, ModelNotFoundError, PermissionDeniedError, RateLimitError, ServerConnectionError, ToolCallError } from './chunk-ZGOHARPV.js';
+import { logger } from './chunk-JAXXTYID.js';
+import Database from 'better-sqlite3';
+import { chmodSync } from 'fs';
+import { randomUUID, randomBytes, createHmac, timingSafeEqual } from 'crypto';
+import { execa } from 'execa';
+import { createServer, connect } from 'net';
+import { chmod, unlink } from 'fs/promises';
+
+// src/storage/migrations/001-initial.ts
+var CREATE_CONVERSATIONS = `
+CREATE TABLE IF NOT EXISTS conversations (
+  id TEXT PRIMARY KEY,
+  project_root TEXT NOT NULL,
+  default_model TEXT,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now')),
+  metadata TEXT DEFAULT '{}'
+)`;
+var CREATE_MESSAGES = `
+CREATE TABLE IF NOT EXISTS messages (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+  role TEXT NOT NULL,
+  model TEXT,
+  provider TEXT,
+  content TEXT NOT NULL,
+  tool_calls TEXT,
+  token_usage TEXT,
+  created_at TEXT DEFAULT (datetime('now'))
+)`;
+var CREATE_FILE_CONTEXT = `
+CREATE TABLE IF NOT EXISTS file_context (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+  file_path TEXT NOT NULL,
+  content_hash TEXT,
+  token_count INTEGER,
+  added_at TEXT DEFAULT (datetime('now'))
+)`;
+var CREATE_COST_TRACKING = `
+CREATE TABLE IF NOT EXISTS cost_tracking (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+  provider TEXT NOT NULL,
+  model TEXT NOT NULL,
+  role TEXT,
+  input_tokens INTEGER,
+  output_tokens INTEGER,
+  cost_usd REAL,
+  created_at TEXT DEFAULT (datetime('now'))
+)`;
+var CREATE_TEAMS = `
+CREATE TABLE IF NOT EXISTS teams (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  status TEXT DEFAULT 'active',
+  config TEXT,
+  created_at TEXT DEFAULT (datetime('now'))
+)`;
+var CREATE_INDEXES = [
+  "CREATE INDEX IF NOT EXISTS idx_messages_conversation ON messages(conversation_id)",
+  "CREATE INDEX IF NOT EXISTS idx_cost_conversation ON cost_tracking(conversation_id)",
+  "CREATE INDEX IF NOT EXISTS idx_cost_provider ON cost_tracking(provider)",
+  "CREATE INDEX IF NOT EXISTS idx_file_context_conversation ON file_context(conversation_id)"
+];
+function up(db) {
+  db.transaction(() => {
+    db.exec(CREATE_CONVERSATIONS);
+    db.exec(CREATE_MESSAGES);
+    db.exec(CREATE_FILE_CONTEXT);
+    db.exec(CREATE_COST_TRACKING);
+    db.exec(CREATE_TEAMS);
+    for (const sql of CREATE_INDEXES) {
+      db.exec(sql);
+    }
+  })();
+}
+
+// src/storage/sqlite-store.ts
+var MIGRATIONS_TABLE_DDL = `
+CREATE TABLE IF NOT EXISTS _migrations (
+  id TEXT PRIMARY KEY,
+  applied_at TEXT DEFAULT (datetime('now'))
+)`;
+var MIGRATIONS = [
+  { id: "001-initial", up }
+];
+var SqliteStore = class {
+  db;
+  closed = false;
+  get database() {
+    if (this.closed || !this.db) {
+      throw new Error("SqliteStore is closed or not initialized");
+    }
+    return this.db;
+  }
+  open(dbPath) {
+    if (this.db) {
+      return;
+    }
+    const resolvedPath = dbPath ?? getDatabasePath();
+    ensureDirectory(getDatabaseDir());
+    logger.info({ path: resolvedPath }, "Opening SQLite database");
+    this.db = new Database(resolvedPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 5000");
+    this.db.pragma("foreign_keys = ON");
+    this.db.pragma("synchronous = NORMAL");
+    try {
+      chmodSync(resolvedPath, 384);
+    } catch {
+      logger.warn(
+        { path: resolvedPath },
+        "Could not set database file permissions to 600"
+      );
+    }
+    this.runMigrations();
+    this.registerCleanupHandlers();
+  }
+  runMigrations() {
+    const db = this.database;
+    db.exec(MIGRATIONS_TABLE_DDL);
+    const appliedStmt = db.prepare(
+      "SELECT id FROM _migrations WHERE id = ?"
+    );
+    const insertStmt = db.prepare(
+      "INSERT INTO _migrations (id) VALUES (?)"
+    );
+    for (const migration of MIGRATIONS) {
+      const existing = appliedStmt.get(migration.id);
+      if (!existing) {
+        logger.info({ migrationId: migration.id }, "Running migration");
+        db.transaction(() => {
+          migration.up(db);
+          insertStmt.run(migration.id);
+        })();
+        logger.info({ migrationId: migration.id }, "Migration applied");
+      }
+    }
+  }
+  prepare(sql) {
+    return this.database.prepare(sql);
+  }
+  run(sql, ...params) {
+    return this.database.prepare(sql).run(...params);
+  }
+  get(sql, ...params) {
+    return this.database.prepare(sql).get(...params);
+  }
+  all(sql, ...params) {
+    return this.database.prepare(sql).all(...params);
+  }
+  transaction(fn) {
+    return this.database.transaction(fn)();
+  }
+  close() {
+    if (this.closed || !this.db) {
+      return;
+    }
+    logger.info("Closing SQLite database");
+    this.closed = true;
+    try {
+      this.db.pragma("wal_checkpoint(TRUNCATE)");
+      this.db.close();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error({ error: message }, "Error closing database");
+    }
+    this.db = void 0;
+  }
+  registerCleanupHandlers() {
+    const cleanup = () => {
+      this.close();
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => {
+      cleanup();
+      process.exit(130);
+    });
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(143);
+    });
+  }
+};
+var ConversationStore = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  createConversation(projectRoot, defaultModel, metadata) {
+    const id = randomUUID();
+    const metadataJson = JSON.stringify(metadata ?? {});
+    this.store.run(
+      `INSERT INTO conversations (id, project_root, default_model, metadata)
+       VALUES (?, ?, ?, ?)`,
+      id,
+      projectRoot,
+      defaultModel ?? null,
+      metadataJson
+    );
+    logger.info({ conversationId: id, projectRoot }, "Conversation created");
+    const row = this.store.get(
+      "SELECT * FROM conversations WHERE id = ?",
+      id
+    );
+    if (!row) {
+      throw new Error(`Failed to retrieve created conversation: ${id}`);
+    }
+    return this.mapConversationRow(row);
+  }
+  getConversation(id) {
+    const row = this.store.get(
+      "SELECT * FROM conversations WHERE id = ?",
+      id
+    );
+    return row ? this.mapConversationRow(row) : void 0;
+  }
+  listConversations(projectRoot) {
+    const rows = projectRoot ? this.store.all(
+      "SELECT * FROM conversations WHERE project_root = ? ORDER BY updated_at DESC",
+      projectRoot
+    ) : this.store.all(
+      "SELECT * FROM conversations ORDER BY updated_at DESC"
+    );
+    return rows.map((row) => this.mapConversationRow(row));
+  }
+  deleteConversation(id) {
+    this.store.run("DELETE FROM conversations WHERE id = ?", id);
+    logger.info({ conversationId: id }, "Conversation deleted");
+  }
+  addMessage(params) {
+    const toolCallsJson = params.toolCalls ? JSON.stringify(params.toolCalls) : null;
+    const tokenUsageJson = params.tokenUsage ? JSON.stringify(params.tokenUsage) : null;
+    const result = this.store.run(
+      `INSERT INTO messages
+       (conversation_id, role, model, provider, content, tool_calls, token_usage)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      params.conversationId,
+      params.role,
+      params.model ?? null,
+      params.provider ?? null,
+      params.content,
+      toolCallsJson,
+      tokenUsageJson
+    );
+    this.store.run(
+      "UPDATE conversations SET updated_at = datetime('now') WHERE id = ?",
+      params.conversationId
+    );
+    const row = this.store.get(
+      "SELECT * FROM messages WHERE id = ?",
+      result.lastInsertRowid
+    );
+    if (!row) {
+      throw new Error("Failed to retrieve created message");
+    }
+    return this.mapMessageRow(row);
+  }
+  getMessages(conversationId, pagination) {
+    const limit = pagination?.limit ?? 100;
+    const offset = pagination?.offset ?? 0;
+    const rows = this.store.all(
+      `SELECT * FROM messages
+       WHERE conversation_id = ?
+       ORDER BY created_at ASC
+       LIMIT ? OFFSET ?`,
+      conversationId,
+      limit,
+      offset
+    );
+    return rows.map((row) => this.mapMessageRow(row));
+  }
+  getMessageCount(conversationId) {
+    const result = this.store.get(
+      "SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?",
+      conversationId
+    );
+    return result?.count ?? 0;
+  }
+  addFileContext(params) {
+    const result = this.store.run(
+      `INSERT INTO file_context
+       (conversation_id, file_path, content_hash, token_count)
+       VALUES (?, ?, ?, ?)`,
+      params.conversationId,
+      params.filePath,
+      params.contentHash ?? null,
+      params.tokenCount ?? null
+    );
+    const row = this.store.get(
+      "SELECT * FROM file_context WHERE id = ?",
+      result.lastInsertRowid
+    );
+    if (!row) {
+      throw new Error("Failed to retrieve created file context");
+    }
+    return this.mapFileContextRow(row);
+  }
+  getFileContext(conversationId) {
+    const rows = this.store.all(
+      "SELECT * FROM file_context WHERE conversation_id = ? ORDER BY added_at DESC",
+      conversationId
+    );
+    return rows.map((row) => this.mapFileContextRow(row));
+  }
+  removeFileContext(conversationId, filePath) {
+    this.store.run(
+      "DELETE FROM file_context WHERE conversation_id = ? AND file_path = ?",
+      conversationId,
+      filePath
+    );
+  }
+  addCost(params) {
+    const result = this.store.run(
+      `INSERT INTO cost_tracking
+       (conversation_id, provider, model, role, input_tokens, output_tokens, cost_usd)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      params.conversationId,
+      params.provider,
+      params.model,
+      params.role ?? null,
+      params.inputTokens ?? null,
+      params.outputTokens ?? null,
+      params.costUsd ?? null
+    );
+    const row = this.store.get(
+      "SELECT * FROM cost_tracking WHERE id = ?",
+      result.lastInsertRowid
+    );
+    if (!row) {
+      throw new Error("Failed to retrieve created cost entry");
+    }
+    return this.mapCostRow(row);
+  }
+  getConversationCost(conversationId) {
+    const result = this.store.get(
+      "SELECT SUM(cost_usd) as total FROM cost_tracking WHERE conversation_id = ?",
+      conversationId
+    );
+    return result?.total ?? 0;
+  }
+  getCostBreakdown(conversationId) {
+    const rows = this.store.all(
+      "SELECT * FROM cost_tracking WHERE conversation_id = ? ORDER BY created_at ASC",
+      conversationId
+    );
+    return rows.map((row) => this.mapCostRow(row));
+  }
+  // ── Private row mappers ─────────────────────────────────────────────
+  mapConversationRow(row) {
+    let metadata = {};
+    try {
+      metadata = JSON.parse(row.metadata);
+    } catch {
+      metadata = {};
+    }
+    return {
+      id: row.id,
+      projectRoot: row.project_root,
+      defaultModel: row.default_model,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      metadata
+    };
+  }
+  mapMessageRow(row) {
+    let toolCalls = null;
+    if (row.tool_calls) {
+      try {
+        toolCalls = JSON.parse(row.tool_calls);
+      } catch {
+        toolCalls = null;
+      }
+    }
+    let tokenUsage = null;
+    if (row.token_usage) {
+      try {
+        tokenUsage = JSON.parse(row.token_usage);
+      } catch {
+        tokenUsage = null;
+      }
+    }
+    return {
+      id: row.id,
+      conversationId: row.conversation_id,
+      role: row.role,
+      model: row.model,
+      provider: row.provider,
+      content: row.content,
+      toolCalls,
+      tokenUsage,
+      createdAt: row.created_at
+    };
+  }
+  mapFileContextRow(row) {
+    return {
+      id: row.id,
+      conversationId: row.conversation_id,
+      filePath: row.file_path,
+      contentHash: row.content_hash,
+      tokenCount: row.token_count,
+      addedAt: row.added_at
+    };
+  }
+  mapCostRow(row) {
+    return {
+      id: row.id,
+      conversationId: row.conversation_id,
+      provider: row.provider,
+      model: row.model,
+      role: row.role,
+      inputTokens: row.input_tokens,
+      outputTokens: row.output_tokens,
+      costUsd: row.cost_usd,
+      createdAt: row.created_at
+    };
+  }
+};
+var ROLE_PROFILES = {
+  planning: { backgroundColor: "#1a1a2e", badgeText: "Planner" },
+  coding: { backgroundColor: "#162447", badgeText: "Coder" },
+  review: { backgroundColor: "#1b2a1b", badgeText: "Reviewer" },
+  testing: { backgroundColor: "#2a1b1b", badgeText: "Tester" },
+  bugfix: { backgroundColor: "#2a2a1b", badgeText: "Debugger" },
+  documentation: { backgroundColor: "#1b1b2a", badgeText: "Docs" }
+};
+var DEFAULT_PROFILE = {
+  backgroundColor: "#1e1e1e",
+  badgeText: "Agent"
+};
+var ITerm2Manager = class {
+  panes = /* @__PURE__ */ new Map();
+  disposed = false;
+  /**
+   * Check if currently running inside iTerm2 on macOS.
+   */
+  isAvailable() {
+    if (process.platform !== "darwin") {
+      logger.debug("iTerm2 manager is macOS-only");
+      return false;
+    }
+    const termProgram = process.env["TERM_PROGRAM"];
+    if (termProgram !== "iTerm.app") {
+      logger.debug({ termProgram }, "Not running inside iTerm2");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Check if the iTerm2 Python API is accessible.
+   */
+  async isPythonAPIAvailable() {
+    if (!this.isAvailable()) return false;
+    try {
+      const result = await execa("python3", ["-c", "import iterm2"]);
+      return result.exitCode === 0;
+    } catch {
+      logger.warn("iTerm2 Python API module (iterm2) not installed");
+      return false;
+    }
+  }
+  /**
+   * Create panes in the current iTerm2 window based on layout config.
+   */
+  async createPanes(layoutConfig) {
+    this.assertNotDisposed();
+    if (!await this.isPythonAPIAvailable()) {
+      throw new AgentSpawnError(
+        "iterm2",
+        "iTerm2 Python API is not available. Install with: pip3 install iterm2"
+      );
+    }
+    const script = this.buildCreatePanesScript(layoutConfig);
+    try {
+      await this.executePythonScript(script);
+      logger.info(
+        { paneCount: layoutConfig.panes.length },
+        "iTerm2 panes created"
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new AgentSpawnError("iterm2", `Failed to create iTerm2 panes: ${message}`);
+    }
+  }
+  /**
+   * Send a command to a specific pane via iTerm2 Python API.
+   */
+  async sendCommand(paneId, command) {
+    this.assertNotDisposed();
+    const info = this.panes.get(paneId);
+    if (!info) {
+      logger.warn({ paneId }, "iTerm2 pane not found, cannot send command");
+      return;
+    }
+    const escapedCommand = command.replace(/"/g, '\\"').replace(/\\/g, "\\\\");
+    const script = this.buildSendCommandScript(info.sessionId, escapedCommand);
+    try {
+      await this.executePythonScript(script);
+      logger.debug({ paneId, command: command.slice(0, 80) }, "Command sent to iTerm2 pane");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error({ paneId, error: message }, "Failed to send command to iTerm2 pane");
+    }
+  }
+  /**
+   * Set the profile (colors) for a pane based on agent role.
+   */
+  async setProfile(paneId, role) {
+    this.assertNotDisposed();
+    const info = this.panes.get(paneId);
+    if (!info) return;
+    const profile = ROLE_PROFILES[role] ?? DEFAULT_PROFILE;
+    const script = this.buildSetProfileScript(info.sessionId, profile);
+    try {
+      await this.executePythonScript(script);
+      logger.debug({ paneId, role }, "iTerm2 pane profile set");
+    } catch {
+      logger.debug({ paneId, role }, "Failed to set iTerm2 profile (non-fatal)");
+    }
+  }
+  /**
+   * Destroy all managed iTerm2 panes.
+   */
+  async destroy() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const [paneId, info] of this.panes) {
+      try {
+        const script = this.buildCloseSessionScript(info.sessionId);
+        await this.executePythonScript(script);
+      } catch {
+      }
+      getEventBus().emit("pane:closed", { paneId });
+    }
+    this.panes.clear();
+    logger.info("iTerm2 panes destroyed");
+  }
+  /**
+   * Get all tracked pane info.
+   */
+  getPanes() {
+    return this.panes;
+  }
+  /**
+   * Register a pane that was created externally.
+   */
+  registerPane(info) {
+    this.panes.set(info.paneId, info);
+    getEventBus().emit("pane:created", {
+      paneId: info.paneId,
+      agentName: info.agentName
+    });
+  }
+  // ── Python Script Builders ─────────────────────────────────────────
+  buildCreatePanesScript(layoutConfig) {
+    const paneConfigs = layoutConfig.panes;
+    const splitCommands = this.buildSplitCommands(paneConfigs, layoutConfig.layout);
+    return `
+import iterm2
+import asyncio
+
+async def main(connection):
+    app = await iterm2.async_get_app(connection)
+    window = app.current_terminal_window
+    if window is None:
+        return
+
+    tab = window.current_tab
+    root_session = tab.current_session
+    sessions = [root_session]
+
+${splitCommands}
+
+    # Output session IDs for tracking
+    for s in sessions:
+        print(s.session_id)
+
+iterm2.run_until_complete(main)
+`.trim();
+  }
+  buildSplitCommands(panes, layout) {
+    const lines = [];
+    for (let i = 1; i < panes.length; i++) {
+      const vertical = this.shouldSplitVertically(i, panes.length, layout);
+      const direction = vertical ? "True" : "False";
+      lines.push(
+        `    new_session = await sessions[${Math.floor(i / 2)}].async_split_pane(vertical=${direction})`
+      );
+      lines.push(`    sessions.append(new_session)`);
+      const pane = panes[i];
+      if (pane) {
+        const escapedTitle = pane.title.replace(/'/g, "\\'");
+        lines.push(`    await new_session.async_set_name("${escapedTitle}")`);
+      }
+    }
+    return lines.join("\n");
+  }
+  shouldSplitVertically(index, total, layout) {
+    if (layout === "vertical") return true;
+    if (layout === "horizontal") return false;
+    if (total <= 2) return false;
+    return index % 2 === 1;
+  }
+  buildSendCommandScript(sessionId, command) {
+    return `
+import iterm2
+
+async def main(connection):
+    app = await iterm2.async_get_app(connection)
+    session = app.get_session_by_id("${sessionId}")
+    if session:
+        await session.async_send_text("${command}\\n")
+
+iterm2.run_until_complete(main)
+`.trim();
+  }
+  buildSetProfileScript(sessionId, profile) {
+    return `
+import iterm2
+
+async def main(connection):
+    app = await iterm2.async_get_app(connection)
+    session = app.get_session_by_id("${sessionId}")
+    if session:
+        change = iterm2.LocalWriteOnlyProfile()
+        color = iterm2.Color.from_hex("${profile.backgroundColor}")
+        change.set_background_color(color)
+        change.set_badge_text("${profile.badgeText}")
+        await session.async_set_profile_properties(change)
+
+iterm2.run_until_complete(main)
+`.trim();
+  }
+  buildCloseSessionScript(sessionId) {
+    return `
+import iterm2
+
+async def main(connection):
+    app = await iterm2.async_get_app(connection)
+    session = app.get_session_by_id("${sessionId}")
+    if session:
+        await session.async_close()
+
+iterm2.run_until_complete(main)
+`.trim();
+  }
+  // ── Execution ──────────────────────────────────────────────────────
+  async executePythonScript(script) {
+    const result = await execa("python3", ["-c", script], {
+      timeout: 1e4
+    });
+    return result.stdout;
+  }
+  assertNotDisposed() {
+    if (this.disposed) {
+      throw new AgentSpawnError("iterm2", "ITerm2Manager has been disposed");
+    }
+  }
+};
+var NEWLINE = 10;
+var SOCKET_PERMS = 448;
+var MAX_MSG_SIZE = 1048576;
+var RPC_PARSE_ERROR = -32700;
+var RPC_INVALID_REQ = -32600;
+var RPC_METHOD_NOT_FOUND = -32601;
+var RPC_INTERNAL_ERROR = -32603;
+var RPC_AUTH_ERROR = -32e3;
+var IPCHub = class {
+  sessionId;
+  hmacSecret;
+  socketPath;
+  clients = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  server;
+  disposed = false;
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+    this.hmacSecret = randomBytes(32).toString("hex");
+    this.socketPath = getIPCSocketPath(sessionId);
+    this.registerDefaultHandlers();
+  }
+  getHmacSecret() {
+    return this.hmacSecret;
+  }
+  getSocketPath() {
+    return this.socketPath;
+  }
+  getClientCount() {
+    return this.clients.size;
+  }
+  getConnectedAgentIds() {
+    return [...this.clients.keys()];
+  }
+  /** Start the Unix domain socket server. */
+  async start() {
+    this.assertAlive();
+    ensureSecureDirectory(getIPCSocketDir());
+    await this.removeStaleSocket();
+    return new Promise((resolve, reject) => {
+      this.server = createServer((socket) => this.handleConnection(socket));
+      this.server.on("error", (err) => {
+        logger.error({ error: err.message }, "IPC server error");
+        reject(new IPCError(`Server error: ${err.message}`));
+      });
+      this.server.listen(this.socketPath, async () => {
+        try {
+          await chmod(this.socketPath, SOCKET_PERMS);
+        } catch {
+        }
+        logger.info({ socketPath: this.socketPath }, "IPC hub listening");
+        this.setupProcessCleanup();
+        resolve();
+      });
+    });
+  }
+  /** Send a message to a specific registered client. */
+  sendToClient(agentId, message) {
+    this.assertAlive();
+    const client = this.clients.get(agentId);
+    if (client) this.write(client.socket, message);
+  }
+  /** Broadcast a message to all connected clients. */
+  broadcast(message, excludeId) {
+    this.assertAlive();
+    for (const [id, client] of this.clients) {
+      if (id !== excludeId) this.write(client.socket, message);
+    }
+  }
+  /** Register a custom method handler. */
+  onMethod(method, handler) {
+    this.handlers.set(method, handler);
+  }
+  /** Compute HMAC-SHA256 for a message. */
+  computeHmac(message) {
+    return createHmac("sha256", this.hmacSecret).update(JSON.stringify(message)).digest("hex");
+  }
+  /** Register a connected socket as a client (also called by agent.register). */
+  registerClientSocket(agentId, agentName, socket) {
+    this.clients.set(agentId, { agentId, agentName, socket });
+  }
+  /** Gracefully shut down the hub and all connections. */
+  async destroy() {
+    if (this.disposed) return;
+    this.disposed = true;
+    const msg = { jsonrpc: "2.0", method: "hub.shutdown", params: { reason: "Hub shutting down" } };
+    for (const c of this.clients.values()) {
+      try {
+        this.write(c.socket, msg);
+        c.socket.end();
+      } catch {
+      }
+    }
+    this.clients.clear();
+    if (this.server) {
+      await new Promise((r) => {
+        this.server.close(() => r());
+      });
+      this.server = void 0;
+    }
+    await this.removeStaleSocket();
+    logger.info({ sessionId: this.sessionId }, "IPC hub destroyed");
+  }
+  // ── Connection Handling ───────────────────────────────────────────
+  handleConnection(socket) {
+    let buffer = Buffer.alloc(0);
+    let agentId;
+    socket.on("data", (data) => {
+      buffer = Buffer.concat([buffer, data]);
+      if (buffer.length > MAX_MSG_SIZE) {
+        socket.destroy();
+        return;
+      }
+      let idx;
+      while ((idx = buffer.indexOf(NEWLINE)) !== -1) {
+        const raw = buffer.subarray(0, idx).toString("utf-8");
+        buffer = buffer.subarray(idx + 1);
+        if (raw.length === 0) continue;
+        this.processRaw(raw, socket, agentId).then((id) => {
+          if (id) agentId = id;
+        }).catch((e) => {
+          logger.error({ error: e instanceof Error ? e.message : String(e) }, "IPC msg error");
+        });
+      }
+    });
+    socket.on("close", () => {
+      if (agentId) {
+        this.clients.delete(agentId);
+        logger.info({ agentId }, "Client disconnected");
+      }
+    });
+    socket.on("error", (err) => {
+      logger.error({ error: err.message, agentId }, "Socket error");
+    });
+  }
+  async processRaw(raw, socket, currentId) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      this.sendError(socket, void 0, RPC_PARSE_ERROR, "Parse error");
+      return void 0;
+    }
+    if (!this.isAuthEnvelope(parsed)) {
+      this.sendError(socket, void 0, RPC_INVALID_REQ, "Invalid request format");
+      return void 0;
+    }
+    const { message, hmac } = parsed;
+    if (!this.verifyHmac(message, hmac)) {
+      this.sendError(socket, message.id, RPC_AUTH_ERROR, "Authentication failed");
+      return void 0;
+    }
+    if (message.jsonrpc !== "2.0" || !message.method) {
+      this.sendError(socket, message.id, RPC_INVALID_REQ, "Invalid JSON-RPC 2.0");
+      return void 0;
+    }
+    const handler = this.handlers.get(message.method);
+    if (!handler) {
+      this.sendError(socket, message.id, RPC_METHOD_NOT_FOUND, `Unknown: ${message.method}`);
+      return void 0;
+    }
+    try {
+      const aid = currentId ?? message.params["agentId"] ?? "unknown";
+      const result = await handler(aid, message.params, message.id, socket);
+      if (message.id !== void 0) this.sendResult(socket, message.id, result);
+      if (message.method === "agent.register") return message.params["agentId"];
+    } catch (e) {
+      this.sendError(socket, message.id, RPC_INTERNAL_ERROR, e instanceof Error ? e.message : String(e));
+    }
+    return void 0;
+  }
+  // ── Default Handlers ──────────────────────────────────────────────
+  registerDefaultHandlers() {
+    this.handlers.set("agent.register", async (_cid, params, _id, socket) => {
+      const agentId = params["agentId"];
+      const agentName = params["agentName"];
+      if (!agentId || !agentName) throw new IPCError("agent.register requires agentId and agentName");
+      this.registerClientSocket(agentId, agentName, socket);
+      logger.info({ agentId, agentName }, "Agent registered");
+      return { registered: true, agentId };
+    });
+    this.handlers.set("agent.streamChunk", async (_cid, params) => {
+      getEventBus().emit("model:stream:chunk", {
+        model: params["model"] ?? "unknown",
+        content: params["content"] ?? ""
+      });
+      return { received: true };
+    });
+    this.handlers.set("agent.taskUpdate", async (_cid, params) => {
+      const taskId = params["taskId"];
+      const status = params["status"];
+      if (taskId && status) getEventBus().emit("task:updated", { taskId, status });
+      return { received: true };
+    });
+    this.handlers.set("agent.message", async (_cid, params) => {
+      const to = params["to"];
+      const content = params["content"];
+      const from = params["from"];
+      if (from && to && content) {
+        getEventBus().emit("agent:message", { from, to, content });
+        const target = this.clients.get(to);
+        if (target) {
+          this.write(target.socket, { jsonrpc: "2.0", method: "agent.message", params: { from, content } });
+        }
+      }
+      return { delivered: this.clients.has(to ?? "") };
+    });
+    this.handlers.set("hub.taskAssign", async (_cid, params) => {
+      const agentId = params["agentId"];
+      const taskId = params["taskId"];
+      if (agentId && taskId) {
+        const target = this.clients.get(agentId);
+        if (target) this.write(target.socket, { jsonrpc: "2.0", method: "hub.taskAssign", params: { taskId, ...params } });
+      }
+      return { assigned: this.clients.has(agentId ?? "") };
+    });
+    this.handlers.set("hub.shutdown", async (_cid, params) => {
+      const agentId = params["agentId"];
+      if (agentId) {
+        const target = this.clients.get(agentId);
+        if (target) {
+          this.write(target.socket, {
+            jsonrpc: "2.0",
+            method: "hub.shutdown",
+            params: { reason: params["reason"] ?? "Shutdown requested" }
+          });
+        }
+      }
+      return { notified: this.clients.has(agentId ?? "") };
+    });
+  }
+  // ── HMAC ──────────────────────────────────────────────────────────
+  verifyHmac(message, hmac) {
+    const expected = this.computeHmac(message);
+    if (expected.length !== hmac.length) return false;
+    return timingSafeEqual(Buffer.from(expected, "hex"), Buffer.from(hmac, "hex"));
+  }
+  isAuthEnvelope(v) {
+    if (typeof v !== "object" || v === null) return false;
+    const o = v;
+    return typeof o["hmac"] === "string" && typeof o["message"] === "object" && o["message"] !== null;
+  }
+  // ── I/O ───────────────────────────────────────────────────────────
+  write(socket, msg) {
+    if (!socket.destroyed) socket.write(JSON.stringify(msg) + "\n");
+  }
+  sendResult(socket, id, result) {
+    this.write(socket, { jsonrpc: "2.0", result, id });
+  }
+  sendError(socket, id, code, message) {
+    this.write(socket, { jsonrpc: "2.0", error: { code, message }, id: id ?? 0 });
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────
+  async removeStaleSocket() {
+    try {
+      await unlink(this.socketPath);
+    } catch {
+    }
+  }
+  setupProcessCleanup() {
+    const cleanup = () => {
+      this.destroy().catch(() => {
+      });
+    };
+    process.once("exit", cleanup);
+    process.once("SIGINT", cleanup);
+    process.once("SIGTERM", cleanup);
+  }
+  assertAlive() {
+    if (this.disposed) throw new IPCError("IPCHub has been disposed");
+  }
+};
+var DEFAULT_HEARTBEAT_MS = 15e3;
+var DEFAULT_RECONNECT_RETRIES = 5;
+var REQUEST_TIMEOUT_MS = 3e4;
+var NEWLINE2 = 10;
+var PaneProcess = class {
+  agentId;
+  agentName;
+  socketPath;
+  hmacSecret;
+  heartbeatMs;
+  maxRetries;
+  msgHandlers = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  socket;
+  heartbeatTimer;
+  nextId = 1;
+  connected = false;
+  disposed = false;
+  constructor(options) {
+    this.agentId = options.agentId;
+    this.agentName = options.agentName;
+    this.socketPath = options.socketPath;
+    this.hmacSecret = options.hmacSecret;
+    this.heartbeatMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS;
+    this.maxRetries = options.reconnectMaxRetries ?? DEFAULT_RECONNECT_RETRIES;
+  }
+  /** Connect to the IPC hub and register this agent. */
+  async connect() {
+    this.assertAlive();
+    await this.establish();
+    await this.register();
+    this.startHeartbeat();
+    logger.info({ agentId: this.agentId }, "PaneProcess connected");
+  }
+  /** Send a JSON-RPC 2.0 request and wait for response. */
+  async request(method, params) {
+    this.assertAlive();
+    this.assertConnected();
+    const id = this.nextId++;
+    const message = { jsonrpc: "2.0", method, params: { ...params, agentId: this.agentId }, id };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new IPCError(`Request timeout: ${method}`));
+      }, REQUEST_TIMEOUT_MS);
+      this.pending.set(id, { resolve, reject, timer });
+      this.sendAuthenticated(message);
+    });
+  }
+  /** Send a notification (no response expected). */
+  notify(method, params) {
+    this.assertAlive();
+    this.assertConnected();
+    this.sendAuthenticated({ jsonrpc: "2.0", method, params: { ...params, agentId: this.agentId } });
+  }
+  /** Convenience: send a stream chunk. */
+  sendStreamChunk(content, model, taskId) {
+    this.notify("agent.streamChunk", { content, model, taskId });
+  }
+  /** Convenience: send a task status update. */
+  sendTaskUpdate(taskId, status) {
+    this.notify("agent.taskUpdate", { taskId, status });
+  }
+  /** Convenience: send a message to another agent via the hub. */
+  async sendMessage(to, content) {
+    return this.request("agent.message", { from: this.agentId, to, content });
+  }
+  /** Register a handler for incoming messages of a specific method. */
+  onMessage(method, handler) {
+    const set = this.msgHandlers.get(method) ?? /* @__PURE__ */ new Set();
+    set.add(handler);
+    this.msgHandlers.set(method, set);
+    return () => {
+      set.delete(handler);
+      if (set.size === 0) this.msgHandlers.delete(method);
+    };
+  }
+  isConnected() {
+    return this.connected && !this.disposed;
+  }
+  /** Gracefully disconnect from the hub. */
+  async disconnect() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.stopHeartbeat();
+    this.rejectAll();
+    if (this.socket) {
+      this.socket.end();
+      this.socket = void 0;
+    }
+    this.connected = false;
+    logger.info({ agentId: this.agentId }, "PaneProcess disconnected");
+  }
+  // ── Connection ────────────────────────────────────────────────────
+  async establish() {
+    await withRetry(() => this.connectSocket(), {
+      maxRetries: this.maxRetries,
+      baseDelayMs: 500,
+      maxDelayMs: 1e4,
+      shouldRetry: () => !this.disposed
+    });
+  }
+  connectSocket() {
+    return new Promise((resolve, reject) => {
+      const socket = connect(this.socketPath);
+      let buffer = Buffer.alloc(0);
+      socket.on("connect", () => {
+        this.socket = socket;
+        this.connected = true;
+        resolve();
+      });
+      socket.on("data", (data) => {
+        buffer = Buffer.concat([buffer, data]);
+        let idx;
+        while ((idx = buffer.indexOf(NEWLINE2)) !== -1) {
+          const raw = buffer.subarray(0, idx).toString("utf-8");
+          buffer = buffer.subarray(idx + 1);
+          if (raw.length > 0) this.handleIncoming(raw);
+        }
+      });
+      socket.on("close", () => {
+        this.connected = false;
+        if (!this.disposed) {
+          logger.warn({ agentId: this.agentId }, "Connection lost, reconnecting");
+          this.attemptReconnect();
+        }
+      });
+      socket.on("error", (err) => {
+        if (!this.connected) reject(new IPCError(`Connection failed: ${err.message}`));
+        else logger.error({ agentId: this.agentId, error: err.message }, "Socket error");
+      });
+    });
+  }
+  async attemptReconnect() {
+    if (this.disposed) return;
+    this.stopHeartbeat();
+    try {
+      await sleep(1e3);
+      await this.establish();
+      await this.register();
+      this.startHeartbeat();
+      logger.info({ agentId: this.agentId }, "Reconnected");
+    } catch (e) {
+      logger.error({ agentId: this.agentId, error: e instanceof Error ? e.message : String(e) }, "Reconnect failed");
+    }
+  }
+  async register() {
+    await this.request("agent.register", { agentId: this.agentId, agentName: this.agentName });
+  }
+  // ── Message Processing ────────────────────────────────────────────
+  handleIncoming(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (this.isResponse(parsed)) {
+      this.resolveResponse(parsed);
+      return;
+    }
+    if (this.isMessage(parsed)) {
+      this.dispatch(parsed);
+      return;
+    }
+  }
+  resolveResponse(response) {
+    const p = this.pending.get(response.id);
+    if (!p) return;
+    this.pending.delete(response.id);
+    clearTimeout(p.timer);
+    if (response.error) p.reject(new IPCError(`RPC ${response.error.code}: ${response.error.message}`));
+    else p.resolve(response.result);
+  }
+  dispatch(message) {
+    const handlers = this.msgHandlers.get(message.method);
+    if (!handlers) return;
+    for (const h of handlers) {
+      try {
+        h(message);
+      } catch (e) {
+        logger.error({ method: message.method, error: e instanceof Error ? e.message : String(e) }, "Handler error");
+      }
+    }
+  }
+  // ── Heartbeat ─────────────────────────────────────────────────────
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.connected && this.socket && !this.socket.destroyed) {
+        this.notify("agent.streamChunk", { content: "", model: "heartbeat", heartbeat: true });
+      }
+    }, this.heartbeatMs);
+    if (this.heartbeatTimer.unref) this.heartbeatTimer.unref();
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = void 0;
+    }
+  }
+  // ── HMAC ──────────────────────────────────────────────────────────
+  sendAuthenticated(message) {
+    if (!this.socket || this.socket.destroyed) return;
+    const hmac = createHmac("sha256", this.hmacSecret).update(JSON.stringify(message)).digest("hex");
+    this.socket.write(JSON.stringify({ message, hmac }) + "\n");
+  }
+  // ── Type Guards ───────────────────────────────────────────────────
+  isResponse(v) {
+    if (typeof v !== "object" || v === null) return false;
+    const o = v;
+    return o["jsonrpc"] === "2.0" && typeof o["id"] === "number" && !("method" in o);
+  }
+  isMessage(v) {
+    if (typeof v !== "object" || v === null) return false;
+    const o = v;
+    return o["jsonrpc"] === "2.0" && typeof o["method"] === "string";
+  }
+  // ── Helpers ───────────────────────────────────────────────────────
+  rejectAll() {
+    const err = new IPCError("PaneProcess disconnected");
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+  assertAlive() {
+    if (this.disposed) throw new IPCError("PaneProcess disposed");
+  }
+  assertConnected() {
+    if (!this.connected || !this.socket) throw new IPCError("Not connected");
+  }
+};
+
+// src/mcp/tool-bridge.ts
+var NAMESPACE_SEPARATOR = "__";
+var MCP_PREFIX = "mcp";
+var MCP_CATEGORY = "mcp";
+function buildToolName(serverName, toolName) {
+  return `${MCP_PREFIX}${NAMESPACE_SEPARATOR}${serverName}${NAMESPACE_SEPARATOR}${toolName}`;
+}
+function parseToolName(namespacedName) {
+  const parts = namespacedName.split(NAMESPACE_SEPARATOR);
+  if (parts.length < 3 || parts[0] !== MCP_PREFIX) {
+    return void 0;
+  }
+  const serverName = parts[1];
+  const toolName = parts.slice(2).join(NAMESPACE_SEPARATOR);
+  if (!serverName || !toolName) {
+    return void 0;
+  }
+  return { serverName, toolName };
+}
+function convertInputSchema(inputSchema) {
+  const properties = inputSchema["properties"];
+  if (!properties || typeof properties !== "object") {
+    return [];
+  }
+  const requiredList = inputSchema["required"];
+  const requiredSet = new Set(
+    Array.isArray(requiredList) ? requiredList : []
+  );
+  const params = [];
+  for (const [name, rawSchema] of Object.entries(
+    properties
+  )) {
+    const schema = rawSchema;
+    if (!schema || typeof schema !== "object") {
+      continue;
+    }
+    const param = {
+      name,
+      type: schema.type ?? "string",
+      description: schema.description ?? "",
+      required: requiredSet.has(name),
+      ...schema.default !== void 0 ? { default: schema.default } : {},
+      ...schema.enum !== void 0 ? { enum: schema.enum } : {}
+    };
+    params.push(param);
+  }
+  return params;
+}
+function mcpToolToDefinition(serverName, mcpTool) {
+  return {
+    name: buildToolName(serverName, mcpTool.name),
+    description: `[MCP:${serverName}] ${mcpTool.description}`,
+    parameters: convertInputSchema(mcpTool.inputSchema)
+  };
+}
+function toolCallToMCPRequest(call) {
+  const parsed = parseToolName(call.name);
+  if (!parsed) {
+    throw new ToolCallError(
+      call.name,
+      "Invalid MCP tool name format \u2014 expected mcp__{server}__{tool}"
+    );
+  }
+  return {
+    serverName: parsed.serverName,
+    toolName: parsed.toolName,
+    arguments: call.arguments
+  };
+}
+function mcpResultToToolResult(toolCallId, toolName, content, isError) {
+  return { toolCallId, name: toolName, content, isError };
+}
+function validateArguments(args, parameters) {
+  for (const param of parameters) {
+    if (param.required && !(param.name in args)) {
+      return `Missing required argument: ${param.name}`;
+    }
+  }
+  return void 0;
+}
+var MCPToolBridge = class {
+  serverManager;
+  toolCache = /* @__PURE__ */ new Map();
+  constructor(serverManager) {
+    this.serverManager = serverManager;
+  }
+  /**
+   * Discover tools from all connected MCP servers and register them.
+   * Uses lazy loading: definitions are fetched and cached on first request.
+   */
+  async registerAll(registry) {
+    const servers = this.serverManager.getConnectedServers();
+    let totalRegistered = 0;
+    for (const serverName of servers) {
+      try {
+        const count = await this.registerServerTools(serverName, registry);
+        totalRegistered += count;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.error(
+          { server: serverName, error: msg },
+          "Failed to register MCP tools"
+        );
+      }
+    }
+    logger.info(
+      { totalRegistered, servers: servers.length },
+      "MCP tool registration complete"
+    );
+    return totalRegistered;
+  }
+  /**
+   * Register tools from a single MCP server.
+   * Fetches tool schemas and caches definitions.
+   */
+  async registerServerTools(serverName, registry) {
+    const definitions = await this.loadToolDefinitions(serverName);
+    for (const definition of definitions) {
+      const registration = this.createRegistration(serverName, definition);
+      registry.register(registration);
+    }
+    logger.info(
+      { server: serverName, tools: definitions.length },
+      "Registered MCP server tools"
+    );
+    return definitions.length;
+  }
+  /**
+   * Lazy-load tool definitions for a server.
+   * Returns cached definitions if already loaded.
+   */
+  async loadToolDefinitions(serverName) {
+    const cached = this.toolCache.get(serverName);
+    if (cached) {
+      return cached;
+    }
+    const mcpTools = await this.serverManager.listServerTools(serverName);
+    const definitions = mcpTools.map(
+      (tool) => mcpToolToDefinition(serverName, tool)
+    );
+    this.toolCache.set(serverName, definitions);
+    return definitions;
+  }
+  /**
+   * Execute an MCP tool call: validate, convert, call, return result.
+   */
+  async executeTool(call) {
+    const request = toolCallToMCPRequest(call);
+    const definitions = this.toolCache.get(request.serverName);
+    if (definitions) {
+      const def = definitions.find((d) => d.name === call.name);
+      if (def) {
+        const validationError = validateArguments(call.arguments, def.parameters);
+        if (validationError) {
+          return mcpResultToToolResult(call.id, call.name, validationError, true);
+        }
+      }
+    }
+    this.serverManager.checkRateLimitFor(request.serverName);
+    this.serverManager.recordCall(request.serverName);
+    const client = this.serverManager.getClient(request.serverName);
+    if (!client) {
+      return mcpResultToToolResult(
+        call.id,
+        call.name,
+        `MCP server "${request.serverName}" is not connected`,
+        true
+      );
+    }
+    try {
+      const result = await client.callTool(request.toolName, request.arguments);
+      return mcpResultToToolResult(
+        call.id,
+        call.name,
+        result.content,
+        result.isError
+      );
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return mcpResultToToolResult(call.id, call.name, msg, true);
+    }
+  }
+  /** Invalidate cached tool definitions for a server (e.g. after config reload). */
+  invalidateCache(serverName) {
+    if (serverName) {
+      this.toolCache.delete(serverName);
+    } else {
+      this.toolCache.clear();
+    }
+  }
+  /** Check whether a tool name is an MCP-namespaced tool. */
+  isMCPTool(toolName) {
+    return parseToolName(toolName) !== void 0;
+  }
+  /** Get all cached tool definitions across all servers. */
+  getAllDefinitions() {
+    const all = [];
+    for (const defs of this.toolCache.values()) {
+      all.push(...defs);
+    }
+    return all;
+  }
+  // ── Private ─────────────────────────────────────────────────────────
+  createRegistration(_serverName, definition) {
+    return {
+      definition,
+      category: MCP_CATEGORY,
+      requiresApproval: (mode, _args) => {
+        return mode === "strict";
+      },
+      execute: async (args) => {
+        const call = {
+          id: `mcp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+          name: definition.name,
+          arguments: args
+        };
+        return this.executeTool(call);
+      }
+    };
+  }
+};
+
+export { ConversationStore, IPCHub, ITerm2Manager, MCPToolBridge, PaneProcess, SqliteStore };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map