@openacp/cli 0.6.10 → 2026.326.3

package/dist/chunk-FQEBWOZR.js

@@ -0,0 +1,3557 @@
+import {
+  AgentCatalog
+} from "./chunk-SHTGQGAU.js";
+import {
+  getAgentCapabilities
+} from "./chunk-ZSLHHQPQ.js";
+import {
+  readTextFileWithRange
+} from "./chunk-OYSAN7UX.js";
+import {
+  createChildLogger,
+  createSessionLogger
+} from "./chunk-XMMAGAT4.js";
+
+// src/core/utils/streams.ts
+function nodeToWebWritable(nodeStream) {
+  return new WritableStream({
+    write(chunk) {
+      return new Promise((resolve, reject) => {
+        nodeStream.write(Buffer.from(chunk), (err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    }
+  });
+}
+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));
+    }
+  });
+}
+
+// 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 fs from "fs";
+import path 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/agents/agent-instance.ts
+var log = createChildLogger({ module: "agent-instance" });
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = path.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 = [
+      path.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
+      path.resolve(root, "node_modules", cmd, "dist", "index.js")
+    ];
+    for (const jsPath of packageDirs) {
+      if (fs.existsSync(jsPath)) {
+        return { command: process.execPath, args: [jsPath] };
+      }
+    }
+  }
+  for (const root of searchRoots) {
+    const localBin = path.resolve(root, "node_modules", ".bin", cmd);
+    if (fs.existsSync(localBin)) {
+      const content = fs.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 = path.resolve(path.dirname(localBin), match[1]);
+        if (fs.existsSync(target)) {
+          return { command: process.execPath, args: [target] };
+        }
+      }
+    }
+  }
+  try {
+    const fullPath = execFileSync("which", [cmd], { encoding: "utf-8" }).trim();
+    if (fullPath) {
+      const content = fs.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();
+  sessionId;
+  agentName;
+  promptCapabilities;
+  middlewareChain;
+  // 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) {
+        log.debug(
+          { direction: "send", raw: chunk.toString().trimEnd() },
+          "ACP raw"
+        );
+        cb(null, chunk);
+      }
+    });
+    stdinLogger.pipe(instance.child.stdin);
+    const stdoutLogger = new Transform({
+      transform(chunk, _enc, cb) {
+        log.debug(
+          { direction: "recv", raw: chunk.toString().trimEnd() },
+          "ACP 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) => {
+      log.info(
+        { sessionId: this.sessionId, exitCode: code, signal },
+        "Agent process exited"
+      );
+      if (code !== 0 && code !== null) {
+        const stderr = this.stderrCapture.getLastLines();
+        this.emit("agent_event", {
+          type: "error",
+          message: `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.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;
+      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;
+      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 fs.promises.mkdir(path.dirname(writePath), { recursive: true });
+        await fs.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 fs.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 fs.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.terminalManager.destroyAll();
+    this.child.kill("SIGTERM");
+    setTimeout(() => {
+      if (!this.child.killed) this.child.kill("SIGKILL");
+    }, 1e4);
+  }
+};
+
+// 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) {
+    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);
+    });
+  }
+  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 fs2 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: /* @__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;
+  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.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;
+    }
+    this.promptCount++;
+    if (this._status === "initializing") {
+      this.activate();
+    }
+    const promptStart = Date.now();
+    this.log.debug("Prompt execution started");
+    if (this.pendingContext) {
+      text = `[CONVERSATION HISTORY - This is context from previous sessions, not current conversation]
+
+${this.pendingContext}
+
+[END CONVERSATION HISTORY]
+
+${text}`;
+      this.pendingContext = null;
+      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;
+      if (this.voiceMode === "next") {
+        this.voiceMode = "off";
+      }
+    }
+    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";
+      }
+    } 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 fs2.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 {
+      const timeoutPromise = new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("TTS synthesis timed out")), TTS_TIMEOUT_MS)
+      );
+      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.log.info("TTS synthesis completed");
+    } 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();
+    }
+  }
+  async generateSummary(timeoutMs = 15e3) {
+    let summary = "";
+    let timer;
+    const captureHandler = (event) => {
+      if (event.type === "text") summary += event.content;
+    };
+    this.pause((event) => event !== "agent_event");
+    this.agentInstance.on("agent_event", captureHandler);
+    try {
+      const promptPromise = this.agentInstance.prompt(
+        "Summarize what you've accomplished so far in this session in 2-3 sentences. Include: key files changed, decisions made, and current status. Reply ONLY with the summary, nothing else."
+      );
+      const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("summary timeout")), timeoutMs);
+      });
+      await Promise.race([promptPromise, timeoutPromise]);
+      return summary.trim().slice(0, 500);
+    } catch {
+      this.log.warn("Failed to generate session summary");
+      return "";
+    } finally {
+      if (timer) clearTimeout(timer);
+      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();
+  }
+  async destroy() {
+    this.log.info("Session destroyed");
+    await this.agentInstance.destroy();
+  }
+};
+
+// 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) {
+      await session.abortPrompt();
+      session.markCancelled();
+    }
+    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 });
+  }
+  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;
+  /** Send message to adapter, optionally running through message:outgoing middleware */
+  async sendMessage(sessionId, message) {
+    const mw = this.deps.middlewareChain;
+    if (mw) {
+      const result = await mw.execute("message:outgoing", { sessionId, message }, async (m) => m);
+      if (!result) return;
+      this.adapter.sendMessage(sessionId, result.message);
+    } else {
+      this.adapter.sendMessage(sessionId, message);
+    }
+  }
+  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);
+    }
+    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) => {
+      const mw = this.deps.middlewareChain;
+      if (mw) {
+        mw.execute("agent:beforeEvent", { sessionId: this.session.id, event }, async (e) => e).then((result) => {
+          if (!result) return;
+          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(() => {
+          this.handleAgentEvent(event);
+        });
+      } else {
+        this.handleAgentEvent(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.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 fs5 = this.deps.fileService;
+          const sid = this.session.id;
+          const { data, mimeType } = event;
+          const buffer = Buffer.from(data, "base64");
+          const ext = fs5.extensionFromMime(mimeType);
+          fs5.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 fs5 = this.deps.fileService;
+          const sid = this.session.id;
+          const { data, mimeType } = event;
+          const buffer = Buffer.from(data, "base64");
+          const ext = fs5.extensionFromMime(mimeType);
+          fs5.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;
+    }
+    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" || to === "cancelled") {
+        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);
+  }
+};
+
+// 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 claudeCode = m?.claudeCode;
+    const tr = claudeCode?.toolResponse;
+    const file = tr?.file;
+    if (typeof file?.filePath === "string" && typeof file?.content === "string") {
+      info = { filePath: file.filePath, content: file.content };
+    }
+    if (!info && typeof tr?.filePath === "string" && typeof tr?.content === "string") {
+      info = { filePath: tr.filePath, content: tr.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;
+      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 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" });
+var MessageTransformer = class {
+  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": {
+        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": {
+        const meta = event.meta;
+        const metadata = {
+          id: event.id,
+          name: event.name,
+          kind: event.kind,
+          status: event.status,
+          content: event.content,
+          rawInput: event.rawInput,
+          displaySummary: meta?.displaySummary,
+          displayTitle: meta?.displayTitle,
+          displayKind: meta?.displayKind
+        };
+        this.enrichWithViewerLinks(event, metadata, sessionContext);
+        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
+          }
+        };
+      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: "" };
+    }
+  }
+  enrichWithViewerLinks(event, metadata, sessionContext) {
+    if (!this.tunnelService || !sessionContext) return;
+    const name = "name" in event ? event.name || "" : "";
+    const kind = "kind" in event ? event.kind : void 0;
+    log3.debug(
+      { name, kind, status: event.status, hasContent: !!event.content },
+      "enrichWithViewerLinks: inspecting event"
+    );
+    const fileInfo = extractFileInfo(
+      name,
+      kind,
+      event.content,
+      event.rawInput,
+      event.meta
+    );
+    if (!fileInfo) 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);
+    }
+    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
+import { nanoid as nanoid2 } from "nanoid";
+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) {
+    if (deps.usageStore) {
+      const usageStore = deps.usageStore;
+      const usageBudget = deps.usageBudget;
+      const notificationManager = deps.notificationManager;
+      session.on("agent_event", (event) => {
+        if (event.type !== "usage") return;
+        const record = {
+          id: nanoid2(),
+          sessionId: session.id,
+          agentName: session.agentName,
+          tokensUsed: event.tokensUsed ?? 0,
+          contextSize: event.contextSize ?? 0,
+          cost: event.cost,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        usageStore.append(record);
+        if (usageBudget) {
+          const result = usageBudget.check();
+          if (result.message) {
+            notificationManager.notifyAll({
+              sessionId: session.id,
+              sessionName: session.name,
+              type: "budget_warning",
+              summary: result.message
+            });
+          }
+        }
+      });
+    }
+    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 path4 from "path";
+import os from "os";
+
+// src/core/sessions/session-store.ts
+import fs3 from "fs";
+import path2 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) {
+    return [...this.records.values()].find(
+      (r) => r.agentSessionId === agentSessionId || r.originalAgentSessionId === agentSessionId
+    );
+  }
+  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 = path2.dirname(this.filePath);
+    if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
+    fs3.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 (!fs3.existsSync(this.filePath)) return;
+    try {
+      const raw = JSON.parse(
+        fs3.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");
+    }
+  }
+  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);
+    } 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].sort((a, b) => a.priority - b.priority);
+    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;
+        try {
+          const timeoutPromise = new Promise((_, reject) => {
+            const timer = setTimeout(
+              () => reject(new Error(`Middleware timeout: ${entry.pluginName} on hook ${hook}`)),
+              MIDDLEWARE_TIMEOUT_MS
+            );
+            if (typeof timer === "object" && timer !== null && "unref" in timer) {
+              ;
+              timer.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();
+        }
+        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-storage.ts
+import fs4 from "fs";
+import path3 from "path";
+var PluginStorageImpl = class {
+  kvPath;
+  dataDir;
+  writeChain = Promise.resolve();
+  constructor(baseDir) {
+    this.dataDir = path3.join(baseDir, "data");
+    this.kvPath = path3.join(baseDir, "kv.json");
+  }
+  readKv() {
+    try {
+      const raw = fs4.readFileSync(this.kvPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return {};
+    }
+  }
+  writeKv(data) {
+    fs4.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() {
+    fs4.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 registeredListeners = [];
+  const registeredCommands = [];
+  const log7 = opts.log ?? {
+    trace() {
+    },
+    debug() {
+    },
+    info() {
+    },
+    warn() {
+    },
+    error() {
+    },
+    fatal() {
+    },
+    child() {
+      return log7;
+    }
+  };
+  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);
+      }
+    },
+    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;
+    },
+    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/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;
+  contexts = /* @__PURE__ */ new Map();
+  loadOrder = [];
+  _loaded = /* @__PURE__ */ new Set();
+  _failed = /* @__PURE__ */ new Set();
+  get loadedPlugins() {
+    return [...this._loaded];
+  }
+  get failedPlugins() {
+    return [...this._failed];
+  }
+  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;
+  }
+  async boot(plugins) {
+    let sorted;
+    try {
+      sorted = resolveLoadOrder(plugins);
+    } catch (err) {
+      for (const p of plugins) {
+        this._failed.add(p.name);
+      }
+      return;
+    }
+    this.loadOrder = sorted;
+    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 migrateCtx = {
+            pluginName: plugin.name,
+            settings: this.settingsManager.createAPI(plugin.name),
+            log: this.log?.child?.({ plugin: plugin.name }) ?? this.log ?? console
+          };
+          const newSettings = await plugin.migrate(migrateCtx, oldSettings, registryEntry.version);
+          if (newSettings && typeof newSettings === "object") {
+            await migrateCtx.settings.setAll(newSettings);
+          }
+          this.pluginRegistry.updateVersion(plugin.name, plugin.version);
+          await this.pluginRegistry.save();
+        } catch (err) {
+          const childLog = this.log?.child?.({ plugin: plugin.name });
+          (childLog ?? this.log ?? console).warn?.({ err }, "Migration failed, continuing with old settings");
+        }
+      }
+      let pluginConfig;
+      if (this.settingsManager) {
+        pluginConfig = await this.settingsManager.loadSettings(plugin.name);
+        if (Object.keys(pluginConfig).length === 0) {
+          pluginConfig = resolvePluginConfig(plugin.name, this.config);
+        }
+      } else {
+        pluginConfig = resolvePluginConfig(plugin.name, this.config);
+      }
+      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
+      });
+      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.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();
+  /** Set by main.ts — triggers graceful shutdown with restart exit code */
+  requestRestart = null;
+  _tunnelService;
+  sessionStore = null;
+  resumeLocks = /* @__PURE__ */ new Map();
+  eventBus;
+  sessionFactory;
+  lifecycleManager;
+  // --- Lazy getters: resolve from ServiceRegistry (populated by plugins during boot) ---
+  get securityGuard() {
+    return this.lifecycleManager.serviceRegistry.get("security");
+  }
+  get notificationManager() {
+    return this.lifecycleManager.serviceRegistry.get("notifications");
+  }
+  get fileService() {
+    return this.lifecycleManager.serviceRegistry.get("file-service");
+  }
+  get speechService() {
+    return this.lifecycleManager.serviceRegistry.get("speech");
+  }
+  get contextManager() {
+    return this.lifecycleManager.serviceRegistry.get("context");
+  }
+  get usageStore() {
+    const usage = this.lifecycleManager.serviceRegistry.get("usage");
+    return usage?.store ?? null;
+  }
+  get usageBudget() {
+    const usage = this.lifecycleManager.serviceRegistry.get("usage");
+    return usage?.budget ?? null;
+  }
+  constructor(configManager) {
+    this.configManager = configManager;
+    const config = configManager.get();
+    this.agentCatalog = new AgentCatalog();
+    this.agentCatalog.load();
+    this.agentManager = new AgentManager(this.agentCatalog);
+    const storePath = path4.join(os.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: path4.join(os.homedir(), ".openacp", "plugins", "data")
+    });
+    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-LZ7FTRKG.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 = new MessageTransformer(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 {
+      await this.notificationManager.notifyAll({
+        sessionId: "system",
+        type: "error",
+        summary: "OpenACP is shutting down"
+      });
+    } catch {
+    }
+    await this.sessionManager.destroyAll();
+    for (const adapter of this.adapters.values()) {
+      await adapter.stop();
+    }
+    if (this.usageStore) {
+      this.usageStore.destroy();
+    }
+  }
+  // --- Summary ---
+  async summarizeSession(sessionId) {
+    const session = this.sessionManager.getSession(sessionId);
+    if (session && session.status === "active") {
+      try {
+        const summary = await session.generateSummary();
+        if (!summary) return { ok: false, error: "Agent could not generate summary" };
+        return { ok: true, summary };
+      } catch (err) {
+        return { ok: false, error: err.message };
+      }
+    }
+    const record = this.sessionManager.getSessionRecord(sessionId);
+    if (!record?.agentSessionId) {
+      return { ok: false, error: "Session not found or has no agent history" };
+    }
+    const caps = getAgentCapabilities(record.agentName);
+    if (!caps.supportsResume) {
+      return { ok: false, error: `Agent "${record.agentName}" does not support resume \u2014 cannot summarize ended session` };
+    }
+    let tempSession;
+    try {
+      const agentInstance = await this.agentManager.resume(
+        record.agentName,
+        record.workingDir,
+        record.agentSessionId
+      );
+      tempSession = new Session({
+        id: `summary-${sessionId}`,
+        channelId: record.channelId,
+        agentName: record.agentName,
+        workingDirectory: record.workingDir,
+        agentInstance
+      });
+      tempSession.activate();
+      const summary = await tempSession.generateSummary();
+      if (!summary) return { ok: false, error: "Agent could not generate summary" };
+      return { ok: true, summary };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    } finally {
+      if (tempSession) {
+        try {
+          await tempSession.destroy();
+        } catch {
+        }
+      }
+    }
+  }
+  // --- Archive ---
+  async archiveSession(sessionId) {
+    const session = this.sessionManager.getSession(sessionId);
+    const record = this.sessionManager.getSessionRecord(sessionId);
+    if (!session && !record) return { ok: false, error: "Session not found" };
+    const channelId = session?.channelId ?? record?.channelId;
+    if (!channelId) return { ok: false, error: "No channel for session" };
+    const adapter = this.adapters.get(channelId);
+    if (!adapter) return { ok: false, error: "Adapter not found for session" };
+    try {
+      if (session) {
+        await adapter.archiveSessionTopic?.(session.id);
+      } else {
+        await adapter.deleteSessionThread?.(sessionId);
+      }
+      if (session) {
+        try {
+          await this.sessionManager.cancelSession(sessionId);
+        } catch {
+        } finally {
+          session.archiving = false;
+        }
+      }
+      await this.sessionManager.removeRecord(sessionId);
+      return { ok: true };
+    } catch (err) {
+      if (session) 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);
+    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, {
+      usageStore: this.usageStore,
+      usageBudget: this.usageBudget,
+      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
+    });
+    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 };
+  }
+  // --- 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") {
+      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
+        });
+        session.threadId = message.threadId;
+        session.activate();
+        session.dangerousMode = record.dangerousMode ?? false;
+        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) {
+    return new SessionBridge(session, adapter, {
+      messageTransformer: this.messageTransformer,
+      notificationManager: this.notificationManager,
+      sessionManager: this.sessionManager,
+      eventBus: this.eventBus,
+      fileService: this.fileService,
+      middlewareChain: this.lifecycleManager?.middlewareChain
+    });
+  }
+};
+
+export {
+  nodeToWebWritable,
+  nodeToWebReadable,
+  StderrCapture,
+  TypedEmitter,
+  AgentInstance,
+  AgentManager,
+  PromptQueue,
+  PermissionGate,
+  Session,
+  SessionManager,
+  SessionBridge,
+  MessageTransformer,
+  SessionFactory,
+  EventBus,
+  OpenACPCore
+};
+//# sourceMappingURL=chunk-FQEBWOZR.js.map