@openacp/cli 2026.331.1 → 2026.331.2

package/dist/chunk-LRV56K2M.js

@@ -1,4106 +0,0 @@
-import {
-  AgentCatalog
-} from "./chunk-MDJHCCFS.js";
-import {
-  readTextFileWithRange
-} from "./chunk-OYSAN7UX.js";
-import {
-  closeSessionLogger,
-  createChildLogger,
-  createSessionLogger
-} from "./chunk-R6KZYF7D.js";
-import {
-  getAgentCapabilities
-} from "./chunk-ZSLHHQPQ.js";
-
-// src/core/utils/streams.ts
-function nodeToWebWritable(nodeStream) {
-  return new WritableStream({
-    write(chunk) {
-      return new Promise((resolve, reject) => {
-        const ok = nodeStream.write(chunk);
-        if (ok) {
-          resolve();
-          return;
-        }
-        nodeStream.once("drain", resolve);
-        nodeStream.once("error", reject);
-      });
-    },
-    close() {
-      nodeStream.end();
-    },
-    abort(reason) {
-      nodeStream.destroy(reason instanceof Error ? reason : new Error(String(reason)));
-    }
-  });
-}
-function nodeToWebReadable(nodeStream) {
-  return new ReadableStream({
-    start(controller) {
-      nodeStream.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
-      nodeStream.on("end", () => controller.close());
-      nodeStream.on("error", (err) => controller.error(err));
-    },
-    cancel() {
-      nodeStream.destroy();
-    }
-  });
-}
-
-// src/core/utils/stderr-capture.ts
-var StderrCapture = class {
-  constructor(maxLines = 50) {
-    this.maxLines = maxLines;
-  }
-  lines = [];
-  append(chunk) {
-    this.lines.push(...chunk.split("\n").filter(Boolean));
-    if (this.lines.length > this.maxLines) {
-      this.lines = this.lines.slice(-this.maxLines);
-    }
-  }
-  getLastLines() {
-    return this.lines.join("\n");
-  }
-};
-
-// src/core/utils/typed-emitter.ts
-var TypedEmitter = class {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  listeners = /* @__PURE__ */ new Map();
-  paused = false;
-  buffer = [];
-  on(event, listener) {
-    let set = this.listeners.get(event);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.listeners.set(event, set);
-    }
-    set.add(listener);
-    return this;
-  }
-  off(event, listener) {
-    this.listeners.get(event)?.delete(listener);
-    return this;
-  }
-  emit(event, ...args) {
-    if (this.paused) {
-      if (this.passthroughFn?.(event, args)) {
-        this.deliver(event, args);
-      } else {
-        this.buffer.push({ event, args });
-      }
-      return;
-    }
-    this.deliver(event, args);
-  }
-  /**
-   * Pause event delivery. Events emitted while paused are buffered.
-   * Optionally pass a filter to allow specific events through even while paused.
-   */
-  pause(passthrough) {
-    this.paused = true;
-    this.passthroughFn = passthrough;
-  }
-  passthroughFn;
-  /** Resume event delivery and replay buffered events in order. */
-  resume() {
-    this.paused = false;
-    this.passthroughFn = void 0;
-    const buffered = this.buffer.splice(0);
-    for (const { event, args } of buffered) {
-      this.deliver(event, args);
-    }
-  }
-  /** Discard all buffered events without delivering them. */
-  clearBuffer() {
-    this.buffer.length = 0;
-  }
-  get isPaused() {
-    return this.paused;
-  }
-  get bufferSize() {
-    return this.buffer.length;
-  }
-  removeAllListeners(event) {
-    if (event) {
-      this.listeners.delete(event);
-    } else {
-      this.listeners.clear();
-    }
-  }
-  deliver(event, args) {
-    const set = this.listeners.get(event);
-    if (!set) return;
-    for (const listener of set) {
-      listener(...args);
-    }
-  }
-};
-
-// src/core/agents/agent-instance.ts
-import { spawn as spawn2, execFileSync } from "child_process";
-import { Transform } from "stream";
-import fs2 from "fs";
-import path2 from "path";
-import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
-import { PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
-
-// src/core/sessions/terminal-manager.ts
-import { spawn } from "child_process";
-import { randomUUID } from "crypto";
-var TerminalManager = class {
-  terminals = /* @__PURE__ */ new Map();
-  maxOutputBytes;
-  constructor(maxOutputBytes = 1024 * 1024) {
-    this.maxOutputBytes = maxOutputBytes;
-  }
-  async createTerminal(sessionId, params, middlewareChain) {
-    let termCommand = params.command;
-    let termArgs = params.args ?? [];
-    let termEnvArr = params.env ?? [];
-    let termCwd = params.cwd ?? void 0;
-    if (middlewareChain) {
-      const envRecord = {};
-      for (const ev of termEnvArr) {
-        envRecord[ev.name] = ev.value;
-      }
-      const result = await middlewareChain.execute("terminal:beforeCreate", {
-        sessionId,
-        command: termCommand,
-        args: termArgs,
-        env: envRecord,
-        cwd: termCwd
-      }, async (p) => p);
-      if (!result) return { terminalId: "" };
-      termCommand = result.command;
-      termArgs = result.args ?? termArgs;
-      termCwd = result.cwd ?? termCwd;
-      if (result.env) {
-        termEnvArr = Object.entries(result.env).map(([name, value]) => ({ name, value }));
-      }
-    }
-    const terminalId = randomUUID();
-    const args = termArgs;
-    const env = {};
-    for (const ev of termEnvArr) {
-      env[ev.name] = ev.value;
-    }
-    const childProcess = spawn(termCommand, args, {
-      cwd: termCwd,
-      env: { ...process.env, ...env },
-      shell: false
-    });
-    const state = {
-      process: childProcess,
-      output: "",
-      exitStatus: null,
-      command: termCommand,
-      startTime: Date.now()
-    };
-    this.terminals.set(terminalId, state);
-    const outputByteLimit = params.outputByteLimit ?? this.maxOutputBytes;
-    const appendOutput = (chunk) => {
-      state.output += chunk;
-      const bytes = Buffer.byteLength(state.output, "utf-8");
-      if (bytes > outputByteLimit) {
-        const excess = bytes - outputByteLimit;
-        state.output = state.output.slice(excess);
-      }
-    };
-    childProcess.stdout?.on(
-      "data",
-      (chunk) => appendOutput(chunk.toString())
-    );
-    childProcess.stderr?.on(
-      "data",
-      (chunk) => appendOutput(chunk.toString())
-    );
-    childProcess.on("exit", (code, signal) => {
-      state.exitStatus = { exitCode: code, signal };
-      if (middlewareChain) {
-        middlewareChain.execute("terminal:afterExit", {
-          sessionId,
-          terminalId,
-          command: state.command,
-          exitCode: code ?? -1,
-          durationMs: Date.now() - state.startTime
-        }, async (p) => p).catch(() => {
-        });
-      }
-    });
-    return { terminalId };
-  }
-  getOutput(terminalId) {
-    const state = this.terminals.get(terminalId);
-    if (!state) {
-      throw new Error(`Terminal not found: ${terminalId}`);
-    }
-    return {
-      output: state.output,
-      truncated: false,
-      exitStatus: state.exitStatus ? {
-        exitCode: state.exitStatus.exitCode,
-        signal: state.exitStatus.signal
-      } : void 0
-    };
-  }
-  async waitForExit(terminalId) {
-    const state = this.terminals.get(terminalId);
-    if (!state) {
-      throw new Error(`Terminal not found: ${terminalId}`);
-    }
-    if (state.exitStatus !== null) {
-      return {
-        exitCode: state.exitStatus.exitCode,
-        signal: state.exitStatus.signal
-      };
-    }
-    return new Promise((resolve) => {
-      state.process.on("exit", (code, signal) => {
-        resolve({ exitCode: code, signal });
-      });
-    });
-  }
-  kill(terminalId) {
-    const state = this.terminals.get(terminalId);
-    if (!state) {
-      throw new Error(`Terminal not found: ${terminalId}`);
-    }
-    state.process.kill("SIGTERM");
-  }
-  release(terminalId) {
-    const state = this.terminals.get(terminalId);
-    if (!state) {
-      return;
-    }
-    state.process.kill("SIGKILL");
-    this.terminals.delete(terminalId);
-  }
-  destroyAll() {
-    for (const [, t] of this.terminals) {
-      t.process.kill("SIGKILL");
-    }
-    this.terminals.clear();
-  }
-};
-
-// src/core/agents/mcp-manager.ts
-var McpManager = class {
-  /**
-   * Resolve the MCP server config to pass to ACP session methods.
-   * Returns the provided config array or an empty array if none given.
-   */
-  resolve(sessionConfig) {
-    return sessionConfig ?? [];
-  }
-};
-
-// src/core/utils/debug-tracer.ts
-import fs from "fs";
-import path from "path";
-var DEBUG_ENABLED = process.env.OPENACP_DEBUG === "true" || process.env.OPENACP_DEBUG === "1";
-var DebugTracer = class {
-  constructor(sessionId, workingDirectory) {
-    this.sessionId = sessionId;
-    this.workingDirectory = workingDirectory;
-    this.logDir = path.join(workingDirectory, ".log");
-  }
-  dirCreated = false;
-  logDir;
-  log(layer, data) {
-    try {
-      if (!this.dirCreated) {
-        fs.mkdirSync(this.logDir, { recursive: true });
-        this.dirCreated = true;
-      }
-      const filePath = path.join(this.logDir, `${this.sessionId}_${layer}.jsonl`);
-      const line = JSON.stringify({ ts: Date.now(), ...data }) + "\n";
-      fs.appendFileSync(filePath, line);
-    } catch {
-    }
-  }
-  /** No-op cleanup — establishes the pattern for future async implementations */
-  destroy() {
-  }
-};
-function createDebugTracer(sessionId, workingDirectory) {
-  if (!DEBUG_ENABLED) return null;
-  return new DebugTracer(sessionId, workingDirectory);
-}
-
-// src/core/agents/agent-instance.ts
-var log = createChildLogger({ module: "agent-instance" });
-function findPackageRoot(startDir) {
-  let dir = startDir;
-  while (dir !== path2.dirname(dir)) {
-    if (fs2.existsSync(path2.join(dir, "package.json"))) {
-      return dir;
-    }
-    dir = path2.dirname(dir);
-  }
-  return startDir;
-}
-function resolveAgentCommand(cmd) {
-  const searchRoots = [process.cwd()];
-  const ownDir = findPackageRoot(import.meta.dirname);
-  if (ownDir !== process.cwd()) {
-    searchRoots.push(ownDir);
-  }
-  for (const root of searchRoots) {
-    const packageDirs = [
-      path2.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
-      path2.resolve(root, "node_modules", cmd, "dist", "index.js")
-    ];
-    for (const jsPath of packageDirs) {
-      if (fs2.existsSync(jsPath)) {
-        return { command: process.execPath, args: [jsPath] };
-      }
-    }
-  }
-  for (const root of searchRoots) {
-    const localBin = path2.resolve(root, "node_modules", ".bin", cmd);
-    if (fs2.existsSync(localBin)) {
-      const content = fs2.readFileSync(localBin, "utf-8");
-      if (content.startsWith("#!/usr/bin/env node")) {
-        return { command: process.execPath, args: [localBin] };
-      }
-      const match = content.match(/"([^"]+\.js)"/);
-      if (match) {
-        const target = path2.resolve(path2.dirname(localBin), match[1]);
-        if (fs2.existsSync(target)) {
-          return { command: process.execPath, args: [target] };
-        }
-      }
-    }
-  }
-  try {
-    const fullPath = execFileSync("which", [cmd], { encoding: "utf-8" }).trim();
-    if (fullPath) {
-      const content = fs2.readFileSync(fullPath, "utf-8");
-      if (content.startsWith("#!/usr/bin/env node")) {
-        return { command: process.execPath, args: [fullPath] };
-      }
-    }
-  } catch {
-  }
-  return { command: cmd, args: [] };
-}
-var AgentInstance = class _AgentInstance extends TypedEmitter {
-  connection;
-  child;
-  stderrCapture;
-  terminalManager = new TerminalManager();
-  static mcpManager = new McpManager();
-  _destroying = false;
-  sessionId;
-  agentName;
-  promptCapabilities;
-  middlewareChain;
-  debugTracer = null;
-  // Callback — set by core when wiring events
-  onPermissionRequest = async () => "";
-  constructor(agentName) {
-    super();
-    this.agentName = agentName;
-  }
-  static async spawnSubprocess(agentDef, workingDirectory) {
-    const instance = new _AgentInstance(agentDef.name);
-    const resolved = resolveAgentCommand(agentDef.command);
-    log.debug(
-      {
-        agentName: agentDef.name,
-        command: resolved.command,
-        args: resolved.args
-      },
-      "Resolved agent command"
-    );
-    instance.child = spawn2(
-      resolved.command,
-      [...resolved.args, ...agentDef.args],
-      {
-        stdio: ["pipe", "pipe", "pipe"],
-        cwd: workingDirectory,
-        env: { ...process.env, ...agentDef.env }
-      }
-    );
-    await new Promise((resolve, reject) => {
-      instance.child.on("error", (err) => {
-        reject(
-          new Error(
-            `Failed to spawn agent "${agentDef.name}": ${err.message}. Is "${agentDef.command}" installed?`
-          )
-        );
-      });
-      instance.child.on("spawn", () => resolve());
-    });
-    instance.stderrCapture = new StderrCapture(50);
-    instance.child.stderr.on("data", (chunk) => {
-      instance.stderrCapture.append(chunk.toString());
-    });
-    const stdinLogger = new Transform({
-      transform(chunk, _enc, cb) {
-        if (instance.debugTracer) {
-          const raw = chunk.toString().trimEnd();
-          try {
-            instance.debugTracer.log("acp", { dir: "send", data: JSON.parse(raw) });
-          } catch {
-            instance.debugTracer.log("acp", { dir: "send", data: raw });
-          }
-        }
-        cb(null, chunk);
-      }
-    });
-    stdinLogger.pipe(instance.child.stdin);
-    const stdoutLogger = new Transform({
-      transform(chunk, _enc, cb) {
-        if (instance.debugTracer) {
-          const raw = chunk.toString().trimEnd();
-          try {
-            instance.debugTracer.log("acp", { dir: "recv", data: JSON.parse(raw) });
-          } catch {
-            instance.debugTracer.log("acp", { dir: "recv", data: raw });
-          }
-        }
-        cb(null, chunk);
-      }
-    });
-    instance.child.stdout.pipe(stdoutLogger);
-    const toAgent = nodeToWebWritable(stdinLogger);
-    const fromAgent = nodeToWebReadable(stdoutLogger);
-    const stream = ndJsonStream(toAgent, fromAgent);
-    instance.connection = new ClientSideConnection(
-      (_agent) => instance.createClient(_agent),
-      stream
-    );
-    const initResponse = await instance.connection.initialize({
-      protocolVersion: PROTOCOL_VERSION,
-      clientCapabilities: {
-        fs: { readTextFile: true, writeTextFile: true },
-        terminal: true
-      }
-    });
-    if (initResponse.protocolVersion !== PROTOCOL_VERSION) {
-      log.warn(
-        { expected: PROTOCOL_VERSION, got: initResponse.protocolVersion },
-        "ACP protocol version mismatch \u2014 some features may not work correctly"
-      );
-    }
-    instance.promptCapabilities = initResponse.agentCapabilities?.promptCapabilities;
-    log.info(
-      { promptCapabilities: instance.promptCapabilities ?? {} },
-      "Agent prompt capabilities"
-    );
-    return instance;
-  }
-  setupCrashDetection() {
-    this.child.on("exit", (code, signal) => {
-      if (this._destroying) return;
-      log.info(
-        { sessionId: this.sessionId, exitCode: code, signal },
-        "Agent process exited"
-      );
-      if (code !== 0 && code !== null || signal) {
-        const stderr = this.stderrCapture.getLastLines();
-        this.emit("agent_event", {
-          type: "error",
-          message: signal ? `Agent killed by signal ${signal}
-${stderr}` : `Agent crashed (exit code ${code})
-${stderr}`
-        });
-      }
-    });
-    this.connection.closed.then(() => {
-      log.debug({ sessionId: this.sessionId }, "ACP connection closed");
-    });
-  }
-  static async spawn(agentDef, workingDirectory, mcpServers) {
-    log.debug(
-      { agentName: agentDef.name, command: agentDef.command },
-      "Spawning agent"
-    );
-    const spawnStart = Date.now();
-    const instance = await _AgentInstance.spawnSubprocess(
-      agentDef,
-      workingDirectory
-    );
-    const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
-    const response = await instance.connection.newSession({
-      cwd: workingDirectory,
-      mcpServers: resolvedMcp
-    });
-    instance.sessionId = response.sessionId;
-    instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
-    instance.setupCrashDetection();
-    log.info(
-      { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
-      "Agent spawn complete"
-    );
-    return instance;
-  }
-  static async resume(agentDef, workingDirectory, agentSessionId, mcpServers) {
-    log.debug({ agentName: agentDef.name, agentSessionId }, "Resuming agent");
-    const spawnStart = Date.now();
-    const instance = await _AgentInstance.spawnSubprocess(
-      agentDef,
-      workingDirectory
-    );
-    try {
-      const response = await instance.connection.unstable_resumeSession({
-        sessionId: agentSessionId,
-        cwd: workingDirectory
-      });
-      instance.sessionId = response.sessionId;
-      instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
-      log.info(
-        { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
-        "Agent resume complete"
-      );
-    } catch (err) {
-      log.warn(
-        { err, agentSessionId },
-        "Resume failed, falling back to new session"
-      );
-      const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
-      const response = await instance.connection.newSession({
-        cwd: workingDirectory,
-        mcpServers: resolvedMcp
-      });
-      instance.sessionId = response.sessionId;
-      instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
-      log.info(
-        { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
-        "Agent fallback spawn complete"
-      );
-    }
-    instance.setupCrashDetection();
-    return instance;
-  }
-  // createClient — implemented in Task 6b
-  createClient(_agent) {
-    const self = this;
-    const MAX_OUTPUT_BYTES = 1024 * 1024;
-    return {
-      // ── Session updates ──────────────────────────────────────────────────
-      async sessionUpdate(params) {
-        const update = params.update;
-        let event = null;
-        switch (update.sessionUpdate) {
-          case "agent_message_chunk":
-            if (update.content.type === "text") {
-              event = { type: "text", content: update.content.text };
-            } else if (update.content.type === "image") {
-              const c = update.content;
-              event = { type: "image_content", data: c.data, mimeType: c.mimeType };
-            } else if (update.content.type === "audio") {
-              const c = update.content;
-              event = { type: "audio_content", data: c.data, mimeType: c.mimeType };
-            } else if (update.content.type === "resource") {
-              const c = update.content;
-              event = {
-                type: "resource_content",
-                uri: c.resource.uri,
-                name: c.resource.uri,
-                text: c.resource.text ?? void 0,
-                blob: c.resource.blob ?? void 0,
-                mimeType: c.resource.mimeType ?? void 0
-              };
-            } else if (update.content.type === "resource_link") {
-              const c = update.content;
-              event = {
-                type: "resource_link",
-                uri: c.uri,
-                name: c.name,
-                mimeType: c.mimeType ?? void 0,
-                title: c.title ?? void 0,
-                description: c.description ?? void 0,
-                size: c.size ?? void 0
-              };
-            }
-            break;
-          case "agent_thought_chunk":
-            if (update.content.type === "text") {
-              event = { type: "thought", content: update.content.text };
-            }
-            break;
-          case "tool_call": {
-            const tc = update;
-            event = {
-              type: "tool_call",
-              id: update.toolCallId,
-              name: update.title,
-              kind: update.kind ?? void 0,
-              status: update.status ?? "pending",
-              content: update.content ?? void 0,
-              rawInput: tc.rawInput ?? void 0,
-              rawOutput: tc.rawOutput ?? void 0,
-              meta: tc._meta ?? void 0
-            };
-            break;
-          }
-          case "tool_call_update": {
-            const tcu = update;
-            event = {
-              type: "tool_update",
-              id: update.toolCallId,
-              name: update.title ?? void 0,
-              kind: update.kind ?? void 0,
-              status: update.status ?? "pending",
-              content: update.content ?? void 0,
-              rawInput: tcu.rawInput ?? void 0,
-              rawOutput: tcu.rawOutput ?? void 0,
-              meta: tcu._meta ?? void 0
-            };
-            break;
-          }
-          case "plan":
-            event = { type: "plan", entries: update.entries };
-            break;
-          case "usage_update":
-            event = {
-              type: "usage",
-              tokensUsed: update.used,
-              contextSize: update.size,
-              cost: update.cost ?? void 0
-            };
-            break;
-          case "available_commands_update":
-            event = {
-              type: "commands_update",
-              commands: update.availableCommands
-            };
-            break;
-          case "session_info_update": {
-            const si = update;
-            event = {
-              type: "session_info_update",
-              title: si.title ?? void 0,
-              updatedAt: si.updatedAt ?? void 0,
-              _meta: si._meta ?? void 0
-            };
-            break;
-          }
-          case "current_mode_update": {
-            const cm = update;
-            event = {
-              type: "current_mode_update",
-              modeId: cm.currentModeId
-            };
-            break;
-          }
-          case "config_option_update": {
-            const co = update;
-            event = {
-              type: "config_option_update",
-              options: co.configOptions ?? []
-            };
-            break;
-          }
-          case "user_message_chunk": {
-            const um = update;
-            event = {
-              type: "user_message_chunk",
-              content: um.content?.text ?? ""
-            };
-            break;
-          }
-          // NOTE: model_update is NOT a session update type in the ACP SDK schema.
-          // Model changes are applied via the unstable_setSessionModel() method and
-          // the response is synchronous — the SDK does not push a model_update
-          // notification to the client. Therefore AgentEvent "model_update" cannot
-          // originate from sessionUpdate and must be emitted by callers of setModel()
-          // if they need to propagate the change downstream.
-          default:
-            return;
-        }
-        if (event !== null) {
-          self.emit("agent_event", event);
-        }
-      },
-      // ── Permission requests ──────────────────────────────────────────────
-      async requestPermission(params) {
-        const permissionRequest = {
-          id: params.toolCall.toolCallId,
-          description: params.toolCall.title ?? params.toolCall.toolCallId,
-          options: params.options.map((opt) => ({
-            id: opt.optionId,
-            label: opt.name,
-            isAllow: opt.kind === "allow_once" || opt.kind === "allow_always"
-          }))
-        };
-        const selectedOptionId = await self.onPermissionRequest(permissionRequest);
-        return {
-          outcome: { outcome: "selected", optionId: selectedOptionId }
-        };
-      },
-      // ── File operations ──────────────────────────────────────────────────
-      async readTextFile(params) {
-        const p = params;
-        if (self.middlewareChain) {
-          const result = await self.middlewareChain.execute("fs:beforeRead", { sessionId: self.sessionId, path: p.path, line: p.line, limit: p.limit }, async (r) => r);
-          if (!result) return { content: "" };
-          p.path = result.path;
-        }
-        const content = await readTextFileWithRange(p.path, {
-          line: p.line ?? void 0,
-          limit: p.limit ?? void 0
-        });
-        return { content };
-      },
-      async writeTextFile(params) {
-        let writePath = params.path;
-        let writeContent = params.content;
-        if (self.middlewareChain) {
-          const result = await self.middlewareChain.execute("fs:beforeWrite", { sessionId: self.sessionId, path: writePath, content: writeContent }, async (r) => r);
-          if (!result) return {};
-          writePath = result.path;
-          writeContent = result.content;
-        }
-        await fs2.promises.mkdir(path2.dirname(writePath), { recursive: true });
-        await fs2.promises.writeFile(writePath, writeContent, "utf-8");
-        return {};
-      },
-      // ── Terminal operations (delegated to TerminalManager) ─────────────
-      async createTerminal(params) {
-        return self.terminalManager.createTerminal(
-          self.sessionId,
-          {
-            command: params.command,
-            args: params.args,
-            env: params.env,
-            cwd: params.cwd,
-            outputByteLimit: params.outputByteLimit ?? MAX_OUTPUT_BYTES
-          },
-          self.middlewareChain
-        );
-      },
-      async terminalOutput(params) {
-        return self.terminalManager.getOutput(params.terminalId);
-      },
-      async waitForTerminalExit(params) {
-        return self.terminalManager.waitForExit(params.terminalId);
-      },
-      async killTerminal(params) {
-        self.terminalManager.kill(params.terminalId);
-        return {};
-      },
-      async releaseTerminal(params) {
-        self.terminalManager.release(params.terminalId);
-      }
-    };
-  }
-  // ── New ACP methods ──────────────────────────────────────────────────
-  async setMode(modeId) {
-    await this.connection.setSessionMode({ sessionId: this.sessionId, modeId });
-  }
-  async setConfigOption(configId, value) {
-    return await this.connection.setSessionConfigOption({
-      sessionId: this.sessionId,
-      configId,
-      ...value
-    });
-  }
-  async setModel(modelId) {
-    await this.connection.unstable_setSessionModel({
-      sessionId: this.sessionId,
-      modelId
-    });
-  }
-  async listSessions(cwd, cursor) {
-    return await this.connection.listSessions({
-      cwd: cwd ?? null,
-      cursor: cursor ?? null
-    });
-  }
-  async loadSession(sessionId, cwd, mcpServers) {
-    const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
-    return await this.connection.loadSession({
-      sessionId,
-      cwd,
-      mcpServers: resolvedMcp
-    });
-  }
-  async authenticate(methodId) {
-    await this.connection.authenticate({ methodId });
-  }
-  async forkSession(sessionId, cwd, mcpServers) {
-    const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
-    return await this.connection.unstable_forkSession({
-      sessionId,
-      cwd,
-      mcpServers: resolvedMcp
-    });
-  }
-  async closeSession(sessionId) {
-    await this.connection.unstable_closeSession({ sessionId });
-  }
-  // ── Prompt & lifecycle ──────────────────────────────────────────────
-  async prompt(text, attachments) {
-    const contentBlocks = [{ type: "text", text }];
-    const SUPPORTED_IMAGE_MIMES = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
-    for (const att of attachments ?? []) {
-      const tooLarge = att.size > 10 * 1024 * 1024;
-      if (att.type === "image" && this.promptCapabilities?.image && !tooLarge && SUPPORTED_IMAGE_MIMES.has(att.mimeType)) {
-        const data = await fs2.promises.readFile(att.filePath);
-        contentBlocks.push({ type: "image", data: data.toString("base64"), mimeType: att.mimeType });
-      } else if (att.type === "audio" && this.promptCapabilities?.audio && !tooLarge) {
-        const data = await fs2.promises.readFile(att.filePath);
-        contentBlocks.push({ type: "audio", data: data.toString("base64"), mimeType: att.mimeType });
-      } else {
-        if ((att.type === "image" || att.type === "audio") && !tooLarge) {
-          log.debug(
-            { type: att.type, capabilities: this.promptCapabilities ?? {} },
-            "Agent does not support %s content, falling back to file path",
-            att.type
-          );
-        }
-        contentBlocks[0].text += `
-
-[Attached file: ${att.filePath}]`;
-      }
-    }
-    return this.connection.prompt({
-      sessionId: this.sessionId,
-      prompt: contentBlocks
-    });
-  }
-  async cancel() {
-    await this.connection.cancel({ sessionId: this.sessionId });
-  }
-  async destroy() {
-    this._destroying = true;
-    this.terminalManager.destroyAll();
-    if (this.child.exitCode !== null) return;
-    await new Promise((resolve) => {
-      this.child.on("exit", () => {
-        clearTimeout(forceKillTimer);
-        resolve();
-      });
-      this.child.kill("SIGTERM");
-      const forceKillTimer = setTimeout(() => {
-        if (this.child.exitCode === null) this.child.kill("SIGKILL");
-        resolve();
-      }, 1e4);
-      if (typeof forceKillTimer === "object" && forceKillTimer !== null && "unref" in forceKillTimer) {
-        forceKillTimer.unref();
-      }
-    });
-  }
-};
-
-// src/core/agents/agent-manager.ts
-var AgentManager = class {
-  constructor(catalog) {
-    this.catalog = catalog;
-  }
-  getAvailableAgents() {
-    const installed = this.catalog.getInstalledEntries();
-    return Object.entries(installed).map(([key, agent]) => ({
-      name: key,
-      command: agent.command,
-      args: agent.args,
-      env: agent.env
-    }));
-  }
-  getAgent(name) {
-    return this.catalog.resolve(name);
-  }
-  async spawn(agentName, workingDirectory) {
-    const agentDef = this.getAgent(agentName);
-    if (!agentDef) throw new Error(`Agent "${agentName}" is not installed. Run "openacp agents install ${agentName}" to add it.`);
-    return AgentInstance.spawn(agentDef, workingDirectory);
-  }
-  async resume(agentName, workingDirectory, agentSessionId) {
-    const agentDef = this.getAgent(agentName);
-    if (!agentDef) throw new Error(`Agent "${agentName}" is not installed. Run "openacp agents install ${agentName}" to add it.`);
-    return AgentInstance.resume(agentDef, workingDirectory, agentSessionId);
-  }
-};
-
-// src/core/sessions/prompt-queue.ts
-var PromptQueue = class {
-  constructor(processor, onError) {
-    this.processor = processor;
-    this.onError = onError;
-  }
-  queue = [];
-  processing = false;
-  abortController = null;
-  async enqueue(text, attachments) {
-    if (this.processing) {
-      return new Promise((resolve) => {
-        this.queue.push({ text, attachments, resolve });
-      });
-    }
-    await this.process(text, attachments);
-  }
-  async process(text, attachments) {
-    this.processing = true;
-    this.abortController = new AbortController();
-    const { signal } = this.abortController;
-    try {
-      await Promise.race([
-        this.processor(text, attachments),
-        new Promise((_, reject) => {
-          signal.addEventListener("abort", () => reject(new Error("Prompt aborted")), { once: true });
-        })
-      ]);
-    } catch (err) {
-      if (!(err instanceof Error && err.message === "Prompt aborted")) {
-        this.onError?.(err);
-      }
-    } finally {
-      this.abortController = null;
-      this.processing = false;
-      this.drainNext();
-    }
-  }
-  drainNext() {
-    const next = this.queue.shift();
-    if (next) {
-      this.process(next.text, next.attachments).then(next.resolve);
-    }
-  }
-  clear() {
-    if (this.abortController) {
-      this.abortController.abort();
-    }
-    for (const item of this.queue) {
-      item.resolve();
-    }
-    this.queue = [];
-  }
-  get pending() {
-    return this.queue.length;
-  }
-  get isProcessing() {
-    return this.processing;
-  }
-};
-
-// src/core/sessions/permission-gate.ts
-var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
-var PermissionGate = class {
-  request;
-  resolveFn;
-  rejectFn;
-  settled = false;
-  timeoutTimer;
-  timeoutMs;
-  constructor(timeoutMs) {
-    this.timeoutMs = timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  }
-  setPending(request) {
-    if (!this.settled && this.rejectFn) {
-      this.rejectFn(new Error("Superseded by new permission request"));
-    }
-    this.request = request;
-    this.settled = false;
-    this.clearTimeout();
-    return new Promise((resolve, reject) => {
-      this.resolveFn = resolve;
-      this.rejectFn = reject;
-      this.timeoutTimer = setTimeout(() => {
-        this.reject("Permission request timed out (no response received)");
-      }, this.timeoutMs);
-      if (typeof this.timeoutTimer === "object" && "unref" in this.timeoutTimer) {
-        this.timeoutTimer.unref();
-      }
-    });
-  }
-  resolve(optionId) {
-    if (this.settled || !this.resolveFn) return;
-    this.settled = true;
-    this.clearTimeout();
-    this.resolveFn(optionId);
-    this.cleanup();
-  }
-  reject(reason) {
-    if (this.settled || !this.rejectFn) return;
-    this.settled = true;
-    this.clearTimeout();
-    this.rejectFn(new Error(reason ?? "Permission rejected"));
-    this.cleanup();
-  }
-  get isPending() {
-    return !!this.request && !this.settled;
-  }
-  get currentRequest() {
-    return this.isPending ? this.request : void 0;
-  }
-  /** The request ID of the current pending request, undefined after settlement */
-  get requestId() {
-    return this.request?.id;
-  }
-  clearTimeout() {
-    if (this.timeoutTimer) {
-      clearTimeout(this.timeoutTimer);
-      this.timeoutTimer = void 0;
-    }
-  }
-  cleanup() {
-    this.request = void 0;
-    this.resolveFn = void 0;
-    this.rejectFn = void 0;
-  }
-};
-
-// src/core/sessions/session.ts
-import { nanoid } from "nanoid";
-import * as fs3 from "fs";
-var moduleLog = createChildLogger({ module: "session" });
-var TTS_PROMPT_INSTRUCTION = `
-
-Additionally, include a [TTS]...[/TTS] block with a spoken-friendly summary of your response. Focus on key information, decisions the user needs to make, or actions required. The agent decides what to say and how long. Respond in the same language the user is using. This instruction applies to this message only.`;
-var TTS_BLOCK_REGEX = /\[TTS\]([\s\S]*?)\[\/TTS\]/;
-var TTS_MAX_LENGTH = 5e3;
-var TTS_TIMEOUT_MS = 3e4;
-var VALID_TRANSITIONS = {
-  initializing: /* @__PURE__ */ new Set(["active", "error"]),
-  active: /* @__PURE__ */ new Set(["error", "finished", "cancelled"]),
-  error: /* @__PURE__ */ new Set(["active", "cancelled"]),
-  cancelled: /* @__PURE__ */ new Set(["active"]),
-  finished: /* @__PURE__ */ new Set()
-};
-var Session = class extends TypedEmitter {
-  id;
-  channelId;
-  threadId = "";
-  agentName;
-  workingDirectory;
-  agentInstance;
-  agentSessionId = "";
-  _status = "initializing";
-  name;
-  createdAt = /* @__PURE__ */ new Date();
-  voiceMode = "off";
-  dangerousMode = false;
-  currentMode;
-  availableModes = [];
-  configOptions = [];
-  currentModel;
-  availableModels = [];
-  agentCapabilities;
-  archiving = false;
-  promptCount = 0;
-  firstAgent;
-  agentSwitchHistory = [];
-  log;
-  middlewareChain;
-  permissionGate = new PermissionGate();
-  queue;
-  speechService;
-  pendingContext = null;
-  constructor(opts) {
-    super();
-    this.id = opts.id || nanoid(12);
-    this.channelId = opts.channelId;
-    this.agentName = opts.agentName;
-    this.firstAgent = opts.agentName;
-    this.workingDirectory = opts.workingDirectory;
-    this.agentInstance = opts.agentInstance;
-    this.speechService = opts.speechService;
-    this.log = createSessionLogger(this.id, moduleLog);
-    this.log.info({ agentName: this.agentName }, "Session created");
-    this.queue = new PromptQueue(
-      (text, attachments) => this.processPrompt(text, attachments),
-      (err) => {
-        this.fail("Prompt execution failed");
-        this.log.error({ err }, "Prompt execution failed");
-      }
-    );
-  }
-  // --- State Machine ---
-  get status() {
-    return this._status;
-  }
-  /** Transition to active — from initializing, error, or cancelled */
-  activate() {
-    this.transition("active");
-  }
-  /** Transition to error — from initializing or active */
-  fail(reason) {
-    this.transition("error");
-    this.emit("error", new Error(reason));
-  }
-  /** Transition to finished — from active only. Emits session_end for backward compat. */
-  finish(reason) {
-    this.transition("finished");
-    this.emit("session_end", reason ?? "completed");
-  }
-  /** Transition to cancelled — from active only (terminal session cancel) */
-  markCancelled() {
-    this.transition("cancelled");
-  }
-  transition(to) {
-    const from = this._status;
-    const allowed = VALID_TRANSITIONS[from];
-    if (!allowed?.has(to)) {
-      throw new Error(
-        `Invalid session transition: ${from} \u2192 ${to}`
-      );
-    }
-    this._status = to;
-    this.log.debug({ from, to }, "Session status transition");
-    this.emit("status_change", from, to);
-  }
-  /** Number of prompts waiting in queue */
-  get queueDepth() {
-    return this.queue.pending;
-  }
-  get promptRunning() {
-    return this.queue.isProcessing;
-  }
-  // --- Context Injection ---
-  setContext(markdown) {
-    this.pendingContext = markdown;
-  }
-  // --- Voice Mode ---
-  setVoiceMode(mode) {
-    this.voiceMode = mode;
-    this.log.info({ voiceMode: mode }, "TTS mode changed");
-  }
-  // --- Public API ---
-  async enqueuePrompt(text, attachments) {
-    if (this.middlewareChain) {
-      const payload = { text, attachments, sessionId: this.id };
-      const result = await this.middlewareChain.execute("agent:beforePrompt", payload, async (p) => p);
-      if (!result) return;
-      text = result.text;
-      attachments = result.attachments;
-    }
-    await this.queue.enqueue(text, attachments);
-  }
-  async processPrompt(text, attachments) {
-    if (text === "\0__warmup__") {
-      await this.runWarmup();
-      return;
-    }
-    if (this._status === "finished") return;
-    this.promptCount++;
-    this.emit("prompt_count_changed", this.promptCount);
-    if (this._status === "initializing" || this._status === "cancelled" || this._status === "error") {
-      this.activate();
-    }
-    const promptStart = Date.now();
-    this.log.debug("Prompt execution started");
-    const contextUsed = this.pendingContext;
-    if (contextUsed) {
-      text = `[CONVERSATION HISTORY - This is context from previous sessions, not current conversation]
-
-${contextUsed}
-
-[END CONVERSATION HISTORY]
-
-${text}`;
-      this.log.debug("Context injected into prompt");
-    }
-    const processed = await this.maybeTranscribeAudio(text, attachments);
-    const ttsActive = this.voiceMode !== "off" && !!this.speechService?.isTTSAvailable();
-    if (ttsActive) {
-      processed.text += TTS_PROMPT_INSTRUCTION;
-    }
-    let accumulatedText = "";
-    const accumulatorListener = ttsActive ? (event) => {
-      if (event.type === "text") {
-        accumulatedText += event.content;
-      }
-    } : null;
-    if (accumulatorListener) {
-      this.on("agent_event", accumulatorListener);
-    }
-    if (this.middlewareChain) {
-      this.middlewareChain.execute("turn:start", { sessionId: this.id, promptText: processed.text, promptNumber: this.promptCount }, async (p) => p).catch(() => {
-      });
-    }
-    let stopReason = "end_turn";
-    try {
-      const response = await this.agentInstance.prompt(processed.text, processed.attachments);
-      if (response && typeof response === "object" && "stopReason" in response) {
-        stopReason = response.stopReason ?? "end_turn";
-      }
-      if (contextUsed) {
-        this.pendingContext = null;
-      }
-      if (ttsActive && this.voiceMode === "next") {
-        this.voiceMode = "off";
-      }
-    } finally {
-      if (accumulatorListener) {
-        this.off("agent_event", accumulatorListener);
-      }
-    }
-    if (this.middlewareChain) {
-      this.middlewareChain.execute("turn:end", { sessionId: this.id, stopReason, durationMs: Date.now() - promptStart }, async (p) => p).catch(() => {
-      });
-    }
-    this.log.info(
-      { durationMs: Date.now() - promptStart },
-      "Prompt execution completed"
-    );
-    if (ttsActive && accumulatedText) {
-      this.processTTSResponse(accumulatedText).catch((err) => {
-        this.log.warn({ err }, "TTS post-processing failed");
-      });
-    }
-    if (!this.name) {
-      await this.autoName();
-    }
-  }
-  async maybeTranscribeAudio(text, attachments) {
-    if (!attachments?.length || !this.speechService) {
-      return { text, attachments };
-    }
-    const hasAudioCapability = this.agentInstance.promptCapabilities?.audio === true;
-    if (hasAudioCapability) {
-      return { text, attachments };
-    }
-    if (!this.speechService.isSTTAvailable()) {
-      return { text, attachments };
-    }
-    let transcribedText = text;
-    const remainingAttachments = [];
-    for (const att of attachments) {
-      if (att.type !== "audio") {
-        remainingAttachments.push(att);
-        continue;
-      }
-      try {
-        const audioPath = att.originalFilePath || att.filePath;
-        const audioMime = att.originalFilePath ? "audio/ogg" : att.mimeType;
-        const audioBuffer = await fs3.promises.readFile(audioPath);
-        const result = await this.speechService.transcribe(audioBuffer, audioMime);
-        this.log.info({ provider: "stt", duration: result.duration }, "Voice transcribed");
-        this.emit("agent_event", {
-          type: "system_message",
-          message: `\u{1F3A4} You said: ${result.text}`
-        });
-        transcribedText = transcribedText.replace(/\[Audio:\s*[^\]]*\]\s*/g, "").trim();
-        transcribedText = transcribedText ? `${transcribedText}
-${result.text}` : result.text;
-      } catch (err) {
-        this.log.warn({ err }, "STT transcription failed, keeping audio attachment");
-        this.emit("agent_event", {
-          type: "error",
-          message: `Voice transcription failed: ${err.message}`
-        });
-        remainingAttachments.push(att);
-      }
-    }
-    return {
-      text: transcribedText,
-      attachments: remainingAttachments.length > 0 ? remainingAttachments : void 0
-    };
-  }
-  async processTTSResponse(responseText) {
-    const match = TTS_BLOCK_REGEX.exec(responseText);
-    if (!match?.[1]) {
-      this.log.debug("No [TTS] block found in response, skipping synthesis");
-      return;
-    }
-    let ttsText = match[1].trim();
-    if (!ttsText) return;
-    if (ttsText.length > TTS_MAX_LENGTH) {
-      ttsText = ttsText.slice(0, TTS_MAX_LENGTH);
-    }
-    try {
-      let ttsTimer;
-      const timeoutPromise = new Promise((_, reject) => {
-        ttsTimer = setTimeout(() => reject(new Error("TTS synthesis timed out")), TTS_TIMEOUT_MS);
-      });
-      try {
-        const result = await Promise.race([
-          this.speechService.synthesize(ttsText),
-          timeoutPromise
-        ]);
-        const base64 = result.audioBuffer.toString("base64");
-        this.emit("agent_event", {
-          type: "audio_content",
-          data: base64,
-          mimeType: result.mimeType
-        });
-        this.emit("agent_event", { type: "tts_strip" });
-        this.log.info("TTS synthesis completed");
-      } finally {
-        clearTimeout(ttsTimer);
-      }
-    } catch (err) {
-      this.log.warn({ err }, "TTS synthesis failed, skipping");
-    }
-  }
-  // NOTE: This injects a summary prompt into the agent's conversation history.
-  async autoName() {
-    let title = "";
-    const captureHandler = (event) => {
-      if (event.type === "text") title += event.content;
-    };
-    this.pause((event) => event !== "agent_event");
-    this.agentInstance.on("agent_event", captureHandler);
-    try {
-      await this.agentInstance.prompt(
-        "Summarize this conversation in max 5 words for a topic title. Reply ONLY with the title, nothing else."
-      );
-      this.name = title.trim().slice(0, 50) || `Session ${this.id.slice(0, 6)}`;
-      this.log.info({ name: this.name }, "Session auto-named");
-      this.emit("named", this.name);
-    } catch {
-      this.name = `Session ${this.id.slice(0, 6)}`;
-    } finally {
-      this.agentInstance.off("agent_event", captureHandler);
-      this.clearBuffer();
-      this.resume();
-    }
-  }
-  /** Fire-and-forget warm-up: primes model cache while user types their first message */
-  async warmup() {
-    await this.queue.enqueue("\0__warmup__");
-  }
-  async runWarmup() {
-    this.pause((_event, args) => {
-      const agentEvent = args[0];
-      return agentEvent?.type === "commands_update";
-    });
-    try {
-      const start = Date.now();
-      await this.agentInstance.prompt('Reply with only "ready".');
-      this.activate();
-      this.log.info({ durationMs: Date.now() - start }, "Warm-up complete");
-    } catch (err) {
-      this.log.error({ err }, "Warm-up failed");
-    } finally {
-      this.clearBuffer();
-      this.resume();
-    }
-  }
-  // --- ACP Mode / Config / Model State ---
-  setInitialAcpState(state) {
-    if (state.modes) {
-      this.currentMode = state.modes.currentModeId;
-      this.availableModes = state.modes.availableModes;
-    }
-    if (state.configOptions) {
-      this.configOptions = state.configOptions;
-    }
-    if (state.models) {
-      this.currentModel = state.models.currentModelId;
-      this.availableModels = state.models.availableModels;
-    }
-    if (state.agentCapabilities) {
-      this.agentCapabilities = state.agentCapabilities;
-    }
-  }
-  /** Set session name explicitly and emit 'named' event */
-  setName(name) {
-    this.name = name;
-    this.emit("named", name);
-  }
-  async updateMode(modeId) {
-    if (this.middlewareChain) {
-      const result = await this.middlewareChain.execute("mode:beforeChange", { sessionId: this.id, fromMode: this.currentMode, toMode: modeId }, async (p) => p);
-      if (!result) return;
-    }
-    this.currentMode = modeId;
-  }
-  async updateConfigOptions(options) {
-    if (this.middlewareChain) {
-      const result = await this.middlewareChain.execute("config:beforeChange", { sessionId: this.id, configId: "options", oldValue: this.configOptions, newValue: options }, async (p) => p);
-      if (!result) return;
-    }
-    this.configOptions = options;
-  }
-  async updateModel(modelId) {
-    if (this.middlewareChain) {
-      const result = await this.middlewareChain.execute("model:beforeChange", { sessionId: this.id, fromModel: this.currentModel, toModel: modelId }, async (p) => p);
-      if (!result) return;
-    }
-    this.currentModel = modelId;
-  }
-  /** Cancel the current prompt and clear the queue. Stays in active state. */
-  async abortPrompt() {
-    if (this.middlewareChain) {
-      const result = await this.middlewareChain.execute("agent:beforeCancel", { sessionId: this.id }, async (p) => p);
-      if (!result) return;
-    }
-    this.queue.clear();
-    this.log.info("Prompt aborted");
-    await this.agentInstance.cancel();
-  }
-  /** Search backward through agentSwitchHistory for the last entry matching agentName */
-  findLastSwitchEntry(agentName) {
-    for (let i = this.agentSwitchHistory.length - 1; i >= 0; i--) {
-      if (this.agentSwitchHistory[i].agentName === agentName) {
-        return this.agentSwitchHistory[i];
-      }
-    }
-    return void 0;
-  }
-  /** Switch the agent instance in-place, preserving session identity */
-  async switchAgent(agentName, createAgent) {
-    if (agentName === this.agentName) {
-      throw new Error(`Already using ${agentName}`);
-    }
-    this.agentSwitchHistory.push({
-      agentName: this.agentName,
-      agentSessionId: this.agentSessionId,
-      switchedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      promptCount: this.promptCount
-    });
-    this.queue.clear();
-    if (this.permissionGate.isPending) {
-      this.permissionGate.reject("Agent switched");
-    }
-    await this.agentInstance.destroy();
-    const newAgent = await createAgent();
-    this.agentInstance = newAgent;
-    this.agentName = agentName;
-    this.agentSessionId = newAgent.sessionId;
-    this.promptCount = 0;
-    this.agentCapabilities = void 0;
-    this.currentMode = void 0;
-    this.availableModes = [];
-    this.currentModel = void 0;
-    this.availableModels = [];
-    this.configOptions = [];
-    this.log.info({ from: this.agentSwitchHistory.at(-1).agentName, to: agentName }, "Agent switched");
-  }
-  async destroy() {
-    this.log.info("Session destroyed");
-    if (this.permissionGate.isPending) {
-      this.permissionGate.reject("Session destroyed");
-    }
-    this.queue.clear();
-    await this.agentInstance.destroy();
-    closeSessionLogger(this.log);
-  }
-};
-
-// src/core/sessions/session-manager.ts
-var SessionManager = class {
-  sessions = /* @__PURE__ */ new Map();
-  store;
-  eventBus;
-  middlewareChain;
-  setEventBus(eventBus) {
-    this.eventBus = eventBus;
-  }
-  constructor(store = null) {
-    this.store = store;
-  }
-  async createSession(channelId, agentName, workingDirectory, agentManager) {
-    const agentInstance = await agentManager.spawn(agentName, workingDirectory);
-    const session = new Session({
-      channelId,
-      agentName,
-      workingDirectory,
-      agentInstance
-    });
-    this.sessions.set(session.id, session);
-    session.agentSessionId = session.agentInstance.sessionId;
-    if (this.store) {
-      await this.store.save({
-        sessionId: session.id,
-        agentSessionId: session.agentInstance.sessionId,
-        agentName: session.agentName,
-        workingDir: session.workingDirectory,
-        channelId,
-        status: session.status,
-        createdAt: session.createdAt.toISOString(),
-        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
-        name: session.name,
-        dangerousMode: false,
-        platform: {}
-      });
-    }
-    return session;
-  }
-  getSession(sessionId) {
-    return this.sessions.get(sessionId);
-  }
-  getSessionByThread(channelId, threadId) {
-    for (const session of this.sessions.values()) {
-      if (session.channelId === channelId && session.threadId === threadId) {
-        return session;
-      }
-    }
-    return void 0;
-  }
-  getSessionByAgentSessionId(agentSessionId) {
-    for (const session of this.sessions.values()) {
-      if (session.agentSessionId === agentSessionId) {
-        return session;
-      }
-    }
-    return void 0;
-  }
-  getRecordByAgentSessionId(agentSessionId) {
-    return this.store?.findByAgentSessionId(agentSessionId);
-  }
-  getRecordByThread(channelId, threadId) {
-    return this.store?.findByPlatform(
-      channelId,
-      (p) => String(p.topicId) === threadId || p.threadId === threadId
-    );
-  }
-  registerSession(session) {
-    this.sessions.set(session.id, session);
-  }
-  async patchRecord(sessionId, patch) {
-    if (!this.store) return;
-    const record = this.store.get(sessionId);
-    if (record) {
-      await this.store.save({ ...record, ...patch });
-    } else if (patch.sessionId) {
-      await this.store.save(patch);
-    }
-  }
-  getSessionRecord(sessionId) {
-    return this.store?.get(sessionId);
-  }
-  async cancelSession(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      try {
-        await session.abortPrompt();
-      } catch {
-      }
-      session.markCancelled();
-      this.sessions.delete(sessionId);
-    }
-    if (this.store) {
-      const record = this.store.get(sessionId);
-      if (record && record.status !== "cancelled") {
-        await this.store.save({ ...record, status: "cancelled" });
-      }
-    }
-    if (this.middlewareChain) {
-      this.middlewareChain.execute("session:afterDestroy", { sessionId }, async (p) => p).catch(() => {
-      });
-    }
-  }
-  listSessions(channelId) {
-    const all = Array.from(this.sessions.values());
-    if (channelId) return all.filter((s) => s.channelId === channelId);
-    return all;
-  }
-  listRecords(filter) {
-    if (!this.store) return [];
-    let records = this.store.list();
-    if (filter?.statuses?.length) {
-      records = records.filter((r) => filter.statuses.includes(r.status));
-    }
-    return records;
-  }
-  async removeRecord(sessionId) {
-    if (!this.store) return;
-    await this.store.remove(sessionId);
-    this.eventBus?.emit("session:deleted", { sessionId });
-  }
-  /**
-   * Graceful shutdown: persist session state without killing agent subprocesses.
-   * Agent processes will exit naturally when the parent process terminates.
-   */
-  async shutdownAll() {
-    if (this.store) {
-      for (const session of this.sessions.values()) {
-        const record = this.store.get(session.id);
-        if (record) {
-          await this.store.save({ ...record, status: "finished" });
-        }
-      }
-    }
-    this.sessions.clear();
-  }
-  /**
-   * Forcefully destroy all sessions (kill agent subprocesses).
-   * Use only when sessions must be fully torn down (e.g. archive).
-   */
-  async destroyAll() {
-    if (this.store) {
-      for (const session of this.sessions.values()) {
-        const record = this.store.get(session.id);
-        if (record) {
-          await this.store.save({ ...record, status: "finished" });
-        }
-      }
-    }
-    const sessionIds = [...this.sessions.keys()];
-    for (const session of this.sessions.values()) {
-      await session.destroy();
-    }
-    this.sessions.clear();
-    if (this.middlewareChain) {
-      for (const sessionId of sessionIds) {
-        this.middlewareChain.execute("session:afterDestroy", { sessionId }, async (p) => p).catch(() => {
-        });
-      }
-    }
-  }
-};
-
-// src/core/sessions/session-bridge.ts
-var log2 = createChildLogger({ module: "session-bridge" });
-var SessionBridge = class {
-  constructor(session, adapter, deps) {
-    this.session = session;
-    this.adapter = adapter;
-    this.deps = deps;
-  }
-  connected = false;
-  agentEventHandler;
-  sessionEventHandler;
-  statusChangeHandler;
-  namedHandler;
-  promptCountHandler;
-  get tracer() {
-    return this.session.agentInstance.debugTracer ?? null;
-  }
-  /** Send message to adapter, optionally running through message:outgoing middleware */
-  async sendMessage(sessionId, message) {
-    try {
-      const mw = this.deps.middlewareChain;
-      if (mw) {
-        const result = await mw.execute("message:outgoing", { sessionId, message }, async (m) => m);
-        this.tracer?.log("core", { step: "middleware:outgoing", sessionId, hook: "message:outgoing", blocked: !result });
-        if (!result) return;
-        this.tracer?.log("core", { step: "dispatch", sessionId, message: result.message });
-        this.adapter.sendMessage(sessionId, result.message).catch((err) => {
-          log2.error({ err, sessionId }, "Failed to send message to adapter");
-        });
-      } else {
-        this.tracer?.log("core", { step: "dispatch", sessionId, message });
-        this.adapter.sendMessage(sessionId, message).catch((err) => {
-          log2.error({ err, sessionId }, "Failed to send message to adapter");
-        });
-      }
-    } catch (err) {
-      log2.error({ err, sessionId }, "Error in sendMessage middleware");
-    }
-  }
-  connect() {
-    if (this.connected) return;
-    this.connected = true;
-    this.wireAgentToSession();
-    this.wireSessionToAdapter();
-    this.wirePermissions();
-    this.wireLifecycle();
-  }
-  disconnect() {
-    if (!this.connected) return;
-    this.connected = false;
-    if (this.agentEventHandler) {
-      this.session.agentInstance.off("agent_event", this.agentEventHandler);
-    }
-    if (this.sessionEventHandler) {
-      this.session.off("agent_event", this.sessionEventHandler);
-    }
-    if (this.statusChangeHandler) {
-      this.session.off("status_change", this.statusChangeHandler);
-    }
-    if (this.namedHandler) {
-      this.session.off("named", this.namedHandler);
-    }
-    if (this.promptCountHandler) {
-      this.session.off("prompt_count_changed", this.promptCountHandler);
-    }
-    this.session.agentInstance.onPermissionRequest = async () => "";
-  }
-  wireAgentToSession() {
-    this.agentEventHandler = (event) => {
-      this.session.emit("agent_event", event);
-    };
-    this.session.agentInstance.on("agent_event", this.agentEventHandler);
-  }
-  wireSessionToAdapter() {
-    this.sessionEventHandler = (event) => {
-      this.tracer?.log("core", { step: "agent_event", sessionId: this.session.id, event });
-      const mw = this.deps.middlewareChain;
-      if (mw) {
-        mw.execute("agent:beforeEvent", { sessionId: this.session.id, event }, async (e) => e).then((result) => {
-          this.tracer?.log("core", { step: "middleware:before", sessionId: this.session.id, hook: "agent:beforeEvent", blocked: !result });
-          if (!result) return;
-          try {
-            const transformedEvent = result.event;
-            const outgoing = this.handleAgentEvent(transformedEvent);
-            mw.execute("agent:afterEvent", {
-              sessionId: this.session.id,
-              event: transformedEvent,
-              outgoingMessage: outgoing ?? { type: "text", text: "" }
-            }, async (e) => e).catch(() => {
-            });
-          } catch (err) {
-            log2.error({ err, sessionId: this.session.id }, "Error handling agent event after middleware");
-          }
-        }).catch(() => {
-          try {
-            this.handleAgentEvent(event);
-          } catch (err) {
-            log2.error({ err, sessionId: this.session.id }, "Error handling agent event (middleware fallback)");
-          }
-        });
-      } else {
-        try {
-          this.handleAgentEvent(event);
-        } catch (err) {
-          log2.error({ err, sessionId: this.session.id }, "Error handling agent event");
-        }
-      }
-    };
-    this.session.on("agent_event", this.sessionEventHandler);
-  }
-  handleAgentEvent(event) {
-    const session = this.session;
-    const ctx = {
-      get id() {
-        return session.id;
-      },
-      get workingDirectory() {
-        return session.workingDirectory;
-      }
-    };
-    let outgoing;
-    switch (event.type) {
-      case "text":
-      case "thought":
-      case "tool_call":
-      case "tool_update":
-      case "plan":
-      case "usage":
-        outgoing = this.deps.messageTransformer.transform(event, ctx);
-        this.tracer?.log("core", { step: "transform", sessionId: this.session.id, input: event, output: outgoing });
-        this.sendMessage(this.session.id, outgoing);
-        break;
-      case "session_end":
-        this.session.finish(event.reason);
-        this.adapter.cleanupSkillCommands?.(this.session.id);
-        outgoing = this.deps.messageTransformer.transform(event);
-        this.sendMessage(this.session.id, outgoing);
-        this.deps.notificationManager.notify(this.session.channelId, {
-          sessionId: this.session.id,
-          sessionName: this.session.name,
-          type: "completed",
-          summary: `Session "${this.session.name || this.session.id}" completed
-\u23F1 ${Math.round((Date.now() - this.session.createdAt.getTime()) / 6e4)} min \xB7 \u{1F4AC} ${this.session.promptCount} prompts`
-        });
-        break;
-      case "error":
-        this.session.fail(event.message);
-        this.adapter.cleanupSkillCommands?.(this.session.id);
-        outgoing = this.deps.messageTransformer.transform(event);
-        this.sendMessage(this.session.id, outgoing);
-        this.deps.notificationManager.notify(this.session.channelId, {
-          sessionId: this.session.id,
-          sessionName: this.session.name,
-          type: "error",
-          summary: event.message
-        });
-        break;
-      case "image_content": {
-        if (this.deps.fileService) {
-          const fs6 = this.deps.fileService;
-          const sid = this.session.id;
-          const { data, mimeType } = event;
-          const buffer = Buffer.from(data, "base64");
-          const ext = fs6.extensionFromMime(mimeType);
-          fs6.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
-            this.sendMessage(sid, {
-              type: "attachment",
-              text: "",
-              attachment: att
-            });
-          }).catch((err) => log2.error({ err }, "Failed to save agent image"));
-        }
-        break;
-      }
-      case "audio_content": {
-        if (this.deps.fileService) {
-          const fs6 = this.deps.fileService;
-          const sid = this.session.id;
-          const { data, mimeType } = event;
-          const buffer = Buffer.from(data, "base64");
-          const ext = fs6.extensionFromMime(mimeType);
-          fs6.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
-            this.sendMessage(sid, {
-              type: "attachment",
-              text: "",
-              attachment: att
-            });
-          }).catch((err) => log2.error({ err }, "Failed to save agent audio"));
-        }
-        break;
-      }
-      case "commands_update":
-        log2.debug({ commands: event.commands }, "Commands available");
-        this.adapter.sendSkillCommands?.(this.session.id, event.commands);
-        break;
-      case "system_message":
-        outgoing = this.deps.messageTransformer.transform(event);
-        this.sendMessage(this.session.id, outgoing);
-        break;
-      case "session_info_update":
-        if (event.title) {
-          this.session.setName(event.title);
-        }
-        outgoing = this.deps.messageTransformer.transform(event);
-        this.sendMessage(this.session.id, outgoing);
-        break;
-      case "current_mode_update":
-        this.session.updateMode(event.modeId);
-        outgoing = this.deps.messageTransformer.transform(event);
-        this.sendMessage(this.session.id, outgoing);
-        break;
-      case "config_option_update":
-        this.session.updateConfigOptions(event.options);
-        outgoing = this.deps.messageTransformer.transform(event);
-        this.sendMessage(this.session.id, outgoing);
-        break;
-      case "model_update":
-        this.session.updateModel(event.modelId);
-        outgoing = this.deps.messageTransformer.transform(event);
-        this.sendMessage(this.session.id, outgoing);
-        break;
-      case "user_message_chunk":
-        outgoing = this.deps.messageTransformer.transform(event);
-        this.sendMessage(this.session.id, outgoing);
-        break;
-      case "resource_content":
-      case "resource_link":
-        outgoing = this.deps.messageTransformer.transform(event);
-        this.sendMessage(this.session.id, outgoing);
-        break;
-      case "tts_strip":
-        this.adapter.stripTTSBlock?.(this.session.id);
-        break;
-    }
-    this.deps.eventBus?.emit("agent:event", {
-      sessionId: this.session.id,
-      event
-    });
-    return outgoing;
-  }
-  wirePermissions() {
-    const mw = this.deps.middlewareChain;
-    this.session.agentInstance.onPermissionRequest = async (request) => {
-      const startTime = Date.now();
-      let permReq = request;
-      if (mw) {
-        const payload = { sessionId: this.session.id, request, autoResolve: void 0 };
-        const result = await mw.execute("permission:beforeRequest", payload, async (r) => r);
-        if (!result) return "";
-        permReq = result.request;
-        if (result.autoResolve) {
-          if (mw) {
-            mw.execute("permission:afterResolve", {
-              sessionId: this.session.id,
-              requestId: permReq.id,
-              decision: result.autoResolve,
-              userId: "middleware",
-              durationMs: Date.now() - startTime
-            }, async (p) => p).catch(() => {
-            });
-          }
-          return result.autoResolve;
-        }
-      }
-      this.session.emit("permission_request", permReq);
-      this.deps.eventBus?.emit("permission:request", {
-        sessionId: this.session.id,
-        permission: permReq
-      });
-      if (permReq.description.toLowerCase().includes("openacp")) {
-        const allowOption = permReq.options.find((o) => o.isAllow);
-        if (allowOption) {
-          log2.info(
-            { sessionId: this.session.id, requestId: permReq.id },
-            "Auto-approving openacp command"
-          );
-          if (mw) {
-            mw.execute("permission:afterResolve", {
-              sessionId: this.session.id,
-              requestId: permReq.id,
-              decision: allowOption.id,
-              userId: "system",
-              durationMs: Date.now() - startTime
-            }, async (p) => p).catch(() => {
-            });
-          }
-          return allowOption.id;
-        }
-      }
-      if (this.session.dangerousMode) {
-        const allowOption = permReq.options.find((o) => o.isAllow);
-        if (allowOption) {
-          log2.info(
-            { sessionId: this.session.id, requestId: permReq.id, optionId: allowOption.id },
-            "Dangerous mode: auto-approving permission"
-          );
-          if (mw) {
-            mw.execute("permission:afterResolve", {
-              sessionId: this.session.id,
-              requestId: permReq.id,
-              decision: allowOption.id,
-              userId: "system",
-              durationMs: Date.now() - startTime
-            }, async (p) => p).catch(() => {
-            });
-          }
-          return allowOption.id;
-        }
-      }
-      const promise = this.session.permissionGate.setPending(permReq);
-      await this.adapter.sendPermissionRequest(this.session.id, permReq);
-      const optionId = await promise;
-      if (mw) {
-        mw.execute("permission:afterResolve", {
-          sessionId: this.session.id,
-          requestId: permReq.id,
-          decision: optionId,
-          userId: "user",
-          durationMs: Date.now() - startTime
-        }, async (p) => p).catch(() => {
-        });
-      }
-      return optionId;
-    };
-  }
-  wireLifecycle() {
-    this.statusChangeHandler = (from, to) => {
-      this.deps.sessionManager.patchRecord(this.session.id, {
-        status: to,
-        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      this.deps.eventBus?.emit("session:updated", {
-        sessionId: this.session.id,
-        status: to
-      });
-      if (to === "finished") {
-        queueMicrotask(() => this.disconnect());
-      }
-    };
-    this.session.on("status_change", this.statusChangeHandler);
-    this.namedHandler = (name) => {
-      this.deps.sessionManager.patchRecord(this.session.id, { name });
-      this.deps.eventBus?.emit("session:updated", {
-        sessionId: this.session.id,
-        name
-      });
-      this.adapter.renameSessionThread(this.session.id, name);
-    };
-    this.session.on("named", this.namedHandler);
-    this.promptCountHandler = (count) => {
-      this.deps.sessionManager.patchRecord(this.session.id, { currentPromptCount: count });
-    };
-    this.session.on("prompt_count_changed", this.promptCountHandler);
-  }
-};
-
-// src/core/utils/extract-file-info.ts
-function extractFileInfo(name, kind, content, rawInput, meta) {
-  if (kind && !["read", "edit", "write"].includes(kind)) return null;
-  let info = null;
-  if (meta) {
-    const m = meta;
-    const toolResponse = resolveToolResponse(m);
-    if (toolResponse) {
-      const file = toolResponse.file;
-      if (typeof file?.filePath === "string" && typeof file?.content === "string") {
-        info = { filePath: file.filePath, content: file.content };
-      }
-      if (!info && typeof toolResponse.filePath === "string" && typeof toolResponse.originalFile === "string") {
-        const originalFile = toolResponse.originalFile;
-        const oldString = typeof toolResponse.oldString === "string" ? toolResponse.oldString : void 0;
-        const newString = typeof toolResponse.newString === "string" ? toolResponse.newString : void 0;
-        const newContent = oldString && newString ? originalFile.replace(oldString, newString) : originalFile;
-        info = { filePath: toolResponse.filePath, content: newContent, oldContent: originalFile };
-      }
-      if (!info && typeof toolResponse.filePath === "string" && typeof toolResponse.content === "string") {
-        info = { filePath: toolResponse.filePath, content: toolResponse.content };
-      }
-    }
-  }
-  if (!info && rawInput && typeof rawInput === "object") {
-    const ri = rawInput;
-    const filePath = ri?.file_path || ri?.filePath || ri?.path;
-    if (typeof filePath === "string") {
-      const parsed = content ? parseContent(content) : null;
-      const riContent = typeof ri?.content === "string" ? ri.content : void 0;
-      if (kind === "edit") {
-        const oldStr = typeof ri.old_string === "string" ? ri.old_string : typeof ri.oldText === "string" ? ri.oldText : void 0;
-        const newStr = typeof ri.new_string === "string" ? ri.new_string : typeof ri.newText === "string" ? ri.newText : void 0;
-        if (newStr) {
-          info = { filePath, content: newStr, oldContent: oldStr };
-        } else {
-          info = { filePath, content: riContent || parsed?.content, oldContent: parsed?.oldContent };
-        }
-      } else if (kind === "write") {
-        info = { filePath, content: riContent || parsed?.content, oldContent: parsed?.oldContent };
-      } else {
-        info = { filePath, content: parsed?.content || riContent, oldContent: parsed?.oldContent };
-      }
-    }
-  }
-  if (!info && content) {
-    info = parseContent(content);
-  }
-  if (!info) return null;
-  if (!info.filePath) {
-    const pathMatch = name.match(/(?:Read|Edit|Write|View)\s+(.+)/i);
-    if (pathMatch) info.filePath = pathMatch[1].trim();
-  }
-  if (!info.filePath || !info.content) return null;
-  return info;
-}
-function resolveToolResponse(meta) {
-  const claudeCode = meta.claudeCode;
-  if (claudeCode?.toolResponse && typeof claudeCode.toolResponse === "object") {
-    return claudeCode.toolResponse;
-  }
-  if (meta.toolResponse && typeof meta.toolResponse === "object") {
-    return meta.toolResponse;
-  }
-  return void 0;
-}
-function parseContent(content) {
-  if (typeof content === "string") {
-    return { content };
-  }
-  if (Array.isArray(content)) {
-    for (const block of content) {
-      const result = parseContent(block);
-      if (result?.content || result?.filePath) return result;
-    }
-    return null;
-  }
-  if (typeof content === "object" && content !== null) {
-    const c = content;
-    if (c.type === "diff" && typeof c.path === "string") {
-      const newText = c.newText;
-      const oldText = c.oldText;
-      if (newText) {
-        return {
-          filePath: c.path,
-          content: newText,
-          oldContent: oldText ?? void 0
-        };
-      }
-    }
-    if (c.type === "content" && c.content) {
-      return parseContent(c.content);
-    }
-    if (c.type === "text" && typeof c.text === "string") {
-      return { content: c.text, filePath: c.filePath };
-    }
-    if (typeof c.text === "string") {
-      return { content: c.text, filePath: c.filePath };
-    }
-    if (typeof c.file_path === "string" || typeof c.filePath === "string" || typeof c.path === "string") {
-      const filePath = c.file_path || c.filePath || c.path;
-      const fileContent = c.content || c.text || c.output || c.newText;
-      if (typeof fileContent === "string") {
-        return {
-          filePath,
-          content: fileContent,
-          oldContent: c.old_content || c.oldText
-        };
-      }
-    }
-    if (c.input) {
-      const result = parseContent(c.input);
-      if (result) return result;
-    }
-    if (c.output) {
-      const result = parseContent(c.output);
-      if (result) return result;
-    }
-  }
-  return null;
-}
-
-// src/core/message-transformer.ts
-var log3 = createChildLogger({ module: "message-transformer" });
-function computeLineDiff(oldStr, newStr) {
-  const oldLines = oldStr ? oldStr.split("\n") : [];
-  const newLines = newStr ? newStr.split("\n") : [];
-  let prefixLen = 0;
-  const minLen = Math.min(oldLines.length, newLines.length);
-  while (prefixLen < minLen && oldLines[prefixLen] === newLines[prefixLen]) {
-    prefixLen++;
-  }
-  let suffixLen = 0;
-  const maxSuffix = minLen - prefixLen;
-  while (suffixLen < maxSuffix && oldLines[oldLines.length - 1 - suffixLen] === newLines[newLines.length - 1 - suffixLen]) {
-    suffixLen++;
-  }
-  return {
-    added: Math.max(0, newLines.length - prefixLen - suffixLen),
-    removed: Math.max(0, oldLines.length - prefixLen - suffixLen)
-  };
-}
-var MessageTransformer = class {
-  tunnelService;
-  /** Cache rawInput from tool_call so it's available in tool_update (which often lacks it) */
-  toolRawInputCache = /* @__PURE__ */ new Map();
-  /** Cache viewer links generated from intermediate updates so completion events carry them */
-  toolViewerCache = /* @__PURE__ */ new Map();
-  constructor(tunnelService) {
-    this.tunnelService = tunnelService;
-  }
-  transform(event, sessionContext) {
-    switch (event.type) {
-      case "text":
-        return { type: "text", text: event.content };
-      case "thought":
-        return { type: "thought", text: event.content };
-      case "tool_call": {
-        if (event.id && this.isNonEmptyInput(event.rawInput)) {
-          this.toolRawInputCache.set(event.id, event.rawInput);
-        }
-        const meta = event.meta;
-        const metadata = {
-          id: event.id,
-          name: event.name,
-          kind: event.kind,
-          status: event.status,
-          content: event.content,
-          locations: event.locations,
-          rawInput: event.rawInput,
-          displaySummary: meta?.displaySummary,
-          displayTitle: meta?.displayTitle,
-          displayKind: meta?.displayKind
-        };
-        this.enrichWithViewerLinks(event, metadata, sessionContext);
-        return { type: "tool_call", text: event.name, metadata };
-      }
-      case "tool_update": {
-        if (event.id && this.isNonEmptyInput(event.rawInput)) {
-          this.toolRawInputCache.set(event.id, event.rawInput);
-        }
-        const cachedRawInput = event.id ? this.toolRawInputCache.get(event.id) : void 0;
-        const effectiveRawInput = this.isNonEmptyInput(event.rawInput) ? event.rawInput : cachedRawInput;
-        if (event.id && (event.status === "completed" || event.status === "done" || event.status === "failed" || event.status === "error")) {
-          this.toolRawInputCache.delete(event.id);
-        }
-        const meta = event.meta;
-        const metadata = {
-          id: event.id,
-          name: event.name,
-          kind: event.kind,
-          status: event.status,
-          content: event.content,
-          rawInput: effectiveRawInput,
-          displaySummary: meta?.displaySummary,
-          displayTitle: meta?.displayTitle,
-          displayKind: meta?.displayKind
-        };
-        const enrichEvent = { ...event, rawInput: effectiveRawInput };
-        this.enrichWithViewerLinks(enrichEvent, metadata, sessionContext);
-        if (event.id) {
-          const cached = this.toolViewerCache.get(event.id);
-          if (cached) {
-            metadata.viewerLinks = cached.viewerLinks;
-            metadata.viewerFilePath = cached.viewerFilePath;
-          } else if (metadata.viewerLinks) {
-            this.toolViewerCache.set(event.id, {
-              viewerLinks: metadata.viewerLinks,
-              viewerFilePath: metadata.viewerFilePath
-            });
-          }
-          if (event.status === "completed" || event.status === "done" || event.status === "failed" || event.status === "error") {
-            this.toolViewerCache.delete(event.id);
-          }
-        }
-        return { type: "tool_update", text: "", metadata };
-      }
-      case "plan":
-        return {
-          type: "plan",
-          text: "",
-          metadata: { entries: event.entries }
-        };
-      case "usage":
-        return {
-          type: "usage",
-          text: "",
-          metadata: {
-            tokensUsed: event.tokensUsed,
-            contextSize: event.contextSize,
-            cost: event.cost?.amount
-          }
-        };
-      case "session_end":
-        return { type: "session_end", text: `Done (${event.reason})` };
-      case "error":
-        return { type: "error", text: event.message };
-      case "system_message":
-        return { type: "system_message", text: event.message };
-      case "session_info_update":
-        return {
-          type: "system_message",
-          text: `Session updated: ${event.title ?? ""}`.trim(),
-          metadata: { title: event.title, updatedAt: event.updatedAt }
-        };
-      case "current_mode_update":
-        return {
-          type: "mode_change",
-          text: `Mode: ${event.modeId}`,
-          metadata: { modeId: event.modeId }
-        };
-      case "config_option_update":
-        return {
-          type: "config_update",
-          text: "Config updated",
-          metadata: { options: event.options }
-        };
-      case "model_update":
-        return {
-          type: "model_update",
-          text: `Model: ${event.modelId}`,
-          metadata: { modelId: event.modelId }
-        };
-      case "user_message_chunk":
-        return {
-          type: "user_replay",
-          text: event.content
-        };
-      case "resource_content":
-        return {
-          type: "resource",
-          text: event.name,
-          metadata: { uri: event.uri, text: event.text, blob: event.blob, mimeType: event.mimeType }
-        };
-      case "resource_link":
-        return {
-          type: "resource_link",
-          text: event.name,
-          metadata: { uri: event.uri, mimeType: event.mimeType, title: event.title, description: event.description, size: event.size }
-        };
-      default:
-        return { type: "text", text: "" };
-    }
-  }
-  /** Check if rawInput is a non-empty object (not null, not {}) */
-  isNonEmptyInput(input) {
-    return input !== null && input !== void 0 && typeof input === "object" && !Array.isArray(input) && Object.keys(input).length > 0;
-  }
-  enrichWithViewerLinks(event, metadata, sessionContext) {
-    const kind = "kind" in event ? event.kind : void 0;
-    if (!metadata.diffStats && (kind === "edit" || kind === "write")) {
-      const ri = event.rawInput;
-      if (ri) {
-        const oldStr = typeof ri.old_string === "string" ? ri.old_string : typeof ri.oldText === "string" ? ri.oldText : null;
-        const newStr = typeof ri.new_string === "string" ? ri.new_string : typeof ri.newText === "string" ? ri.newText : typeof ri.content === "string" ? ri.content : null;
-        if (oldStr !== null && newStr !== null) {
-          const stats = computeLineDiff(oldStr, newStr);
-          if (stats.added > 0 || stats.removed > 0) {
-            metadata.diffStats = stats;
-          }
-        } else if (oldStr === null && newStr !== null && kind === "write") {
-          const added = newStr.split("\n").length;
-          if (added > 0) metadata.diffStats = { added, removed: 0 };
-        }
-      }
-    }
-    if (!this.tunnelService || !sessionContext) {
-      log3.debug(
-        { hasTunnel: !!this.tunnelService, hasCtx: !!sessionContext, kind },
-        "enrichWithViewerLinks: skipping (no tunnel or session context)"
-      );
-      return;
-    }
-    const name = "name" in event ? event.name || "" : "";
-    log3.debug(
-      { name, kind, status: event.status, hasContent: !!event.content, hasRawInput: !!event.rawInput },
-      "enrichWithViewerLinks: inspecting event"
-    );
-    const fileInfo = extractFileInfo(
-      name,
-      kind,
-      event.content,
-      event.rawInput,
-      event.meta
-    );
-    if (!fileInfo) {
-      log3.debug(
-        { name, kind, hasContent: !!event.content, hasRawInput: !!event.rawInput, hasMeta: !!event.meta },
-        "enrichWithViewerLinks: extractFileInfo returned null"
-      );
-      return;
-    }
-    const publicUrl = this.tunnelService.getPublicUrl();
-    if (publicUrl.startsWith("http://localhost") || publicUrl.startsWith("http://127.0.0.1")) {
-      log3.debug({ kind, filePath: fileInfo.filePath }, "enrichWithViewerLinks: skipping (no public tunnel URL)");
-      return;
-    }
-    log3.info(
-      {
-        name,
-        kind,
-        filePath: fileInfo.filePath,
-        hasOldContent: !!fileInfo.oldContent
-      },
-      "enrichWithViewerLinks: extracted file info"
-    );
-    const store = this.tunnelService.getStore();
-    const viewerLinks = {};
-    if (fileInfo.oldContent) {
-      const id2 = store.storeDiff(
-        sessionContext.id,
-        fileInfo.filePath,
-        fileInfo.oldContent,
-        fileInfo.content,
-        sessionContext.workingDirectory
-      );
-      if (id2) viewerLinks.diff = this.tunnelService.diffUrl(id2);
-      if (!metadata.diffStats) {
-        const stats = computeLineDiff(fileInfo.oldContent, fileInfo.content);
-        if (stats.added > 0 || stats.removed > 0) {
-          metadata.diffStats = stats;
-        }
-      }
-    }
-    const id = store.storeFile(
-      sessionContext.id,
-      fileInfo.filePath,
-      fileInfo.content,
-      sessionContext.workingDirectory
-    );
-    if (id) viewerLinks.file = this.tunnelService.fileUrl(id);
-    if (Object.keys(viewerLinks).length > 0) {
-      metadata.viewerLinks = viewerLinks;
-      metadata.viewerFilePath = fileInfo.filePath;
-    }
-  }
-};
-
-// src/core/sessions/session-factory.ts
-var log4 = createChildLogger({ module: "session-factory" });
-var SessionFactory = class {
-  constructor(agentManager, sessionManager, speechServiceAccessor, eventBus) {
-    this.agentManager = agentManager;
-    this.sessionManager = sessionManager;
-    this.speechServiceAccessor = speechServiceAccessor;
-    this.eventBus = eventBus;
-  }
-  middlewareChain;
-  get speechService() {
-    return typeof this.speechServiceAccessor === "function" ? this.speechServiceAccessor() : this.speechServiceAccessor;
-  }
-  async create(params) {
-    let createParams = params;
-    if (this.middlewareChain) {
-      const payload = {
-        agentName: params.agentName,
-        workingDir: params.workingDirectory,
-        userId: "",
-        // userId is not part of SessionCreateParams — resolved upstream
-        channelId: params.channelId,
-        threadId: ""
-        // threadId is assigned after session creation
-      };
-      const result = await this.middlewareChain.execute("session:beforeCreate", payload, async (p) => p);
-      if (!result) throw new Error("Session creation blocked by middleware");
-      createParams = {
-        ...params,
-        agentName: result.agentName,
-        workingDirectory: result.workingDir,
-        channelId: result.channelId
-      };
-    }
-    const agentInstance = createParams.resumeAgentSessionId ? await this.agentManager.resume(
-      createParams.agentName,
-      createParams.workingDirectory,
-      createParams.resumeAgentSessionId
-    ) : await this.agentManager.spawn(
-      createParams.agentName,
-      createParams.workingDirectory
-    );
-    agentInstance.middlewareChain = this.middlewareChain;
-    const session = new Session({
-      id: createParams.existingSessionId,
-      channelId: createParams.channelId,
-      agentName: createParams.agentName,
-      workingDirectory: createParams.workingDirectory,
-      agentInstance,
-      speechService: this.speechService
-    });
-    session.agentSessionId = agentInstance.sessionId;
-    session.middlewareChain = this.middlewareChain;
-    if (createParams.initialName) {
-      session.name = createParams.initialName;
-    }
-    this.sessionManager.registerSession(session);
-    this.eventBus.emit("session:created", {
-      sessionId: session.id,
-      agent: session.agentName,
-      status: session.status
-    });
-    return session;
-  }
-  wireSideEffects(session, deps) {
-    session.on("agent_event", (event) => {
-      if (event.type !== "usage") return;
-      deps.eventBus.emit("usage:recorded", {
-        sessionId: session.id,
-        agentName: session.agentName,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        tokensUsed: event.tokensUsed ?? 0,
-        contextSize: event.contextSize ?? 0,
-        cost: event.cost
-      });
-    });
-    session.on("status_change", (_from, to) => {
-      if ((to === "finished" || to === "cancelled") && deps.tunnelService) {
-        deps.tunnelService.stopBySession(session.id).then((stopped) => {
-          for (const entry of stopped) {
-            deps.notificationManager.notifyAll({
-              sessionId: session.id,
-              sessionName: session.name,
-              type: "completed",
-              summary: `Tunnel stopped: port ${entry.port}${entry.label ? ` (${entry.label})` : ""} \u2014 session ended`
-            }).catch(() => {
-            });
-          }
-        }).catch(() => {
-        });
-      }
-    });
-  }
-};
-
-// src/core/event-bus.ts
-var EventBus = class extends TypedEmitter {
-};
-
-// src/core/core.ts
-import path6 from "path";
-import os2 from "os";
-
-// src/core/sessions/session-store.ts
-import fs4 from "fs";
-import path3 from "path";
-var log5 = createChildLogger({ module: "session-store" });
-var DEBOUNCE_MS = 2e3;
-var JsonFileSessionStore = class {
-  records = /* @__PURE__ */ new Map();
-  filePath;
-  ttlDays;
-  debounceTimer = null;
-  cleanupInterval = null;
-  flushHandler = null;
-  constructor(filePath, ttlDays) {
-    this.filePath = filePath;
-    this.ttlDays = ttlDays;
-    this.load();
-    this.cleanup();
-    this.cleanupInterval = setInterval(
-      () => this.cleanup(),
-      24 * 60 * 60 * 1e3
-    );
-    this.flushHandler = () => this.flushSync();
-    process.on("SIGTERM", this.flushHandler);
-    process.on("SIGINT", this.flushHandler);
-    process.on("exit", this.flushHandler);
-  }
-  async save(record) {
-    this.records.set(record.sessionId, { ...record });
-    this.scheduleDiskWrite();
-  }
-  get(sessionId) {
-    return this.records.get(sessionId);
-  }
-  findByPlatform(channelId, predicate) {
-    for (const record of this.records.values()) {
-      if (record.channelId === channelId && predicate(record.platform)) {
-        return record;
-      }
-    }
-    return void 0;
-  }
-  findByAgentSessionId(agentSessionId) {
-    for (const record of this.records.values()) {
-      if (record.agentSessionId === agentSessionId || record.originalAgentSessionId === agentSessionId) {
-        return record;
-      }
-      if (record.agentSwitchHistory?.some((e) => e.agentSessionId === agentSessionId)) {
-        return record;
-      }
-    }
-    return void 0;
-  }
-  list(channelId) {
-    const all = [...this.records.values()];
-    if (channelId) return all.filter((r) => r.channelId === channelId);
-    return all;
-  }
-  async remove(sessionId) {
-    this.records.delete(sessionId);
-    this.scheduleDiskWrite();
-  }
-  flushSync() {
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-      this.debounceTimer = null;
-    }
-    const data = {
-      version: 1,
-      sessions: Object.fromEntries(this.records)
-    };
-    const dir = path3.dirname(this.filePath);
-    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
-    fs4.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
-  }
-  destroy() {
-    if (this.debounceTimer) clearTimeout(this.debounceTimer);
-    if (this.cleanupInterval) clearInterval(this.cleanupInterval);
-    if (this.flushHandler) {
-      process.removeListener("SIGTERM", this.flushHandler);
-      process.removeListener("SIGINT", this.flushHandler);
-      process.removeListener("exit", this.flushHandler);
-      this.flushHandler = null;
-    }
-  }
-  load() {
-    if (!fs4.existsSync(this.filePath)) return;
-    try {
-      const raw = JSON.parse(
-        fs4.readFileSync(this.filePath, "utf-8")
-      );
-      if (raw.version !== 1) {
-        log5.warn(
-          { version: raw.version },
-          "Unknown session store version, skipping load"
-        );
-        return;
-      }
-      for (const [id, record] of Object.entries(raw.sessions)) {
-        this.records.set(id, record);
-      }
-      log5.debug({ count: this.records.size }, "Loaded session records");
-    } catch (err) {
-      log5.error({ err }, "Failed to load session store, backing up corrupt file");
-      try {
-        fs4.renameSync(this.filePath, `${this.filePath}.bak`);
-      } catch {
-      }
-    }
-  }
-  cleanup() {
-    const cutoff = Date.now() - this.ttlDays * 24 * 60 * 60 * 1e3;
-    let removed = 0;
-    for (const [id, record] of this.records) {
-      if (record.status === "active" || record.status === "initializing")
-        continue;
-      const lastActive = new Date(record.lastActiveAt).getTime();
-      if (lastActive < cutoff) {
-        this.records.delete(id);
-        removed++;
-      }
-    }
-    if (removed > 0) {
-      log5.info({ removed }, "Cleaned up expired session records");
-      this.scheduleDiskWrite();
-    }
-  }
-  scheduleDiskWrite() {
-    if (this.debounceTimer) clearTimeout(this.debounceTimer);
-    this.debounceTimer = setTimeout(() => {
-      this.flushSync();
-    }, DEBOUNCE_MS);
-  }
-};
-
-// src/core/plugin/plugin-loader.ts
-import { createHash } from "crypto";
-import { readFileSync } from "fs";
-function resolveLoadOrder(plugins) {
-  const overrideTargets = /* @__PURE__ */ new Set();
-  for (const p of plugins) {
-    if (p.overrides) {
-      overrideTargets.add(p.overrides);
-    }
-  }
-  let remaining = plugins.filter((p) => !overrideTargets.has(p.name));
-  const byName = /* @__PURE__ */ new Map();
-  for (const p of remaining) {
-    byName.set(p.name, p);
-  }
-  const skipped = /* @__PURE__ */ new Set();
-  function cascadeSkip(name) {
-    if (skipped.has(name)) return;
-    skipped.add(name);
-    for (const p of remaining) {
-      if (p.pluginDependencies && name in p.pluginDependencies) {
-        cascadeSkip(p.name);
-      }
-    }
-  }
-  for (const p of remaining) {
-    if (p.pluginDependencies) {
-      for (const dep of Object.keys(p.pluginDependencies)) {
-        if (!byName.has(dep)) {
-          cascadeSkip(p.name);
-        }
-      }
-    }
-  }
-  remaining = remaining.filter((p) => !skipped.has(p.name));
-  byName.clear();
-  for (const p of remaining) {
-    byName.set(p.name, p);
-  }
-  const visited = /* @__PURE__ */ new Set();
-  const inStack = /* @__PURE__ */ new Set();
-  const order = [];
-  function visit(name) {
-    if (visited.has(name)) return;
-    if (inStack.has(name)) {
-      throw new Error(`Circular dependency detected: ${name}`);
-    }
-    inStack.add(name);
-    const plugin = byName.get(name);
-    if (plugin.pluginDependencies) {
-      for (const dep of Object.keys(plugin.pluginDependencies)) {
-        visit(dep);
-      }
-    }
-    inStack.delete(name);
-    visited.add(name);
-    order.push(plugin);
-  }
-  for (const p of remaining) {
-    visit(p.name);
-  }
-  return order;
-}
-
-// src/core/plugin/service-registry.ts
-var ServiceRegistry = class {
-  services = /* @__PURE__ */ new Map();
-  register(name, implementation, pluginName) {
-    if (this.services.has(name)) {
-      const existing = this.services.get(name);
-      throw new Error(`Service '${name}' already registered by ${existing.pluginName}. Plugin ${pluginName} cannot register it without override.`);
-    }
-    this.services.set(name, { implementation, pluginName });
-  }
-  registerOverride(name, implementation, pluginName) {
-    this.services.set(name, { implementation, pluginName });
-  }
-  get(name) {
-    return this.services.get(name)?.implementation;
-  }
-  has(name) {
-    return this.services.has(name);
-  }
-  list() {
-    return [...this.services.entries()].map(([name, { pluginName }]) => ({ name, pluginName }));
-  }
-  unregister(name) {
-    this.services.delete(name);
-  }
-  unregisterByPlugin(pluginName) {
-    for (const [name, entry] of this.services) {
-      if (entry.pluginName === pluginName) {
-        this.services.delete(name);
-      }
-    }
-  }
-};
-
-// src/core/plugin/middleware-chain.ts
-var MIDDLEWARE_TIMEOUT_MS = 5e3;
-var MiddlewareChain = class {
-  chains = /* @__PURE__ */ new Map();
-  errorHandler;
-  errorTracker;
-  add(hook, pluginName, opts) {
-    const entry = {
-      pluginName,
-      priority: opts.priority ?? 100,
-      handler: opts.handler
-    };
-    const existing = this.chains.get(hook);
-    if (existing) {
-      existing.push(entry);
-      existing.sort((a, b) => a.priority - b.priority);
-    } else {
-      this.chains.set(hook, [entry]);
-    }
-  }
-  async execute(hook, payload, coreHandler) {
-    const handlers = this.chains.get(hook);
-    if (!handlers || handlers.length === 0) {
-      return coreHandler(payload);
-    }
-    const sorted = handlers;
-    let cachedResult = void 0;
-    const buildNext = (index, currentPayload) => {
-      return async () => {
-        if (cachedResult !== void 0) {
-          return cachedResult.value;
-        }
-        if (index >= sorted.length) {
-          const result = await coreHandler(currentPayload);
-          cachedResult = { value: result };
-          return result;
-        }
-        const entry = sorted[index];
-        if (this.errorTracker?.isDisabled(entry.pluginName)) {
-          const skipFn = buildNext(index + 1, currentPayload);
-          return skipFn();
-        }
-        const nextFn = buildNext(index + 1, currentPayload);
-        let nextCalled = false;
-        let nextResult = null;
-        const wrappedNext = async (newPayload) => {
-          if (!nextCalled) {
-            nextCalled = true;
-            const payloadForNext = newPayload !== void 0 ? newPayload : currentPayload;
-            const newNextFn = buildNext(index + 1, payloadForNext);
-            nextResult = await newNextFn();
-          }
-          return nextResult;
-        };
-        let handlerResult;
-        let timeoutTimer;
-        try {
-          const timeoutPromise = new Promise((_, reject) => {
-            timeoutTimer = setTimeout(
-              () => reject(new Error(`Middleware timeout: ${entry.pluginName} on hook ${hook}`)),
-              MIDDLEWARE_TIMEOUT_MS
-            );
-            if (typeof timeoutTimer === "object" && timeoutTimer !== null && "unref" in timeoutTimer) {
-              ;
-              timeoutTimer.unref();
-            }
-          });
-          handlerResult = await Promise.race([
-            entry.handler(currentPayload, wrappedNext),
-            timeoutPromise
-          ]);
-        } catch (err) {
-          if (this.errorHandler) {
-            this.errorHandler(entry.pluginName, err instanceof Error ? err : new Error(String(err)));
-          }
-          this.errorTracker?.increment(entry.pluginName);
-          return nextFn();
-        } finally {
-          clearTimeout(timeoutTimer);
-        }
-        if (handlerResult === null) {
-          return null;
-        }
-        return handlerResult;
-      };
-    };
-    const start = buildNext(0, payload);
-    return start();
-  }
-  removeAll(pluginName) {
-    for (const [hook, handlers] of this.chains.entries()) {
-      const filtered = handlers.filter((h) => h.pluginName !== pluginName);
-      if (filtered.length === 0) {
-        this.chains.delete(hook);
-      } else {
-        this.chains.set(hook, filtered);
-      }
-    }
-  }
-  setErrorHandler(fn) {
-    this.errorHandler = fn;
-  }
-  setErrorTracker(tracker) {
-    this.errorTracker = tracker;
-  }
-};
-
-// src/core/plugin/error-tracker.ts
-var ErrorTracker = class {
-  errors = /* @__PURE__ */ new Map();
-  disabled = /* @__PURE__ */ new Set();
-  exempt = /* @__PURE__ */ new Set();
-  config;
-  onDisabled;
-  constructor(config) {
-    this.config = { maxErrors: config?.maxErrors ?? 10, windowMs: config?.windowMs ?? 36e5 };
-  }
-  increment(pluginName) {
-    if (this.exempt.has(pluginName)) return;
-    const now = Date.now();
-    const entry = this.errors.get(pluginName);
-    if (!entry || now - entry.windowStart >= this.config.windowMs) {
-      this.errors.set(pluginName, { count: 1, windowStart: now });
-    } else {
-      entry.count += 1;
-    }
-    const current = this.errors.get(pluginName);
-    if (current.count >= this.config.maxErrors && !this.disabled.has(pluginName)) {
-      this.disabled.add(pluginName);
-      const reason = `Error budget exceeded: ${current.count} errors within ${this.config.windowMs}ms window`;
-      this.onDisabled?.(pluginName, reason);
-    }
-  }
-  isDisabled(pluginName) {
-    return this.disabled.has(pluginName);
-  }
-  reset(pluginName) {
-    this.disabled.delete(pluginName);
-    this.errors.delete(pluginName);
-  }
-  setExempt(pluginName) {
-    this.exempt.add(pluginName);
-  }
-};
-
-// src/core/plugin/plugin-context.ts
-import path5 from "path";
-import os from "os";
-
-// src/core/plugin/plugin-storage.ts
-import fs5 from "fs";
-import path4 from "path";
-var PluginStorageImpl = class {
-  kvPath;
-  dataDir;
-  writeChain = Promise.resolve();
-  constructor(baseDir) {
-    this.dataDir = path4.join(baseDir, "data");
-    this.kvPath = path4.join(baseDir, "kv.json");
-    fs5.mkdirSync(baseDir, { recursive: true });
-  }
-  readKv() {
-    try {
-      const raw = fs5.readFileSync(this.kvPath, "utf-8");
-      return JSON.parse(raw);
-    } catch {
-      return {};
-    }
-  }
-  writeKv(data) {
-    fs5.writeFileSync(this.kvPath, JSON.stringify(data), "utf-8");
-  }
-  async get(key) {
-    const data = this.readKv();
-    return key in data ? data[key] : void 0;
-  }
-  async set(key, value) {
-    this.writeChain = this.writeChain.then(() => {
-      const data = this.readKv();
-      data[key] = value;
-      this.writeKv(data);
-    });
-    return this.writeChain;
-  }
-  async delete(key) {
-    this.writeChain = this.writeChain.then(() => {
-      const data = this.readKv();
-      delete data[key];
-      this.writeKv(data);
-    });
-    return this.writeChain;
-  }
-  async list() {
-    return Object.keys(this.readKv());
-  }
-  getDataDir() {
-    fs5.mkdirSync(this.dataDir, { recursive: true });
-    return this.dataDir;
-  }
-};
-
-// src/core/plugin/plugin-context.ts
-function requirePermission(permissions, required, action) {
-  if (!permissions.includes(required)) {
-    throw new Error(`Plugin does not have '${required}' permission required for ${action}`);
-  }
-}
-function createPluginContext(opts) {
-  const {
-    pluginName,
-    pluginConfig,
-    permissions,
-    serviceRegistry,
-    middlewareChain,
-    eventBus,
-    storagePath,
-    sessions,
-    config,
-    core
-  } = opts;
-  const instanceRoot = opts.instanceRoot ?? path5.join(os.homedir(), ".openacp");
-  const registeredListeners = [];
-  const registeredCommands = [];
-  const noopLog = {
-    trace() {
-    },
-    debug() {
-    },
-    info() {
-    },
-    warn() {
-    },
-    error() {
-    },
-    fatal() {
-    },
-    child() {
-      return noopLog;
-    }
-  };
-  const baseLog = opts.log ?? noopLog;
-  const log7 = typeof baseLog.child === "function" ? baseLog.child({ plugin: pluginName }) : baseLog;
-  const storageImpl = new PluginStorageImpl(storagePath);
-  const storage = {
-    async get(key) {
-      requirePermission(permissions, "storage:read", "storage.get");
-      return storageImpl.get(key);
-    },
-    async set(key, value) {
-      requirePermission(permissions, "storage:write", "storage.set");
-      return storageImpl.set(key, value);
-    },
-    async delete(key) {
-      requirePermission(permissions, "storage:write", "storage.delete");
-      return storageImpl.delete(key);
-    },
-    async list() {
-      requirePermission(permissions, "storage:read", "storage.list");
-      return storageImpl.list();
-    },
-    getDataDir() {
-      requirePermission(permissions, "storage:read", "storage.getDataDir");
-      return storageImpl.getDataDir();
-    }
-  };
-  const ctx = {
-    pluginName,
-    pluginConfig,
-    log: log7,
-    storage,
-    on(event, handler) {
-      requirePermission(permissions, "events:read", "on()");
-      eventBus.on(event, handler);
-      registeredListeners.push({ event, handler });
-    },
-    off(event, handler) {
-      requirePermission(permissions, "events:read", "off()");
-      eventBus.off(event, handler);
-      const idx = registeredListeners.findIndex((l) => l.event === event && l.handler === handler);
-      if (idx >= 0) registeredListeners.splice(idx, 1);
-    },
-    emit(event, payload) {
-      requirePermission(permissions, "events:emit", "emit()");
-      eventBus.emit(event, payload);
-    },
-    registerMiddleware(hook, middlewareOpts) {
-      requirePermission(permissions, "middleware:register", "registerMiddleware()");
-      middlewareChain.add(hook, pluginName, middlewareOpts);
-    },
-    registerService(name, implementation) {
-      requirePermission(permissions, "services:register", "registerService()");
-      serviceRegistry.register(name, implementation, pluginName);
-    },
-    getService(name) {
-      requirePermission(permissions, "services:use", "getService()");
-      return serviceRegistry.get(name);
-    },
-    registerCommand(def) {
-      requirePermission(permissions, "commands:register", "registerCommand()");
-      registeredCommands.push(def);
-      const registry = serviceRegistry.get("command-registry");
-      if (registry && typeof registry.register === "function") {
-        registry.register(def, pluginName);
-        log7.debug(`Command '/${def.name}' registered`);
-      }
-    },
-    async sendMessage(_sessionId, _content) {
-      requirePermission(permissions, "services:use", "sendMessage()");
-      const router = serviceRegistry.get("message-router");
-      if (router) {
-        await router.send(_sessionId, _content);
-      }
-    },
-    get sessions() {
-      requirePermission(permissions, "kernel:access", "sessions");
-      return sessions;
-    },
-    get config() {
-      requirePermission(permissions, "kernel:access", "config");
-      return config;
-    },
-    get eventBus() {
-      requirePermission(permissions, "kernel:access", "eventBus");
-      return eventBus;
-    },
-    get core() {
-      requirePermission(permissions, "kernel:access", "core");
-      return core;
-    },
-    instanceRoot,
-    cleanup() {
-      for (const { event, handler } of registeredListeners) {
-        eventBus.off(event, handler);
-      }
-      registeredListeners.length = 0;
-      middlewareChain.removeAll(pluginName);
-      serviceRegistry.unregisterByPlugin(pluginName);
-      const cmdRegistry = serviceRegistry.get("command-registry");
-      if (cmdRegistry && typeof cmdRegistry.unregisterByPlugin === "function") {
-        cmdRegistry.unregisterByPlugin(pluginName);
-      }
-      registeredCommands.length = 0;
-    }
-  };
-  return ctx;
-}
-
-// src/core/plugin/lifecycle-manager.ts
-var SETUP_TIMEOUT_MS = 3e4;
-var TEARDOWN_TIMEOUT_MS = 1e4;
-function withTimeout(promise, ms, label) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(`Timeout: ${label} exceeded ${ms}ms`)), ms);
-    if (typeof timer === "object" && timer !== null && "unref" in timer) {
-      ;
-      timer.unref();
-    }
-    promise.then(resolve, reject).finally(() => clearTimeout(timer));
-  });
-}
-function resolvePluginConfig(pluginName, configManager) {
-  try {
-    const allConfig = configManager?.get?.() ?? {};
-    const pluginEntry = allConfig.plugins?.builtin?.[pluginName];
-    if (pluginEntry?.config && Object.keys(pluginEntry.config).length > 0) {
-      return pluginEntry.config;
-    }
-    const legacyMap = {
-      "@openacp/security": "security",
-      "@openacp/speech": "speech",
-      "@openacp/tunnel": "tunnel",
-      "@openacp/usage": "usage",
-      "@openacp/file-service": "files",
-      "@openacp/api-server": "api",
-      "@openacp/telegram": "channels.telegram",
-      "@openacp/discord": "channels.discord",
-      "@openacp/adapter-discord": "channels.discord",
-      "@openacp/plugin-discord": "channels.discord",
-      // alias for old name
-      "@openacp/slack": "channels.slack"
-    };
-    const legacyKey = legacyMap[pluginName];
-    if (legacyKey) {
-      const parts = legacyKey.split(".");
-      let obj = allConfig;
-      for (const p of parts) obj = obj?.[p];
-      if (obj && typeof obj === "object") return { ...obj };
-    }
-  } catch {
-  }
-  return {};
-}
-var LifecycleManager = class {
-  serviceRegistry;
-  middlewareChain;
-  errorTracker;
-  eventBus;
-  storagePath;
-  sessions;
-  config;
-  core;
-  log;
-  settingsManager;
-  pluginRegistry;
-  instanceRoot;
-  contexts = /* @__PURE__ */ new Map();
-  loadOrder = [];
-  _loaded = /* @__PURE__ */ new Set();
-  _failed = /* @__PURE__ */ new Set();
-  get loadedPlugins() {
-    return [...this._loaded];
-  }
-  get failedPlugins() {
-    return [...this._failed];
-  }
-  get registry() {
-    return this.pluginRegistry;
-  }
-  constructor(opts) {
-    this.serviceRegistry = opts?.serviceRegistry ?? new ServiceRegistry();
-    this.middlewareChain = opts?.middlewareChain ?? new MiddlewareChain();
-    this.errorTracker = opts?.errorTracker ?? new ErrorTracker();
-    this.eventBus = opts?.eventBus ?? {
-      on() {
-      },
-      off() {
-      },
-      emit() {
-      }
-    };
-    this.storagePath = opts?.storagePath ?? "/tmp/openacp-plugins";
-    this.sessions = opts?.sessions ?? {};
-    this.config = opts?.config ?? {};
-    this.core = opts?.core;
-    this.log = opts?.log;
-    this.settingsManager = opts?.settingsManager;
-    this.pluginRegistry = opts?.pluginRegistry;
-    this.instanceRoot = opts?.instanceRoot;
-  }
-  getPluginLogger(pluginName) {
-    if (this.log && typeof this.log.child === "function") {
-      return this.log.child({ plugin: pluginName });
-    }
-    return this.log ?? { trace() {
-    }, debug() {
-    }, info() {
-    }, warn() {
-    }, error() {
-    }, fatal() {
-    }, child() {
-      return this;
-    } };
-  }
-  async boot(plugins) {
-    const newNames = new Set(plugins.map((p) => p.name));
-    const allForResolution = [...this.loadOrder.filter((p) => !newNames.has(p.name)), ...plugins];
-    let sorted;
-    try {
-      sorted = resolveLoadOrder(allForResolution);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      this.log?.error(`Plugin dependency resolution failed: ${error.message}`);
-      for (const p of plugins) {
-        this._failed.add(p.name);
-      }
-      return;
-    }
-    sorted = sorted.filter((p) => newNames.has(p.name));
-    for (const p of sorted) {
-      if (!this.loadOrder.some((existing) => existing.name === p.name)) {
-        this.loadOrder.push(p);
-      } else {
-        const idx = this.loadOrder.findIndex((existing) => existing.name === p.name);
-        this.loadOrder[idx] = p;
-      }
-    }
-    for (const plugin of sorted) {
-      if (plugin.pluginDependencies) {
-        const depFailed = Object.keys(plugin.pluginDependencies).some(
-          (dep) => this._failed.has(dep)
-        );
-        if (depFailed) {
-          this._failed.add(plugin.name);
-          continue;
-        }
-      }
-      const registryEntry = this.pluginRegistry?.get(plugin.name);
-      if (registryEntry && registryEntry.enabled === false) {
-        this.eventBus?.emit("plugin:disabled", { name: plugin.name });
-        continue;
-      }
-      if (registryEntry && plugin.migrate && registryEntry.version !== plugin.version && this.settingsManager) {
-        try {
-          const oldSettings = await this.settingsManager.loadSettings(plugin.name);
-          const pluginLog = this.getPluginLogger(plugin.name);
-          const migrateCtx = {
-            pluginName: plugin.name,
-            settings: this.settingsManager.createAPI(plugin.name),
-            log: pluginLog
-          };
-          const newSettings = await withTimeout(
-            plugin.migrate(migrateCtx, oldSettings, registryEntry.version),
-            SETUP_TIMEOUT_MS,
-            `${plugin.name}.migrate()`
-          );
-          if (newSettings && typeof newSettings === "object") {
-            await migrateCtx.settings.setAll(newSettings);
-          }
-          this.pluginRegistry.updateVersion(plugin.name, plugin.version);
-          await this.pluginRegistry.save();
-        } catch (err) {
-          this.getPluginLogger(plugin.name).warn(`Migration failed, continuing with old settings: ${err}`);
-        }
-      }
-      let pluginConfig;
-      if (this.settingsManager) {
-        pluginConfig = await this.settingsManager.loadSettings(plugin.name);
-        const settingsPath = this.settingsManager.getSettingsPath(plugin.name);
-        this.getPluginLogger(plugin.name).debug(`Settings loaded from ${settingsPath}: ${Object.keys(pluginConfig).length} keys`);
-        if (Object.keys(pluginConfig).length === 0) {
-          pluginConfig = resolvePluginConfig(plugin.name, this.config);
-        }
-      } else {
-        pluginConfig = resolvePluginConfig(plugin.name, this.config);
-        this.getPluginLogger(plugin.name).debug("No settingsManager, using legacy config");
-      }
-      if (plugin.settingsSchema && this.settingsManager) {
-        const validation = this.settingsManager.validateSettings(plugin.name, pluginConfig, plugin.settingsSchema);
-        if (!validation.valid) {
-          this._failed.add(plugin.name);
-          this.getPluginLogger(plugin.name).error(`Settings validation failed: ${validation.errors?.join("; ")}`);
-          this.eventBus?.emit("plugin:failed", { name: plugin.name, error: `Settings validation failed: ${validation.errors?.join("; ")}` });
-          continue;
-        }
-      }
-      const ctx = createPluginContext({
-        pluginName: plugin.name,
-        pluginConfig,
-        permissions: plugin.permissions ?? [],
-        serviceRegistry: this.serviceRegistry,
-        middlewareChain: this.middlewareChain,
-        errorTracker: this.errorTracker,
-        eventBus: this.eventBus,
-        storagePath: `${this.storagePath}/${plugin.name}`,
-        sessions: this.sessions,
-        config: this.config,
-        core: this.core,
-        log: this.log,
-        instanceRoot: this.instanceRoot
-      });
-      try {
-        await withTimeout(plugin.setup(ctx), SETUP_TIMEOUT_MS, `${plugin.name}.setup()`);
-        this.contexts.set(plugin.name, ctx);
-        this._loaded.add(plugin.name);
-        this.eventBus?.emit("plugin:loaded", { name: plugin.name, version: plugin.version });
-      } catch (err) {
-        this._failed.add(plugin.name);
-        ctx.cleanup();
-        this.getPluginLogger(plugin.name).error(`setup() failed: ${err}`);
-        this.eventBus?.emit("plugin:failed", { name: plugin.name, error: String(err) });
-      }
-    }
-  }
-  async unloadPlugin(name) {
-    if (!this._loaded.has(name)) return;
-    const plugin = this.loadOrder.find((p) => p.name === name);
-    if (plugin?.teardown) {
-      try {
-        await withTimeout(plugin.teardown(), TEARDOWN_TIMEOUT_MS, `${name}.teardown()`);
-      } catch {
-      }
-    }
-    const ctx = this.contexts.get(name);
-    if (ctx) {
-      ctx.cleanup();
-      this.contexts.delete(name);
-    }
-    this._loaded.delete(name);
-    this._failed.delete(name);
-    this.loadOrder = this.loadOrder.filter((p) => p.name !== name);
-    this.eventBus?.emit("plugin:unloaded", { name });
-  }
-  async shutdown() {
-    const reversed = [...this.loadOrder].reverse();
-    for (const plugin of reversed) {
-      if (!this._loaded.has(plugin.name)) continue;
-      if (plugin.teardown) {
-        try {
-          await withTimeout(plugin.teardown(), TEARDOWN_TIMEOUT_MS, `${plugin.name}.teardown()`);
-        } catch {
-        }
-      }
-      const ctx = this.contexts.get(plugin.name);
-      if (ctx) {
-        ctx.cleanup();
-        this.contexts.delete(plugin.name);
-      }
-      this.eventBus?.emit("plugin:unloaded", { name: plugin.name });
-    }
-    this._loaded.clear();
-    this.loadOrder = [];
-  }
-};
-
-// src/core/core.ts
-var log6 = createChildLogger({ module: "core" });
-var OpenACPCore = class {
-  configManager;
-  agentCatalog;
-  agentManager;
-  sessionManager;
-  messageTransformer;
-  adapters = /* @__PURE__ */ new Map();
-  /** sessionId → SessionBridge — tracks active bridges for disconnect/reconnect during agent switch */
-  bridges = /* @__PURE__ */ new Map();
-  /** Set by main.ts — triggers graceful shutdown with restart exit code */
-  requestRestart = null;
-  _tunnelService;
-  sessionStore = null;
-  resumeLocks = /* @__PURE__ */ new Map();
-  switchingLocks = /* @__PURE__ */ new Set();
-  eventBus;
-  sessionFactory;
-  lifecycleManager;
-  instanceContext;
-  // --- Lazy getters: resolve from ServiceRegistry (populated by plugins during boot) ---
-  getService(name) {
-    const svc = this.lifecycleManager.serviceRegistry.get(name);
-    if (!svc) throw new Error(`Service '${name}' not registered \u2014 is the ${name} plugin loaded?`);
-    return svc;
-  }
-  get securityGuard() {
-    return this.getService("security");
-  }
-  get notificationManager() {
-    return this.getService("notifications");
-  }
-  get fileService() {
-    return this.getService("file-service");
-  }
-  get speechService() {
-    return this.getService("speech");
-  }
-  get contextManager() {
-    return this.getService("context");
-  }
-  constructor(configManager, ctx) {
-    this.configManager = configManager;
-    this.instanceContext = ctx;
-    const config = configManager.get();
-    this.agentCatalog = new AgentCatalog();
-    this.agentCatalog.load();
-    this.agentManager = new AgentManager(this.agentCatalog);
-    const storePath = ctx?.paths.sessions ?? path6.join(os2.homedir(), ".openacp", "sessions.json");
-    this.sessionStore = new JsonFileSessionStore(
-      storePath,
-      config.sessionStore.ttlDays
-    );
-    this.sessionManager = new SessionManager(this.sessionStore);
-    this.messageTransformer = new MessageTransformer();
-    this.eventBus = new EventBus();
-    this.sessionManager.setEventBus(this.eventBus);
-    this.sessionFactory = new SessionFactory(
-      this.agentManager,
-      this.sessionManager,
-      () => this.speechService,
-      this.eventBus
-    );
-    this.lifecycleManager = new LifecycleManager({
-      serviceRegistry: new ServiceRegistry(),
-      middlewareChain: new MiddlewareChain(),
-      errorTracker: new ErrorTracker(),
-      eventBus: this.eventBus,
-      sessions: this.sessionManager,
-      config: this.configManager,
-      core: this,
-      storagePath: ctx?.paths.pluginsData ?? path6.join(os2.homedir(), ".openacp", "plugins", "data"),
-      log: createChildLogger({ module: "plugin" })
-    });
-    this.sessionFactory.middlewareChain = this.lifecycleManager.middlewareChain;
-    this.sessionManager.middlewareChain = this.lifecycleManager.middlewareChain;
-    this.configManager.on(
-      "config:changed",
-      async ({ path: configPath, value }) => {
-        if (configPath === "logging.level" && typeof value === "string") {
-          const { setLogLevel } = await import("./log-YZ243M5G.js");
-          setLogLevel(value);
-          log6.info({ level: value }, "Log level changed at runtime");
-        }
-        if (configPath.startsWith("speech.")) {
-          const speechSvc = this.speechService;
-          if (speechSvc) {
-            const newConfig = this.configManager.get();
-            const newSpeechConfig = newConfig.speech ?? {
-              stt: { provider: null, providers: {} },
-              tts: { provider: null, providers: {} }
-            };
-            speechSvc.refreshProviders(newSpeechConfig);
-            log6.info("Speech service config updated at runtime");
-          }
-        }
-      }
-    );
-  }
-  get tunnelService() {
-    return this._tunnelService;
-  }
-  set tunnelService(service) {
-    this._tunnelService = service;
-    this.messageTransformer.tunnelService = service;
-  }
-  registerAdapter(name, adapter) {
-    this.adapters.set(name, adapter);
-  }
-  async start() {
-    this.agentCatalog.refreshRegistryIfStale().catch((err) => {
-      log6.warn({ err }, "Background registry refresh failed");
-    });
-    for (const adapter of this.adapters.values()) {
-      await adapter.start();
-    }
-  }
-  async stop() {
-    try {
-      const nm = this.lifecycleManager.serviceRegistry.get("notifications");
-      if (nm) {
-        await nm.notifyAll({
-          sessionId: "system",
-          type: "error",
-          summary: "OpenACP is shutting down"
-        });
-      }
-    } catch {
-    }
-    await this.sessionManager.shutdownAll();
-    for (const adapter of this.adapters.values()) {
-      await adapter.stop();
-    }
-  }
-  // --- Archive ---
-  async archiveSession(sessionId) {
-    const session = this.sessionManager.getSession(sessionId);
-    if (!session) return { ok: false, error: "Session not found (must be in memory)" };
-    if (session.status !== "active" && session.status !== "cancelled" && session.status !== "error") {
-      return { ok: false, error: `Cannot archive session in '${session.status}' state` };
-    }
-    const adapter = this.adapters.get(session.channelId);
-    if (!adapter) return { ok: false, error: "Adapter not found for session" };
-    if (!adapter.archiveSessionTopic) return { ok: false, error: "Adapter does not support topic archiving" };
-    try {
-      const newThreadId = await adapter.archiveSessionTopic(session.id);
-      session.threadId = newThreadId;
-      try {
-        const platform = {};
-        if (session.channelId === "telegram") {
-          platform.topicId = Number(newThreadId);
-        } else {
-          platform.threadId = newThreadId;
-        }
-        await this.sessionManager.patchRecord(sessionId, { platform });
-      } catch (patchErr) {
-        log6.warn({ err: patchErr, sessionId }, "Failed to update session record after archive \u2014 session will work but may not survive restart");
-      }
-      return { ok: true, newThreadId };
-    } catch (err) {
-      session.archiving = false;
-      return { ok: false, error: err.message };
-    }
-  }
-  // --- Message Routing ---
-  async handleMessage(message) {
-    log6.debug(
-      {
-        channelId: message.channelId,
-        threadId: message.threadId,
-        userId: message.userId
-      },
-      "Incoming message"
-    );
-    if (this.lifecycleManager?.middlewareChain) {
-      const result = await this.lifecycleManager.middlewareChain.execute(
-        "message:incoming",
-        message,
-        async (msg) => msg
-      );
-      if (!result) return;
-      message = result;
-    }
-    const access = this.securityGuard.checkAccess(message);
-    if (!access.allowed) {
-      log6.warn({ userId: message.userId, reason: access.reason }, "Access denied");
-      if (access.reason.includes("Session limit")) {
-        const adapter = this.adapters.get(message.channelId);
-        if (adapter) {
-          await adapter.sendMessage(message.threadId, {
-            type: "error",
-            text: `\u26A0\uFE0F ${access.reason}. Please cancel existing sessions with /cancel before starting new ones.`
-          });
-        }
-      }
-      return;
-    }
-    let session = this.sessionManager.getSessionByThread(
-      message.channelId,
-      message.threadId
-    );
-    if (!session) {
-      session = await this.lazyResume(message) ?? void 0;
-    }
-    if (!session) {
-      log6.warn(
-        { channelId: message.channelId, threadId: message.threadId },
-        "No session found for thread (in-memory miss + lazy resume returned null)"
-      );
-      return;
-    }
-    this.sessionManager.patchRecord(session.id, {
-      lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    await session.enqueuePrompt(message.text, message.attachments);
-  }
-  // --- Unified Session Creation Pipeline ---
-  async createSession(params) {
-    const session = await this.sessionFactory.create(params);
-    if (params.threadId) {
-      session.threadId = params.threadId;
-    }
-    const adapter = this.adapters.get(params.channelId);
-    if (params.createThread && adapter) {
-      const threadId = await adapter.createSessionThread(
-        session.id,
-        params.initialName ?? `\u{1F504} ${params.agentName} \u2014 New Session`
-      );
-      session.threadId = threadId;
-    }
-    if (adapter) {
-      const bridge = this.createBridge(session, adapter);
-      bridge.connect();
-    }
-    this.sessionFactory.wireSideEffects(session, {
-      eventBus: this.eventBus,
-      notificationManager: this.notificationManager,
-      tunnelService: this._tunnelService
-    });
-    const existingRecord = this.sessionStore?.get(session.id);
-    const platform = {
-      ...existingRecord?.platform ?? {}
-    };
-    if (session.threadId) {
-      if (params.channelId === "telegram") {
-        platform.topicId = Number(session.threadId);
-      } else {
-        platform.threadId = session.threadId;
-      }
-    }
-    await this.sessionManager.patchRecord(session.id, {
-      sessionId: session.id,
-      agentSessionId: session.agentSessionId,
-      agentName: params.agentName,
-      workingDir: params.workingDirectory,
-      channelId: params.channelId,
-      status: session.status,
-      createdAt: session.createdAt.toISOString(),
-      lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
-      name: session.name,
-      platform,
-      firstAgent: session.firstAgent,
-      currentPromptCount: session.promptCount,
-      agentSwitchHistory: session.agentSwitchHistory
-    });
-    log6.info(
-      { sessionId: session.id, agentName: params.agentName },
-      "Session created via pipeline"
-    );
-    return session;
-  }
-  async handleNewSession(channelId, agentName, workspacePath, options) {
-    const config = this.configManager.get();
-    const resolvedAgent = agentName || config.defaultAgent;
-    log6.info({ channelId, agentName: resolvedAgent }, "New session request");
-    const agentDef = this.agentCatalog.resolve(resolvedAgent);
-    const resolvedWorkspace = this.configManager.resolveWorkspace(
-      workspacePath || agentDef?.workingDirectory
-    );
-    return this.createSession({
-      channelId,
-      agentName: resolvedAgent,
-      workingDirectory: resolvedWorkspace,
-      createThread: options?.createThread
-    });
-  }
-  async adoptSession(agentName, agentSessionId, cwd, channelId) {
-    const caps = getAgentCapabilities(agentName);
-    if (!caps.supportsResume) {
-      return {
-        ok: false,
-        error: "agent_not_supported",
-        message: `Agent '${agentName}' does not support session resume`
-      };
-    }
-    const agentDef = this.agentManager.getAgent(agentName);
-    if (!agentDef) {
-      return {
-        ok: false,
-        error: "agent_not_supported",
-        message: `Agent '${agentName}' not found`
-      };
-    }
-    const { existsSync } = await import("fs");
-    if (!existsSync(cwd)) {
-      return {
-        ok: false,
-        error: "invalid_cwd",
-        message: `Directory does not exist: ${cwd}`
-      };
-    }
-    const maxSessions = this.configManager.get().security.maxConcurrentSessions;
-    if (this.sessionManager.listSessions().length >= maxSessions) {
-      return {
-        ok: false,
-        error: "session_limit",
-        message: "Maximum concurrent sessions reached"
-      };
-    }
-    const existingRecord = this.sessionManager.getRecordByAgentSessionId(agentSessionId);
-    if (existingRecord) {
-      const sameChannel = !channelId || existingRecord.channelId === channelId;
-      const platform = existingRecord.platform;
-      const existingThreadId = platform?.topicId ? String(platform.topicId) : platform?.threadId;
-      if (existingThreadId && sameChannel) {
-        const adapter = this.adapters.get(existingRecord.channelId) ?? this.adapters.values().next().value;
-        if (adapter) {
-          try {
-            await adapter.sendMessage(existingRecord.sessionId, {
-              type: "text",
-              text: "Session resumed from CLI."
-            });
-          } catch {
-          }
-        }
-        return {
-          ok: true,
-          sessionId: existingRecord.sessionId,
-          threadId: existingThreadId,
-          status: "existing"
-        };
-      }
-    }
-    let adapterChannelId;
-    if (channelId) {
-      if (!this.adapters.has(channelId)) {
-        const available = Array.from(this.adapters.keys()).join(", ") || "none";
-        return { ok: false, error: "adapter_not_found", message: `Adapter '${channelId}' is not connected. Available: ${available}` };
-      }
-      adapterChannelId = channelId;
-    } else {
-      const firstEntry = this.adapters.entries().next().value;
-      if (!firstEntry) {
-        return { ok: false, error: "no_adapter", message: "No channel adapter registered" };
-      }
-      adapterChannelId = firstEntry[0];
-    }
-    let session;
-    try {
-      session = await this.createSession({
-        channelId: adapterChannelId,
-        agentName,
-        workingDirectory: cwd,
-        resumeAgentSessionId: agentSessionId,
-        createThread: true,
-        initialName: "Adopted session"
-      });
-    } catch (err) {
-      return {
-        ok: false,
-        error: "resume_failed",
-        message: `Failed to resume session: ${err instanceof Error ? err.message : String(err)}`
-      };
-    }
-    const adoptPlatform = {};
-    if (adapterChannelId === "telegram") {
-      adoptPlatform.topicId = Number(session.threadId);
-    } else {
-      adoptPlatform.threadId = session.threadId;
-    }
-    await this.sessionManager.patchRecord(session.id, {
-      originalAgentSessionId: agentSessionId,
-      platform: adoptPlatform
-    });
-    return {
-      ok: true,
-      sessionId: session.id,
-      threadId: session.threadId,
-      status: "adopted"
-    };
-  }
-  async handleNewChat(channelId, currentThreadId) {
-    const currentSession = this.sessionManager.getSessionByThread(
-      channelId,
-      currentThreadId
-    );
-    if (currentSession) {
-      return this.handleNewSession(
-        channelId,
-        currentSession.agentName,
-        currentSession.workingDirectory
-      );
-    }
-    const record = this.sessionManager.getRecordByThread(
-      channelId,
-      currentThreadId
-    );
-    if (!record || record.status === "cancelled" || record.status === "error")
-      return null;
-    return this.handleNewSession(
-      channelId,
-      record.agentName,
-      record.workingDir
-    );
-  }
-  async createSessionWithContext(params) {
-    let contextResult = null;
-    try {
-      contextResult = await this.contextManager.buildContext(
-        params.contextQuery,
-        params.contextOptions
-      );
-    } catch (err) {
-      log6.warn({ err }, "Context building failed, proceeding without context");
-    }
-    const session = await this.createSession({
-      channelId: params.channelId,
-      agentName: params.agentName,
-      workingDirectory: params.workingDirectory,
-      createThread: params.createThread
-    });
-    if (contextResult) {
-      session.setContext(contextResult.markdown);
-    }
-    return { session, contextResult };
-  }
-  // --- Agent Switch ---
-  async switchSessionAgent(sessionId, toAgent) {
-    if (this.switchingLocks.has(sessionId)) {
-      throw new Error("Switch already in progress");
-    }
-    this.switchingLocks.add(sessionId);
-    try {
-      return await this._doSwitchSessionAgent(sessionId, toAgent);
-    } finally {
-      this.switchingLocks.delete(sessionId);
-    }
-  }
-  async _doSwitchSessionAgent(sessionId, toAgent) {
-    const session = this.sessionManager.getSession(sessionId);
-    if (!session) throw new Error(`Session ${sessionId} not found`);
-    const agentDef = this.agentManager.getAgent(toAgent);
-    if (!agentDef) throw new Error(`Agent "${toAgent}" is not installed`);
-    const fromAgent = session.agentName;
-    const middlewareChain = this.lifecycleManager.middlewareChain;
-    const result = await middlewareChain.execute("agent:beforeSwitch", {
-      sessionId,
-      fromAgent,
-      toAgent
-    }, async (payload) => payload);
-    if (!result) throw new Error("Agent switch blocked by middleware");
-    const lastEntry = session.findLastSwitchEntry(toAgent);
-    const caps = getAgentCapabilities(toAgent);
-    const canResume = !!(lastEntry && caps.supportsResume && lastEntry.promptCount === 0);
-    const resumed = canResume;
-    const bridge = this.bridges.get(sessionId);
-    if (bridge) bridge.disconnect();
-    const switchAdapter = this.adapters.get(session.channelId);
-    if (switchAdapter?.sendSkillCommands) {
-      await switchAdapter.sendSkillCommands(session.id, []);
-    }
-    if (switchAdapter?.cleanupSessionState) {
-      await switchAdapter.cleanupSessionState(session.id);
-    }
-    const fromAgentSessionId = session.agentSessionId;
-    try {
-      await session.switchAgent(toAgent, async () => {
-        if (canResume) {
-          return this.agentManager.resume(toAgent, session.workingDirectory, lastEntry.agentSessionId);
-        } else {
-          const instance = await this.agentManager.spawn(toAgent, session.workingDirectory);
-          try {
-            const contextService = this.lifecycleManager.serviceRegistry.get("context");
-            if (contextService) {
-              const config = this.configManager.get();
-              const labelAgent = config.agentSwitch?.labelHistory ?? true;
-              const contextResult = await contextService.buildContext(
-                { type: "session", value: sessionId, repoPath: session.workingDirectory },
-                { labelAgent }
-              );
-              if (contextResult?.markdown) {
-                session.setContext(contextResult.markdown);
-              }
-            }
-          } catch {
-          }
-          return instance;
-        }
-      });
-    } catch (err) {
-      try {
-        let rollbackInstance;
-        try {
-          rollbackInstance = await this.agentManager.resume(fromAgent, session.workingDirectory, fromAgentSessionId);
-        } catch {
-          rollbackInstance = await this.agentManager.spawn(fromAgent, session.workingDirectory);
-        }
-        const oldInstance = rollbackInstance;
-        session.agentSwitchHistory.pop();
-        session.agentInstance = oldInstance;
-        session.agentName = fromAgent;
-        session.agentSessionId = oldInstance.sessionId;
-        const adapter = this.adapters.get(session.channelId);
-        if (adapter) {
-          const rollbackBridge = this.createBridge(session, adapter);
-          rollbackBridge.connect();
-        }
-        log6.warn({ sessionId, fromAgent, toAgent, err }, "Agent switch failed, rolled back to previous agent");
-      } catch (rollbackErr) {
-        session.fail(`Switch failed and rollback failed: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`);
-        log6.error({ sessionId, fromAgent, toAgent, err, rollbackErr }, "Agent switch failed and rollback also failed");
-      }
-      throw err;
-    }
-    if (bridge) {
-      const adapter = this.adapters.get(session.channelId);
-      if (adapter) {
-        const newBridge = this.createBridge(session, adapter);
-        newBridge.connect();
-      }
-    }
-    await this.sessionManager.patchRecord(sessionId, {
-      agentName: toAgent,
-      agentSessionId: session.agentSessionId,
-      firstAgent: session.firstAgent,
-      currentPromptCount: 0,
-      agentSwitchHistory: session.agentSwitchHistory
-    });
-    middlewareChain.execute("agent:afterSwitch", {
-      sessionId,
-      fromAgent,
-      toAgent,
-      resumed
-    }, async (p) => p).catch(() => {
-    });
-    return { resumed };
-  }
-  // --- Lazy Resume ---
-  /**
-   * Get active session by thread, or attempt lazy resume from store.
-   * Used by adapter command handlers that need a session but don't go through handleMessage().
-   */
-  async getOrResumeSession(channelId, threadId) {
-    const session = this.sessionManager.getSessionByThread(channelId, threadId);
-    if (session) return session;
-    return this.lazyResume({ channelId, threadId, userId: "", text: "" });
-  }
-  async lazyResume(message) {
-    const store = this.sessionStore;
-    if (!store) return null;
-    const lockKey = `${message.channelId}:${message.threadId}`;
-    const existing = this.resumeLocks.get(lockKey);
-    if (existing) return existing;
-    const record = store.findByPlatform(
-      message.channelId,
-      (p) => String(p.topicId) === message.threadId
-    );
-    if (!record) {
-      log6.debug(
-        { threadId: message.threadId, channelId: message.channelId },
-        "No session record found for thread"
-      );
-      return null;
-    }
-    if (record.status === "error" || record.status === "cancelled") {
-      log6.debug(
-        {
-          threadId: message.threadId,
-          sessionId: record.sessionId,
-          status: record.status
-        },
-        "Skipping resume of error session"
-      );
-      return null;
-    }
-    log6.info(
-      {
-        threadId: message.threadId,
-        sessionId: record.sessionId,
-        status: record.status
-      },
-      "Lazy resume: found record, attempting resume"
-    );
-    const resumePromise = (async () => {
-      try {
-        const session = await this.createSession({
-          channelId: record.channelId,
-          agentName: record.agentName,
-          workingDirectory: record.workingDir,
-          resumeAgentSessionId: record.agentSessionId,
-          existingSessionId: record.sessionId,
-          initialName: record.name,
-          threadId: message.threadId
-        });
-        session.activate();
-        session.dangerousMode = record.dangerousMode ?? false;
-        if (record.firstAgent) session.firstAgent = record.firstAgent;
-        if (record.agentSwitchHistory) session.agentSwitchHistory = record.agentSwitchHistory;
-        if (record.currentPromptCount != null) session.promptCount = record.currentPromptCount;
-        log6.info(
-          { sessionId: session.id, threadId: message.threadId },
-          "Lazy resume successful"
-        );
-        return session;
-      } catch (err) {
-        log6.error({ err, record }, "Lazy resume failed");
-        const adapter = this.adapters.get(message.channelId);
-        if (adapter) {
-          try {
-            await adapter.sendMessage(message.threadId, {
-              type: "error",
-              text: `\u26A0\uFE0F Failed to resume session: ${err instanceof Error ? err.message : String(err)}`
-            });
-          } catch {
-          }
-        }
-        return null;
-      } finally {
-        this.resumeLocks.delete(lockKey);
-      }
-    })();
-    this.resumeLocks.set(lockKey, resumePromise);
-    return resumePromise;
-  }
-  // --- Event Wiring ---
-  /** Create a SessionBridge for the given session and adapter */
-  createBridge(session, adapter) {
-    const bridge = new SessionBridge(session, adapter, {
-      messageTransformer: this.messageTransformer,
-      notificationManager: this.notificationManager,
-      sessionManager: this.sessionManager,
-      eventBus: this.eventBus,
-      fileService: this.fileService,
-      middlewareChain: this.lifecycleManager?.middlewareChain
-    });
-    this.bridges.set(session.id, bridge);
-    return bridge;
-  }
-};
-
-// src/core/command-registry.ts
-var CommandRegistry = class _CommandRegistry {
-  /** Main registry: short names + qualified names → RegisteredCommand */
-  commands = /* @__PURE__ */ new Map();
-  /** Adapter-specific overrides: `channelId:commandName` → RegisteredCommand */
-  overrides = /* @__PURE__ */ new Map();
-  static ADAPTER_SCOPES = /* @__PURE__ */ new Set(["telegram", "discord"]);
-  /**
-   * Register a command definition.
-   * @param def - Command definition
-   * @param pluginName - Plugin that owns the command (set automatically by PluginContext)
-   */
-  register(def, pluginName) {
-    const cmd = {
-      ...def,
-      pluginName: pluginName ?? def.pluginName
-    };
-    if (pluginName) {
-      cmd.scope = _CommandRegistry.extractScope(pluginName);
-    }
-    const qualifiedName = cmd.scope ? `${cmd.scope}:${cmd.name}` : void 0;
-    if (cmd.scope && _CommandRegistry.ADAPTER_SCOPES.has(cmd.scope) && this.commands.has(cmd.name)) {
-      this.overrides.set(`${cmd.scope}:${cmd.name}`, cmd);
-      return;
-    }
-    if (qualifiedName) {
-      this.commands.set(qualifiedName, cmd);
-    }
-    if (this.commands.has(cmd.name)) {
-      const existing = this.commands.get(cmd.name);
-      if (existing.category === "system") {
-        return;
-      }
-      return;
-    }
-    this.commands.set(cmd.name, cmd);
-  }
-  /** Retrieve a command by name (short or qualified). */
-  get(name) {
-    return this.commands.get(name);
-  }
-  /** Remove a command by name (short or qualified). Also removes its qualified name entry. */
-  unregister(name) {
-    const cmd = this.commands.get(name);
-    if (!cmd) return;
-    this.commands.delete(name);
-    if (cmd.scope) {
-      this.commands.delete(`${cmd.scope}:${cmd.name}`);
-      this.commands.delete(cmd.name);
-    }
-  }
-  /** Remove all commands registered by a given plugin. */
-  unregisterByPlugin(pluginName) {
-    const toDelete = [];
-    for (const [key, cmd] of this.commands) {
-      if (cmd.pluginName === pluginName) {
-        toDelete.push(key);
-      }
-    }
-    for (const key of toDelete) {
-      this.commands.delete(key);
-    }
-    for (const [key, cmd] of this.overrides) {
-      if (cmd.pluginName === pluginName) {
-        this.overrides.delete(key);
-      }
-    }
-  }
-  /** Return all unique commands (deduplicated — each command appears once). */
-  getAll() {
-    const seen = /* @__PURE__ */ new Set();
-    for (const cmd of this.commands.values()) {
-      seen.add(cmd);
-    }
-    return [...seen];
-  }
-  /** Filter commands by category. */
-  getByCategory(category) {
-    return this.getAll().filter((cmd) => cmd.category === category);
-  }
-  /**
-   * Parse and execute a command string.
-   * @param commandString - Full command string, e.g. "/greet hello world"
-   * @param baseArgs - Base arguments (channelId, userId, etc.)
-   * @returns CommandResponse
-   */
-  async execute(commandString, baseArgs) {
-    const trimmed = commandString.trim();
-    const spaceIdx = trimmed.indexOf(" ");
-    const rawCmd = spaceIdx === -1 ? trimmed.slice(1) : trimmed.slice(1, spaceIdx);
-    const cmdName = rawCmd.split("@")[0];
-    const rawArgs = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1);
-    const overrideKey = `${baseArgs.channelId}:${cmdName}`;
-    const override = this.overrides.get(overrideKey);
-    const cmd = override ?? this.commands.get(cmdName);
-    if (!cmd) {
-      return { type: "error", message: `Unknown command: /${cmdName}` };
-    }
-    const args = {
-      ...baseArgs,
-      raw: rawArgs
-    };
-    try {
-      const result = await cmd.handler(args);
-      if (result === void 0 || result === null) {
-        return { type: "silent" };
-      }
-      return result;
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { type: "error", message: `Command /${cmdName} failed: ${message}` };
-    }
-  }
-  /** Extract scope from plugin name: '@openacp/speech' → 'speech', 'my-plugin' → 'my-plugin' */
-  static extractScope(pluginName) {
-    const slashIdx = pluginName.lastIndexOf("/");
-    if (slashIdx !== -1) {
-      return pluginName.slice(slashIdx + 1);
-    }
-    return pluginName;
-  }
-};
-
-export {
-  nodeToWebWritable,
-  nodeToWebReadable,
-  StderrCapture,
-  TypedEmitter,
-  AgentInstance,
-  AgentManager,
-  PromptQueue,
-  PermissionGate,
-  Session,
-  SessionManager,
-  SessionBridge,
-  MessageTransformer,
-  SessionFactory,
-  EventBus,
-  OpenACPCore,
-  CommandRegistry
-};
-//# sourceMappingURL=chunk-LRV56K2M.js.map