@openacp/cli 0.6.3 → 0.6.5

package/dist/chunk-FEWSQT3U.js

@@ -0,0 +1,3949 @@
+import {
+  AgentCatalog
+} from "./chunk-UKT3G5IA.js";
+import {
+  getAgentCapabilities
+} from "./chunk-JKBFUAJK.js";
+import {
+  createChildLogger,
+  createSessionLogger
+} from "./chunk-GAK6PIBW.js";
+
+// src/core/streams.ts
+function nodeToWebWritable(nodeStream) {
+  return new WritableStream({
+    write(chunk) {
+      return new Promise((resolve3, reject) => {
+        nodeStream.write(Buffer.from(chunk), (err) => {
+          if (err) reject(err);
+          else resolve3();
+        });
+      });
+    }
+  });
+}
+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/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/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/agent-instance.ts
+import { spawn, execFileSync } from "child_process";
+import { Transform } from "stream";
+import fs from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+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;
+  terminals = /* @__PURE__ */ new Map();
+  sessionId;
+  agentName;
+  promptCapabilities;
+  // 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 = spawn(
+      resolved.command,
+      [...resolved.args, ...agentDef.args],
+      {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: workingDirectory,
+        env: { ...process.env, ...agentDef.env }
+      }
+    );
+    await new Promise((resolve3, 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", () => resolve3());
+    });
+    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: 1,
+      clientCapabilities: {
+        fs: { readTextFile: true, writeTextFile: true },
+        terminal: true
+      }
+    });
+    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) {
+    log.debug(
+      { agentName: agentDef.name, command: agentDef.command },
+      "Spawning agent"
+    );
+    const spawnStart = Date.now();
+    const instance = await _AgentInstance.spawnSubprocess(
+      agentDef,
+      workingDirectory
+    );
+    const response = await instance.connection.newSession({
+      cwd: workingDirectory,
+      mcpServers: []
+    });
+    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) {
+    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 response = await instance.connection.newSession({
+        cwd: workingDirectory,
+        mcpServers: []
+      });
+      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 };
+            }
+            break;
+          case "agent_thought_chunk":
+            if (update.content.type === "text") {
+              event = { type: "thought", content: update.content.text };
+            }
+            break;
+          case "tool_call":
+            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: update.rawInput ?? void 0,
+              meta: update._meta ?? void 0
+            };
+            break;
+          case "tool_call_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: update.rawInput ?? void 0,
+              meta: update._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;
+          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 content = await fs.promises.readFile(params.path, "utf-8");
+        return { content };
+      },
+      async writeTextFile(params) {
+        await fs.promises.mkdir(path.dirname(params.path), { recursive: true });
+        await fs.promises.writeFile(params.path, params.content, "utf-8");
+        return {};
+      },
+      // ── Terminal operations ──────────────────────────────────────────────
+      async createTerminal(params) {
+        const terminalId = randomUUID();
+        const args = params.args ?? [];
+        const env = {};
+        for (const ev of params.env ?? []) {
+          env[ev.name] = ev.value;
+        }
+        const childProcess = spawn(params.command, args, {
+          cwd: params.cwd ?? void 0,
+          env: { ...process.env, ...env },
+          shell: false
+        });
+        const state = {
+          process: childProcess,
+          output: "",
+          exitStatus: null
+        };
+        self.terminals.set(terminalId, state);
+        const outputByteLimit = params.outputByteLimit ?? MAX_OUTPUT_BYTES;
+        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 };
+        });
+        return { terminalId };
+      },
+      async terminalOutput(params) {
+        const state = self.terminals.get(params.terminalId);
+        if (!state) {
+          throw new Error(`Terminal not found: ${params.terminalId}`);
+        }
+        return {
+          output: state.output,
+          truncated: false,
+          exitStatus: state.exitStatus ? {
+            exitCode: state.exitStatus.exitCode,
+            signal: state.exitStatus.signal
+          } : void 0
+        };
+      },
+      async waitForTerminalExit(params) {
+        const state = self.terminals.get(params.terminalId);
+        if (!state) {
+          throw new Error(`Terminal not found: ${params.terminalId}`);
+        }
+        if (state.exitStatus !== null) {
+          return {
+            exitCode: state.exitStatus.exitCode,
+            signal: state.exitStatus.signal
+          };
+        }
+        return new Promise((resolve3) => {
+          state.process.on("exit", (code, signal) => {
+            resolve3({ exitCode: code, signal });
+          });
+        });
+      },
+      async killTerminal(params) {
+        const state = self.terminals.get(params.terminalId);
+        if (!state) {
+          throw new Error(`Terminal not found: ${params.terminalId}`);
+        }
+        state.process.kill("SIGTERM");
+        return {};
+      },
+      async releaseTerminal(params) {
+        const state = self.terminals.get(params.terminalId);
+        if (!state) {
+          return;
+        }
+        state.process.kill("SIGKILL");
+        self.terminals.delete(params.terminalId);
+      }
+    };
+  }
+  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() {
+    for (const [, t] of this.terminals) {
+      t.process.kill("SIGKILL");
+    }
+    this.terminals.clear();
+    this.child.kill("SIGTERM");
+    setTimeout(() => {
+      if (!this.child.killed) this.child.kill("SIGKILL");
+    }, 1e4);
+  }
+};
+
+// src/core/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/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((resolve3) => {
+        this.queue.push({ text, attachments, resolve: resolve3 });
+      });
+    }
+    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/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((resolve3, reject) => {
+      this.resolveFn = resolve3;
+      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/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;
+  archiving = false;
+  log;
+  permissionGate = new PermissionGate();
+  queue;
+  speechService;
+  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;
+  }
+  // --- Voice Mode ---
+  setVoiceMode(mode) {
+    this.voiceMode = mode;
+    this.log.info({ voiceMode: mode }, "TTS mode changed");
+  }
+  // --- Public API ---
+  async enqueuePrompt(text, attachments) {
+    await this.queue.enqueue(text, attachments);
+  }
+  async processPrompt(text, attachments) {
+    if (text === "\0__warmup__") {
+      await this.runWarmup();
+      return;
+    }
+    if (this._status === "initializing") {
+      this.activate();
+    }
+    const promptStart = Date.now();
+    this.log.debug("Prompt execution started");
+    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);
+    }
+    try {
+      await this.agentInstance.prompt(processed.text, processed.attachments);
+    } finally {
+      if (accumulatorListener) {
+        this.off("agent_event", accumulatorListener);
+      }
+    }
+    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();
+    }
+  }
+  /** 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();
+    }
+  }
+  /** Cancel the current prompt and clear the queue. Stays in active state. */
+  async abortPrompt() {
+    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/session-manager.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  store;
+  eventBus;
+  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" });
+      }
+    }
+  }
+  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" });
+        }
+      }
+    }
+    for (const session of this.sessions.values()) {
+      await session.destroy();
+    }
+    this.sessions.clear();
+  }
+};
+
+// src/core/file-service.ts
+import fs3 from "fs";
+import path2 from "path";
+import { OggOpusDecoder } from "ogg-opus-decoder";
+import wav from "node-wav";
+var MIME_TO_EXT = {
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/svg+xml": ".svg",
+  "audio/ogg": ".ogg",
+  "audio/mpeg": ".mp3",
+  "audio/wav": ".wav",
+  "audio/webm": ".webm",
+  "audio/mp4": ".m4a",
+  "video/mp4": ".mp4",
+  "video/webm": ".webm",
+  "application/pdf": ".pdf",
+  "text/plain": ".txt"
+};
+var EXT_TO_MIME = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".ogg": "audio/ogg",
+  ".oga": "audio/ogg",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".m4a": "audio/mp4",
+  ".mp4": "video/mp4",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain"
+};
+function classifyMime(mimeType) {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("audio/")) return "audio";
+  return "file";
+}
+var FileService = class {
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+  async saveFile(sessionId, fileName, data, mimeType) {
+    const sessionDir = path2.join(this.baseDir, sessionId);
+    await fs3.promises.mkdir(sessionDir, { recursive: true });
+    const safeName = `${Date.now()}-${fileName.replace(/[^a-zA-Z0-9._-]/g, "_")}`;
+    const filePath = path2.join(sessionDir, safeName);
+    await fs3.promises.writeFile(filePath, data);
+    return {
+      type: classifyMime(mimeType),
+      filePath,
+      fileName,
+      mimeType,
+      size: data.length
+    };
+  }
+  async resolveFile(filePath) {
+    try {
+      const stat = await fs3.promises.stat(filePath);
+      if (!stat.isFile()) return null;
+      const ext = path2.extname(filePath).toLowerCase();
+      const mimeType = EXT_TO_MIME[ext] || "application/octet-stream";
+      return {
+        type: classifyMime(mimeType),
+        filePath,
+        fileName: path2.basename(filePath),
+        mimeType,
+        size: stat.size
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Convert OGG Opus audio to WAV format.
+   * Telegram voice messages use OGG Opus which many AI agents can't read.
+   */
+  async convertOggToWav(oggData) {
+    const decoder = new OggOpusDecoder();
+    await decoder.ready;
+    try {
+      const { channelData, sampleRate } = await decoder.decode(new Uint8Array(oggData));
+      const wavData = wav.encode(channelData, { sampleRate, float: true, bitDepth: 32 });
+      return Buffer.from(wavData);
+    } finally {
+      decoder.free();
+    }
+  }
+  static extensionFromMime(mimeType) {
+    return MIME_TO_EXT[mimeType] || ".bin";
+  }
+};
+
+// src/core/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;
+  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() {
+    const session = this.session;
+    const ctx = {
+      get id() {
+        return session.id;
+      },
+      get workingDirectory() {
+        return session.workingDirectory;
+      }
+    };
+    this.sessionEventHandler = (event) => {
+      switch (event.type) {
+        case "text":
+        case "thought":
+        case "tool_call":
+        case "tool_update":
+        case "plan":
+        case "usage":
+          this.adapter.sendMessage(
+            this.session.id,
+            this.deps.messageTransformer.transform(event, ctx)
+          );
+          break;
+        case "session_end":
+          this.session.finish(event.reason);
+          this.adapter.cleanupSkillCommands(this.session.id);
+          this.adapter.sendMessage(
+            this.session.id,
+            this.deps.messageTransformer.transform(event)
+          );
+          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`
+          });
+          break;
+        case "error":
+          this.session.fail(event.message);
+          this.adapter.cleanupSkillCommands(this.session.id);
+          this.adapter.sendMessage(
+            this.session.id,
+            this.deps.messageTransformer.transform(event)
+          );
+          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 fs8 = this.deps.fileService;
+            const sid = this.session.id;
+            const { data, mimeType } = event;
+            const buffer = Buffer.from(data, "base64");
+            const ext = FileService.extensionFromMime(mimeType);
+            fs8.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
+              this.adapter.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 fs8 = this.deps.fileService;
+            const sid = this.session.id;
+            const { data, mimeType } = event;
+            const buffer = Buffer.from(data, "base64");
+            const ext = FileService.extensionFromMime(mimeType);
+            fs8.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
+              this.adapter.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":
+          this.adapter.sendMessage(
+            this.session.id,
+            this.deps.messageTransformer.transform(event)
+          );
+          break;
+      }
+      this.deps.eventBus?.emit("agent:event", {
+        sessionId: this.session.id,
+        event
+      });
+    };
+    this.session.on("agent_event", this.sessionEventHandler);
+  }
+  wirePermissions() {
+    this.session.agentInstance.onPermissionRequest = async (request) => {
+      this.session.emit("permission_request", request);
+      this.deps.eventBus?.emit("permission:request", {
+        sessionId: this.session.id,
+        permission: request
+      });
+      if (request.description.toLowerCase().includes("openacp")) {
+        const allowOption = request.options.find((o) => o.isAllow);
+        if (allowOption) {
+          log2.info(
+            { sessionId: this.session.id, requestId: request.id },
+            "Auto-approving openacp command"
+          );
+          return allowOption.id;
+        }
+      }
+      if (this.session.dangerousMode) {
+        const allowOption = request.options.find((o) => o.isAllow);
+        if (allowOption) {
+          log2.info(
+            { sessionId: this.session.id, requestId: request.id, optionId: allowOption.id },
+            "Dangerous mode: auto-approving permission"
+          );
+          return allowOption.id;
+        }
+      }
+      const promise = this.session.permissionGate.setPending(request);
+      await this.adapter.sendPermissionRequest(this.session.id, request);
+      return promise;
+    };
+  }
+  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/notification.ts
+var NotificationManager = class {
+  constructor(adapters) {
+    this.adapters = adapters;
+  }
+  async notify(channelId, notification) {
+    const adapter = this.adapters.get(channelId);
+    if (adapter) {
+      await adapter.sendNotification(notification);
+    }
+  }
+  async notifyAll(notification) {
+    for (const adapter of this.adapters.values()) {
+      await adapter.sendNotification(notification);
+    }
+  }
+};
+
+// src/tunnel/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 metadata = {
+          id: event.id,
+          name: event.name,
+          kind: event.kind,
+          status: event.status,
+          content: event.content,
+          locations: event.locations
+        };
+        this.enrichWithViewerLinks(event, metadata, sessionContext);
+        return { type: "tool_call", text: event.name, metadata };
+      }
+      case "tool_update": {
+        const metadata = {
+          id: event.id,
+          name: event.name,
+          kind: event.kind,
+          status: event.status,
+          content: event.content
+        };
+        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 };
+      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/usage-store.ts
+import fs4 from "fs";
+import path3 from "path";
+var log4 = createChildLogger({ module: "usage-store" });
+var DEBOUNCE_MS = 2e3;
+var UsageStore = class {
+  constructor(filePath, retentionDays) {
+    this.filePath = filePath;
+    this.retentionDays = retentionDays;
+    this.load();
+    this.cleanup();
+    this.cleanupInterval = setInterval(
+      () => this.cleanup(),
+      24 * 60 * 60 * 1e3
+    );
+    this.flushHandler = () => {
+      try {
+        this.flushSync();
+      } catch {
+      }
+    };
+    process.on("SIGTERM", this.flushHandler);
+    process.on("SIGINT", this.flushHandler);
+    process.on("exit", this.flushHandler);
+  }
+  records = [];
+  debounceTimer = null;
+  cleanupInterval = null;
+  flushHandler = null;
+  append(record) {
+    this.records.push(record);
+    this.scheduleDiskWrite();
+  }
+  query(period) {
+    const cutoff = this.getCutoff(period);
+    const filtered = cutoff ? this.records.filter((r) => new Date(r.timestamp).getTime() >= cutoff) : this.records;
+    const totalTokens = filtered.reduce((sum, r) => sum + r.tokensUsed, 0);
+    const totalCost = filtered.reduce(
+      (sum, r) => sum + (r.cost?.amount ?? 0),
+      0
+    );
+    const sessionIds = new Set(filtered.map((r) => r.sessionId));
+    const currency = filtered.find((r) => r.cost?.currency)?.cost?.currency ?? "USD";
+    return {
+      period,
+      totalTokens,
+      totalCost,
+      currency,
+      sessionCount: sessionIds.size,
+      recordCount: filtered.length
+    };
+  }
+  getMonthlyTotal() {
+    const now = /* @__PURE__ */ new Date();
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+    const cutoff = startOfMonth.getTime();
+    const filtered = this.records.filter(
+      (r) => new Date(r.timestamp).getTime() >= cutoff
+    );
+    const totalCost = filtered.reduce(
+      (sum, r) => sum + (r.cost?.amount ?? 0),
+      0
+    );
+    const currency = filtered.find((r) => r.cost?.currency)?.cost?.currency ?? "USD";
+    return { totalCost, currency };
+  }
+  cleanup() {
+    const cutoff = Date.now() - this.retentionDays * 24 * 60 * 60 * 1e3;
+    const before = this.records.length;
+    this.records = this.records.filter(
+      (r) => new Date(r.timestamp).getTime() >= cutoff
+    );
+    const removed = before - this.records.length;
+    if (removed > 0) {
+      log4.info({ removed }, "Cleaned up expired usage records");
+      this.scheduleDiskWrite();
+    }
+  }
+  flushSync() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    const data = { version: 1, records: this.records };
+    const dir = path3.dirname(this.filePath);
+    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+    fs4.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+  }
+  destroy() {
+    if (this.debounceTimer) this.flushSync();
+    if (this.cleanupInterval) clearInterval(this.cleanupInterval);
+    if (this.flushHandler) {
+      process.removeListener("SIGTERM", this.flushHandler);
+      process.removeListener("SIGINT", this.flushHandler);
+      process.removeListener("exit", this.flushHandler);
+      this.flushHandler = null;
+    }
+  }
+  load() {
+    if (!fs4.existsSync(this.filePath)) return;
+    try {
+      const raw = JSON.parse(
+        fs4.readFileSync(this.filePath, "utf-8")
+      );
+      if (raw.version !== 1) {
+        log4.warn(
+          { version: raw.version },
+          "Unknown usage store version, skipping load"
+        );
+        return;
+      }
+      this.records = raw.records || [];
+      log4.debug({ count: this.records.length }, "Loaded usage records");
+    } catch (err) {
+      log4.error({ err }, "Failed to load usage store, backing up corrupt file");
+      try {
+        fs4.copyFileSync(this.filePath, this.filePath + ".bak");
+      } catch {
+      }
+      this.records = [];
+    }
+  }
+  getCutoff(period) {
+    const now = /* @__PURE__ */ new Date();
+    switch (period) {
+      case "today": {
+        const start = new Date(now);
+        start.setHours(0, 0, 0, 0);
+        return start.getTime();
+      }
+      case "week":
+        return Date.now() - 7 * 24 * 60 * 60 * 1e3;
+      case "month": {
+        const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+        return startOfMonth.getTime();
+      }
+      case "all":
+        return null;
+    }
+  }
+  scheduleDiskWrite() {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      this.flushSync();
+    }, DEBOUNCE_MS);
+  }
+};
+
+// src/core/usage-budget.ts
+var UsageBudget = class {
+  constructor(store, config, now = () => /* @__PURE__ */ new Date()) {
+    this.store = store;
+    this.config = config;
+    this.now = now;
+    this.lastNotifiedMonth = this.now().getMonth();
+  }
+  lastNotifiedStatus = "ok";
+  lastNotifiedMonth;
+  check() {
+    if (!this.config.monthlyBudget) {
+      return { status: "ok" };
+    }
+    const currentMonth = this.now().getMonth();
+    if (currentMonth !== this.lastNotifiedMonth) {
+      this.lastNotifiedStatus = "ok";
+      this.lastNotifiedMonth = currentMonth;
+    }
+    const { totalCost } = this.store.getMonthlyTotal();
+    const budget = this.config.monthlyBudget;
+    const threshold = this.config.warningThreshold;
+    let status;
+    if (totalCost >= budget) {
+      status = "exceeded";
+    } else if (totalCost >= threshold * budget) {
+      status = "warning";
+    } else {
+      status = "ok";
+    }
+    let message;
+    if (status !== "ok" && status !== this.lastNotifiedStatus) {
+      const pct = Math.round(totalCost / budget * 100);
+      const filled = Math.round(Math.min(totalCost / budget, 1) * 10);
+      const bar = "\u2593".repeat(filled) + "\u2591".repeat(10 - filled);
+      if (status === "warning") {
+        message = `\u26A0\uFE0F <b>Budget Warning</b>
+Monthly usage: $${totalCost.toFixed(2)} / $${budget.toFixed(2)} (${pct}%)
+${bar} ${pct}%`;
+      } else {
+        message = `\u{1F6A8} <b>Budget Exceeded</b>
+Monthly usage: $${totalCost.toFixed(2)} / $${budget.toFixed(2)} (${pct}%)
+${bar} ${pct}%
+Sessions are NOT blocked \u2014 this is a warning only.`;
+      }
+    }
+    this.lastNotifiedStatus = status;
+    return { status, message };
+  }
+  getStatus() {
+    const { totalCost } = this.store.getMonthlyTotal();
+    const budget = this.config.monthlyBudget ?? 0;
+    let status = "ok";
+    if (budget > 0) {
+      if (totalCost >= budget) {
+        status = "exceeded";
+      } else if (totalCost >= this.config.warningThreshold * budget) {
+        status = "warning";
+      }
+    }
+    const percent = budget > 0 ? Math.round(totalCost / budget * 100) : 0;
+    return { status, used: totalCost, budget, percent };
+  }
+};
+
+// src/core/security-guard.ts
+var SecurityGuard = class {
+  constructor(configManager, sessionManager) {
+    this.configManager = configManager;
+    this.sessionManager = sessionManager;
+  }
+  checkAccess(message) {
+    const config = this.configManager.get();
+    if (config.security.allowedUserIds.length > 0) {
+      const userId = String(message.userId);
+      if (!config.security.allowedUserIds.includes(userId)) {
+        return { allowed: false, reason: "Unauthorized user" };
+      }
+    }
+    const active = this.sessionManager.listSessions().filter((s) => s.status === "active" || s.status === "initializing");
+    if (active.length >= config.security.maxConcurrentSessions) {
+      return { allowed: false, reason: `Session limit reached (${config.security.maxConcurrentSessions})` };
+    }
+    return { allowed: true };
+  }
+};
+
+// src/core/session-factory.ts
+import { nanoid as nanoid2 } from "nanoid";
+var log5 = createChildLogger({ module: "session-factory" });
+var SessionFactory = class {
+  constructor(agentManager, sessionManager, speechService, eventBus) {
+    this.agentManager = agentManager;
+    this.sessionManager = sessionManager;
+    this.speechService = speechService;
+    this.eventBus = eventBus;
+  }
+  async create(params) {
+    const agentInstance = params.resumeAgentSessionId ? await this.agentManager.resume(
+      params.agentName,
+      params.workingDirectory,
+      params.resumeAgentSessionId
+    ) : await this.agentManager.spawn(
+      params.agentName,
+      params.workingDirectory
+    );
+    const session = new Session({
+      id: params.existingSessionId,
+      channelId: params.channelId,
+      agentName: params.agentName,
+      workingDirectory: params.workingDirectory,
+      agentInstance,
+      speechService: this.speechService
+    });
+    session.agentSessionId = agentInstance.sessionId;
+    if (params.initialName) {
+      session.name = params.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/speech/speech-service.ts
+var SpeechService = class {
+  constructor(config) {
+    this.config = config;
+  }
+  sttProviders = /* @__PURE__ */ new Map();
+  ttsProviders = /* @__PURE__ */ new Map();
+  registerSTTProvider(name, provider) {
+    this.sttProviders.set(name, provider);
+  }
+  registerTTSProvider(name, provider) {
+    this.ttsProviders.set(name, provider);
+  }
+  isSTTAvailable() {
+    const { provider, providers } = this.config.stt;
+    return provider !== null && providers[provider]?.apiKey !== void 0;
+  }
+  isTTSAvailable() {
+    const provider = this.config.tts.provider;
+    return provider !== null && this.ttsProviders.has(provider);
+  }
+  async transcribe(audioBuffer, mimeType, options) {
+    const providerName = this.config.stt.provider;
+    if (!providerName || !this.config.stt.providers[providerName]?.apiKey) {
+      throw new Error("STT not configured. Set speech.stt.provider and API key in config.");
+    }
+    const provider = this.sttProviders.get(providerName);
+    if (!provider) {
+      throw new Error(`STT provider "${providerName}" not registered. Available: ${[...this.sttProviders.keys()].join(", ") || "none"}`);
+    }
+    return provider.transcribe(audioBuffer, mimeType, options);
+  }
+  async synthesize(text, options) {
+    const providerName = this.config.tts.provider;
+    if (!providerName) {
+      throw new Error("TTS not configured. Set speech.tts.provider in config.");
+    }
+    const provider = this.ttsProviders.get(providerName);
+    if (!provider) {
+      throw new Error(`TTS provider "${providerName}" not registered. Available: ${[...this.ttsProviders.keys()].join(", ") || "none"}`);
+    }
+    return provider.synthesize(text, options);
+  }
+  updateConfig(config) {
+    this.config = config;
+  }
+};
+
+// src/core/speech/providers/groq.ts
+var GROQ_API_URL = "https://api.groq.com/openai/v1/audio/transcriptions";
+var GroqSTT = class {
+  constructor(apiKey, defaultModel = "whisper-large-v3-turbo") {
+    this.apiKey = apiKey;
+    this.defaultModel = defaultModel;
+  }
+  name = "groq";
+  async transcribe(audioBuffer, mimeType, options) {
+    const ext = mimeToExt(mimeType);
+    const form = new FormData();
+    form.append("file", new Blob([new Uint8Array(audioBuffer)], { type: mimeType }), `audio${ext}`);
+    form.append("model", options?.model || this.defaultModel);
+    form.append("response_format", "verbose_json");
+    if (options?.language) {
+      form.append("language", options.language);
+    }
+    const resp = await fetch(GROQ_API_URL, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.apiKey}` },
+      body: form
+    });
+    if (!resp.ok) {
+      const body = await resp.text();
+      if (resp.status === 401) {
+        throw new Error("Invalid Groq API key. Check your key at console.groq.com.");
+      }
+      if (resp.status === 413) {
+        throw new Error("Audio file too large for Groq API (max 25MB).");
+      }
+      if (resp.status === 429) {
+        throw new Error("Groq rate limit exceeded. Free tier: 28,800 seconds/day. Try again later.");
+      }
+      throw new Error(`Groq STT error (${resp.status}): ${body}`);
+    }
+    const data = await resp.json();
+    return {
+      text: data.text,
+      language: data.language,
+      duration: data.duration
+    };
+  }
+};
+function mimeToExt(mimeType) {
+  const map = {
+    "audio/ogg": ".ogg",
+    "audio/wav": ".wav",
+    "audio/mpeg": ".mp3",
+    "audio/mp4": ".m4a",
+    "audio/webm": ".webm",
+    "audio/flac": ".flac"
+  };
+  return map[mimeType] || ".bin";
+}
+
+// src/core/speech/providers/edge-tts.ts
+var DEFAULT_VOICE = "en-US-AriaNeural";
+var EdgeTTS = class {
+  name = "edge-tts";
+  voice;
+  constructor(voice) {
+    this.voice = voice || DEFAULT_VOICE;
+  }
+  async synthesize(text, options) {
+    const { MsEdgeTTS, OUTPUT_FORMAT } = await import("msedge-tts");
+    const tts = new MsEdgeTTS();
+    const voice = options?.voice || this.voice;
+    const format = OUTPUT_FORMAT.AUDIO_24KHZ_48KBITRATE_MONO_MP3;
+    await tts.setMetadata(voice, format);
+    const { audioStream } = tts.toStream(text);
+    const chunks = [];
+    for await (const chunk of audioStream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    tts.close();
+    return {
+      audioBuffer: Buffer.concat(chunks),
+      mimeType: "audio/mpeg"
+    };
+  }
+};
+
+// src/core/core.ts
+import path5 from "path";
+import os from "os";
+
+// src/core/session-store.ts
+import fs5 from "fs";
+import path4 from "path";
+var log6 = createChildLogger({ module: "session-store" });
+var DEBOUNCE_MS2 = 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 = path4.dirname(this.filePath);
+    if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+    fs5.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 (!fs5.existsSync(this.filePath)) return;
+    try {
+      const raw = JSON.parse(
+        fs5.readFileSync(this.filePath, "utf-8")
+      );
+      if (raw.version !== 1) {
+        log6.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);
+      }
+      log6.debug({ count: this.records.size }, "Loaded session records");
+    } catch (err) {
+      log6.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) {
+      log6.info({ removed }, "Cleaned up expired session records");
+      this.scheduleDiskWrite();
+    }
+  }
+  scheduleDiskWrite() {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      this.flushSync();
+    }, DEBOUNCE_MS2);
+  }
+};
+
+// src/core/core.ts
+var log7 = createChildLogger({ module: "core" });
+var OpenACPCore = class {
+  configManager;
+  agentCatalog;
+  agentManager;
+  sessionManager;
+  notificationManager;
+  messageTransformer;
+  fileService;
+  speechService;
+  securityGuard;
+  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;
+  usageStore = null;
+  usageBudget = 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 = path5.join(os.homedir(), ".openacp", "sessions.json");
+    this.sessionStore = new JsonFileSessionStore(
+      storePath,
+      config.sessionStore.ttlDays
+    );
+    this.sessionManager = new SessionManager(this.sessionStore);
+    this.securityGuard = new SecurityGuard(configManager, this.sessionManager);
+    this.notificationManager = new NotificationManager(this.adapters);
+    const usageConfig = config.usage;
+    if (usageConfig.enabled) {
+      const usagePath = path5.join(os.homedir(), ".openacp", "usage.json");
+      this.usageStore = new UsageStore(usagePath, usageConfig.retentionDays);
+      this.usageBudget = new UsageBudget(this.usageStore, usageConfig);
+    }
+    this.messageTransformer = new MessageTransformer();
+    this.eventBus = new EventBus();
+    this.sessionManager.setEventBus(this.eventBus);
+    this.fileService = new FileService(
+      path5.join(os.homedir(), ".openacp", "files")
+    );
+    const speechConfig = config.speech ?? {
+      stt: { provider: null, providers: {} },
+      tts: { provider: "edge-tts", providers: {} }
+    };
+    if (speechConfig.tts.provider == null) {
+      speechConfig.tts.provider = "edge-tts";
+    }
+    this.speechService = new SpeechService(speechConfig);
+    const groqConfig = speechConfig.stt?.providers?.groq;
+    if (groqConfig?.apiKey) {
+      this.speechService.registerSTTProvider(
+        "groq",
+        new GroqSTT(groqConfig.apiKey, groqConfig.model)
+      );
+    }
+    {
+      const edgeConfig = speechConfig.tts?.providers?.["edge-tts"];
+      const voice = edgeConfig?.voice;
+      this.speechService.registerTTSProvider("edge-tts", new EdgeTTS(voice));
+    }
+    this.sessionFactory = new SessionFactory(
+      this.agentManager,
+      this.sessionManager,
+      this.speechService,
+      this.eventBus
+    );
+    this.configManager.on(
+      "config:changed",
+      async ({ path: configPath, value }) => {
+        if (configPath === "logging.level" && typeof value === "string") {
+          const { setLogLevel: setLogLevel2 } = await import("./log-RCVBXLTN.js");
+          setLogLevel2(value);
+          log7.info({ level: value }, "Log level changed at runtime");
+        }
+        if (configPath.startsWith("speech.")) {
+          const newConfig = this.configManager.get();
+          const newSpeechConfig = newConfig.speech ?? {
+            stt: { provider: null, providers: {} },
+            tts: { provider: null, providers: {} }
+          };
+          this.speechService.updateConfig(newSpeechConfig);
+          const groqCfg = newSpeechConfig.stt?.providers?.groq;
+          if (groqCfg?.apiKey) {
+            this.speechService.registerSTTProvider(
+              "groq",
+              new GroqSTT(groqCfg.apiKey, groqCfg.model)
+            );
+          }
+          {
+            const edgeConfig = newSpeechConfig.tts?.providers?.["edge-tts"];
+            const voice = edgeConfig?.voice;
+            this.speechService.registerTTSProvider("edge-tts", new EdgeTTS(voice));
+          }
+          log7.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) => {
+      log7.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();
+    }
+  }
+  // --- Archive ---
+  async archiveSession(sessionId) {
+    const session = this.sessionManager.getSession(sessionId);
+    if (!session) return { ok: false, error: "Session not found" };
+    if (session.status === "initializing")
+      return { ok: false, error: "Session is still initializing" };
+    if (session.status !== "active")
+      return { ok: false, error: `Session is ${session.status}` };
+    const adapter = this.adapters.get(session.channelId);
+    if (!adapter) return { ok: false, error: "Adapter not found for session" };
+    try {
+      const result = await adapter.archiveSessionTopic(session.id);
+      if (!result)
+        return { ok: false, error: "Adapter does not support archiving" };
+      return { ok: true, newThreadId: result.newThreadId };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  }
+  // --- Message Routing ---
+  async handleMessage(message) {
+    log7.debug(
+      {
+        channelId: message.channelId,
+        threadId: message.threadId,
+        userId: message.userId
+      },
+      "Incoming message"
+    );
+    const access = this.securityGuard.checkAccess(message);
+    if (!access.allowed) {
+      log7.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) {
+      log7.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
+    });
+    log7.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;
+    log7.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: existsSync2 } = await import("fs");
+    if (!existsSync2(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
+    );
+  }
+  // --- 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) {
+      log7.debug(
+        { threadId: message.threadId, channelId: message.channelId },
+        "No session record found for thread"
+      );
+      return null;
+    }
+    if (record.status === "error") {
+      log7.debug(
+        {
+          threadId: message.threadId,
+          sessionId: record.sessionId,
+          status: record.status
+        },
+        "Skipping resume of error session"
+      );
+      return null;
+    }
+    log7.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;
+        log7.info(
+          { sessionId: session.id, threadId: message.threadId },
+          "Lazy resume successful"
+        );
+        return session;
+      } catch (err) {
+        log7.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
+    });
+  }
+};
+
+// src/core/sse-manager.ts
+var SSEManager = class {
+  constructor(eventBus, getSessionStats, startedAt) {
+    this.eventBus = eventBus;
+    this.getSessionStats = getSessionStats;
+    this.startedAt = startedAt;
+  }
+  sseConnections = /* @__PURE__ */ new Set();
+  sseCleanupHandlers = /* @__PURE__ */ new Map();
+  healthInterval;
+  boundHandlers = [];
+  setup() {
+    if (!this.eventBus) return;
+    const events = [
+      "session:created",
+      "session:updated",
+      "session:deleted",
+      "agent:event",
+      "permission:request"
+    ];
+    for (const eventName of events) {
+      const handler = (data) => {
+        this.broadcast(eventName, data);
+      };
+      this.eventBus.on(eventName, handler);
+      this.boundHandlers.push({ event: eventName, handler });
+    }
+    this.healthInterval = setInterval(() => {
+      const mem = process.memoryUsage();
+      const stats = this.getSessionStats();
+      this.broadcast("health", {
+        uptime: Date.now() - this.startedAt,
+        memory: {
+          rss: mem.rss,
+          heapUsed: mem.heapUsed,
+          heapTotal: mem.heapTotal
+        },
+        sessions: stats
+      });
+    }, 3e4);
+  }
+  handleRequest(req, res) {
+    const parsedUrl = new URL(req.url || "", "http://localhost");
+    const sessionFilter = parsedUrl.searchParams.get("sessionId");
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    res.flushHeaders();
+    res.sessionFilter = sessionFilter ?? void 0;
+    this.sseConnections.add(res);
+    const cleanup = () => {
+      this.sseConnections.delete(res);
+      this.sseCleanupHandlers.delete(res);
+    };
+    this.sseCleanupHandlers.set(res, cleanup);
+    req.on("close", cleanup);
+  }
+  broadcast(event, data) {
+    const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+    const sessionEvents = [
+      "agent:event",
+      "permission:request",
+      "session:updated"
+    ];
+    for (const res of this.sseConnections) {
+      const filter = res.sessionFilter;
+      if (filter && sessionEvents.includes(event)) {
+        const eventData = data;
+        if (eventData.sessionId !== filter) continue;
+      }
+      try {
+        if (res.writable) res.write(payload);
+      } catch {
+      }
+    }
+  }
+  stop() {
+    if (this.healthInterval) clearInterval(this.healthInterval);
+    if (this.eventBus) {
+      for (const { event, handler } of this.boundHandlers) {
+        this.eventBus.off(event, handler);
+      }
+    }
+    this.boundHandlers = [];
+    const entries = [...this.sseCleanupHandlers];
+    for (const [res, cleanup] of entries) {
+      res.end();
+      cleanup();
+    }
+  }
+};
+
+// src/core/static-server.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { fileURLToPath } from "url";
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+var StaticServer = class {
+  uiDir;
+  constructor(uiDir) {
+    this.uiDir = uiDir;
+    if (!this.uiDir) {
+      const __filename = fileURLToPath(import.meta.url);
+      const candidate = path6.resolve(path6.dirname(__filename), "../../ui/dist");
+      if (fs6.existsSync(path6.join(candidate, "index.html"))) {
+        this.uiDir = candidate;
+      }
+      if (!this.uiDir) {
+        const publishCandidate = path6.resolve(
+          path6.dirname(__filename),
+          "../ui"
+        );
+        if (fs6.existsSync(path6.join(publishCandidate, "index.html"))) {
+          this.uiDir = publishCandidate;
+        }
+      }
+    }
+  }
+  isAvailable() {
+    return this.uiDir !== void 0;
+  }
+  serve(req, res) {
+    if (!this.uiDir) return false;
+    const urlPath = (req.url || "/").split("?")[0];
+    const safePath = path6.normalize(urlPath);
+    const filePath = path6.join(this.uiDir, safePath);
+    if (!filePath.startsWith(this.uiDir + path6.sep) && filePath !== this.uiDir)
+      return false;
+    if (fs6.existsSync(filePath) && fs6.statSync(filePath).isFile()) {
+      const ext = path6.extname(filePath);
+      const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+      const isHashed = /\.[a-zA-Z0-9]{8,}\.(js|css)$/.test(filePath);
+      const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "no-cache";
+      res.writeHead(200, {
+        "Content-Type": contentType,
+        "Cache-Control": cacheControl
+      });
+      fs6.createReadStream(filePath).pipe(res);
+      return true;
+    }
+    const indexPath = path6.join(this.uiDir, "index.html");
+    if (fs6.existsSync(indexPath)) {
+      res.writeHead(200, {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-cache"
+      });
+      fs6.createReadStream(indexPath).pipe(res);
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/core/api/index.ts
+import * as http from "http";
+import * as fs7 from "fs";
+import * as path7 from "path";
+import * as os2 from "os";
+import * as crypto from "crypto";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/core/api/router.ts
+var Router = class {
+  routes = [];
+  get(path8, handler) {
+    this.add("GET", path8, handler);
+  }
+  post(path8, handler) {
+    this.add("POST", path8, handler);
+  }
+  put(path8, handler) {
+    this.add("PUT", path8, handler);
+  }
+  patch(path8, handler) {
+    this.add("PATCH", path8, handler);
+  }
+  delete(path8, handler) {
+    this.add("DELETE", path8, handler);
+  }
+  match(method, url) {
+    const pathname = url.split("?")[0];
+    for (const route of this.routes) {
+      if (route.method !== method) continue;
+      const m = pathname.match(route.pattern);
+      if (!m) continue;
+      const params = {};
+      for (let i = 0; i < route.keys.length; i++) {
+        params[route.keys[i]] = m[i + 1];
+      }
+      return { handler: route.handler, params };
+    }
+    return null;
+  }
+  add(method, path8, handler) {
+    const keys = [];
+    const pattern = path8.replace(/:(\w+)/g, (_, key) => {
+      keys.push(key);
+      return "([^/]+)";
+    });
+    this.routes.push({
+      method,
+      pattern: new RegExp(`^${pattern}$`),
+      keys,
+      handler
+    });
+  }
+};
+
+// src/core/api/routes/health.ts
+function registerHealthRoutes(router, deps) {
+  router.get("/api/health", async (_req, res) => {
+    const activeSessions = deps.core.sessionManager.listSessions();
+    const allRecords = deps.core.sessionManager.listRecords();
+    const mem = process.memoryUsage();
+    const tunnel = deps.core.tunnelService;
+    deps.sendJson(res, 200, {
+      status: "ok",
+      uptime: Date.now() - deps.startedAt,
+      version: deps.getVersion(),
+      memory: {
+        rss: mem.rss,
+        heapUsed: mem.heapUsed,
+        heapTotal: mem.heapTotal
+      },
+      sessions: {
+        active: activeSessions.filter(
+          (s) => s.status === "active" || s.status === "initializing"
+        ).length,
+        total: allRecords.length
+      },
+      adapters: Array.from(deps.core.adapters.keys()),
+      tunnel: tunnel ? { enabled: true, url: tunnel.getPublicUrl() } : { enabled: false }
+    });
+  });
+  router.get("/api/version", async (_req, res) => {
+    deps.sendJson(res, 200, { version: deps.getVersion() });
+  });
+  router.post("/api/restart", async (_req, res) => {
+    if (!deps.core.requestRestart) {
+      deps.sendJson(res, 501, { error: "Restart not available" });
+      return;
+    }
+    deps.sendJson(res, 200, { ok: true, message: "Restarting..." });
+    setImmediate(() => deps.core.requestRestart());
+  });
+  router.get("/api/adapters", async (_req, res) => {
+    const adapters = Array.from(deps.core.adapters.entries()).map(([name]) => ({
+      name,
+      type: "built-in"
+    }));
+    deps.sendJson(res, 200, { adapters });
+  });
+}
+
+// src/core/api/routes/sessions.ts
+var log8 = createChildLogger({ module: "api-server" });
+function registerSessionRoutes(router, deps) {
+  router.post("/api/sessions/adopt", async (req, res) => {
+    const body = await deps.readBody(req);
+    if (body === null) {
+      return deps.sendJson(res, 413, { error: "Request body too large" });
+    }
+    if (!body) {
+      return deps.sendJson(res, 400, {
+        error: "bad_request",
+        message: "Empty request body"
+      });
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      return deps.sendJson(res, 400, {
+        error: "bad_request",
+        message: "Invalid JSON"
+      });
+    }
+    const { agent, agentSessionId, cwd, channel } = parsed;
+    if (!agent || !agentSessionId) {
+      return deps.sendJson(res, 400, {
+        error: "bad_request",
+        message: "Missing required fields: agent, agentSessionId"
+      });
+    }
+    const result = await deps.core.adoptSession(
+      agent,
+      agentSessionId,
+      cwd ?? process.cwd(),
+      channel
+    );
+    if (result.ok) {
+      return deps.sendJson(res, 200, result);
+    } else {
+      const status = result.error === "session_limit" ? 429 : result.error === "agent_not_supported" ? 400 : 500;
+      return deps.sendJson(res, status, result);
+    }
+  });
+  router.post("/api/sessions", async (req, res) => {
+    const body = await deps.readBody(req);
+    let agent;
+    let workspace;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        agent = parsed.agent;
+        workspace = parsed.workspace;
+      } catch {
+        deps.sendJson(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+    }
+    const config = deps.core.configManager.get();
+    const activeSessions = deps.core.sessionManager.listSessions().filter((s) => s.status === "active" || s.status === "initializing");
+    if (activeSessions.length >= config.security.maxConcurrentSessions) {
+      deps.sendJson(res, 429, {
+        error: `Max concurrent sessions (${config.security.maxConcurrentSessions}) reached. Cancel a session first.`
+      });
+      return;
+    }
+    const [adapterId, adapter] = deps.core.adapters.entries().next().value ?? [
+      null,
+      null
+    ];
+    const channelId = adapterId ?? "api";
+    const resolvedAgent = agent || config.defaultAgent;
+    const resolvedWorkspace = deps.core.configManager.resolveWorkspace(
+      workspace || config.agents[resolvedAgent]?.workingDirectory
+    );
+    const session = await deps.core.createSession({
+      channelId,
+      agentName: resolvedAgent,
+      workingDirectory: resolvedWorkspace,
+      createThread: !!adapter,
+      initialName: `\u{1F504} ${resolvedAgent} \u2014 New Session`
+    });
+    if (!adapter) {
+      session.agentInstance.onPermissionRequest = async (request) => {
+        const allowOption = request.options.find((o) => o.isAllow);
+        log8.debug(
+          {
+            sessionId: session.id,
+            permissionId: request.id,
+            option: allowOption?.id
+          },
+          "Auto-approving permission for API session"
+        );
+        return allowOption?.id ?? request.options[0]?.id ?? "";
+      };
+    }
+    session.warmup().catch(
+      (err) => log8.warn({ err, sessionId: session.id }, "API session warmup failed")
+    );
+    deps.sendJson(res, 200, {
+      sessionId: session.id,
+      agent: session.agentName,
+      status: session.status,
+      workspace: session.workingDirectory
+    });
+  });
+  router.post("/api/sessions/:sessionId/prompt", async (req, res, params) => {
+    const sessionId = decodeURIComponent(params.sessionId);
+    const session = deps.core.sessionManager.getSession(sessionId);
+    if (!session) {
+      deps.sendJson(res, 404, { error: `Session "${sessionId}" not found` });
+      return;
+    }
+    if (session.status === "cancelled" || session.status === "finished" || session.status === "error") {
+      deps.sendJson(res, 400, { error: `Session is ${session.status}` });
+      return;
+    }
+    const body = await deps.readBody(req);
+    let prompt;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        prompt = parsed.prompt;
+      } catch {
+        deps.sendJson(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+    }
+    if (!prompt) {
+      deps.sendJson(res, 400, { error: "Missing prompt" });
+      return;
+    }
+    session.enqueuePrompt(prompt).catch(() => {
+    });
+    deps.sendJson(res, 200, {
+      ok: true,
+      sessionId,
+      queueDepth: session.queueDepth
+    });
+  });
+  router.post(
+    "/api/sessions/:sessionId/permission",
+    async (req, res, params) => {
+      const sessionId = decodeURIComponent(params.sessionId);
+      const session = deps.core.sessionManager.getSession(sessionId);
+      if (!session) {
+        deps.sendJson(res, 404, { error: `Session "${sessionId}" not found` });
+        return;
+      }
+      const body = await deps.readBody(req);
+      let permissionId;
+      let optionId;
+      if (body) {
+        try {
+          const parsed = JSON.parse(body);
+          permissionId = parsed.permissionId;
+          optionId = parsed.optionId;
+        } catch {
+          deps.sendJson(res, 400, { error: "Invalid JSON body" });
+          return;
+        }
+      }
+      if (!permissionId || !optionId) {
+        deps.sendJson(res, 400, {
+          error: "Missing permissionId or optionId"
+        });
+        return;
+      }
+      if (!session.permissionGate.isPending || session.permissionGate.requestId !== permissionId) {
+        deps.sendJson(res, 400, {
+          error: "No matching pending permission request"
+        });
+        return;
+      }
+      session.permissionGate.resolve(optionId);
+      deps.sendJson(res, 200, { ok: true });
+    }
+  );
+  router.patch(
+    "/api/sessions/:sessionId/dangerous",
+    async (req, res, params) => {
+      const sessionId = decodeURIComponent(params.sessionId);
+      const session = deps.core.sessionManager.getSession(sessionId);
+      if (!session) {
+        deps.sendJson(res, 404, { error: `Session "${sessionId}" not found` });
+        return;
+      }
+      const body = await deps.readBody(req);
+      let enabled;
+      if (body) {
+        try {
+          const parsed = JSON.parse(body);
+          enabled = parsed.enabled;
+        } catch {
+          deps.sendJson(res, 400, { error: "Invalid JSON body" });
+          return;
+        }
+      }
+      if (typeof enabled !== "boolean") {
+        deps.sendJson(res, 400, { error: "Missing enabled boolean" });
+        return;
+      }
+      session.dangerousMode = enabled;
+      await deps.core.sessionManager.patchRecord(sessionId, {
+        dangerousMode: enabled
+      });
+      deps.sendJson(res, 200, { ok: true, dangerousMode: enabled });
+    }
+  );
+  router.get("/api/sessions/:sessionId", async (_req, res, params) => {
+    const sessionId = decodeURIComponent(params.sessionId);
+    const session = deps.core.sessionManager.getSession(sessionId);
+    if (!session) {
+      deps.sendJson(res, 404, { error: `Session "${sessionId}" not found` });
+      return;
+    }
+    deps.sendJson(res, 200, {
+      session: {
+        id: session.id,
+        agent: session.agentName,
+        status: session.status,
+        name: session.name ?? null,
+        workspace: session.workingDirectory,
+        createdAt: session.createdAt.toISOString(),
+        dangerousMode: session.dangerousMode,
+        queueDepth: session.queueDepth,
+        promptRunning: session.promptRunning,
+        threadId: session.threadId,
+        channelId: session.channelId,
+        agentSessionId: session.agentSessionId
+      }
+    });
+  });
+  router.post("/api/sessions/:sessionId/archive", async (_req, res, params) => {
+    const sessionId = decodeURIComponent(params.sessionId);
+    const result = await deps.core.archiveSession(sessionId);
+    if (result.ok) {
+      deps.sendJson(res, 200, result);
+    } else {
+      deps.sendJson(res, 400, result);
+    }
+  });
+  router.delete("/api/sessions/:sessionId", async (_req, res, params) => {
+    const sessionId = decodeURIComponent(params.sessionId);
+    const session = deps.core.sessionManager.getSession(sessionId);
+    if (!session) {
+      deps.sendJson(res, 404, { error: `Session "${sessionId}" not found` });
+      return;
+    }
+    await deps.core.sessionManager.cancelSession(sessionId);
+    deps.sendJson(res, 200, { ok: true });
+  });
+  router.get("/api/sessions", async (_req, res) => {
+    const sessions = deps.core.sessionManager.listSessions();
+    deps.sendJson(res, 200, {
+      sessions: sessions.map((s) => ({
+        id: s.id,
+        agent: s.agentName,
+        status: s.status,
+        name: s.name ?? null,
+        workspace: s.workingDirectory,
+        createdAt: s.createdAt.toISOString(),
+        dangerousMode: s.dangerousMode,
+        queueDepth: s.queueDepth,
+        promptRunning: s.promptRunning,
+        lastActiveAt: deps.core.sessionManager.getSessionRecord(s.id)?.lastActiveAt ?? null
+      }))
+    });
+  });
+}
+
+// src/core/api/routes/config.ts
+var SENSITIVE_KEYS = [
+  "botToken",
+  "token",
+  "apiKey",
+  "secret",
+  "password",
+  "webhookSecret"
+];
+function redactConfig(config) {
+  const redacted = structuredClone(config);
+  redactDeep(redacted);
+  return redacted;
+}
+function redactDeep(obj) {
+  for (const [key, value] of Object.entries(obj)) {
+    if (SENSITIVE_KEYS.includes(key) && typeof value === "string") {
+      obj[key] = "***";
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item && typeof item === "object")
+          redactDeep(item);
+      }
+    } else if (value && typeof value === "object") {
+      redactDeep(value);
+    }
+  }
+}
+function registerConfigRoutes(router, deps) {
+  router.get("/api/config/editable", async (_req, res) => {
+    const { getSafeFields: getSafeFields2, resolveOptions: resolveOptions2, getConfigValue: getConfigValue2 } = await import("./config-registry-7I6GGDOY.js");
+    const config = deps.core.configManager.get();
+    const safeFields = getSafeFields2();
+    const fields = safeFields.map((def) => ({
+      path: def.path,
+      displayName: def.displayName,
+      group: def.group,
+      type: def.type,
+      options: resolveOptions2(def, config),
+      value: getConfigValue2(config, def.path),
+      hotReload: def.hotReload
+    }));
+    deps.sendJson(res, 200, { fields });
+  });
+  router.get("/api/config", async (_req, res) => {
+    const config = deps.core.configManager.get();
+    deps.sendJson(res, 200, { config: redactConfig(config) });
+  });
+  router.patch("/api/config", async (req, res) => {
+    const body = await deps.readBody(req);
+    let configPath;
+    let value;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        configPath = parsed.path;
+        value = parsed.value;
+      } catch {
+        deps.sendJson(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+    }
+    if (!configPath) {
+      deps.sendJson(res, 400, { error: "Missing path" });
+      return;
+    }
+    const BLOCKED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+    const parts = configPath.split(".");
+    if (parts.some((p) => BLOCKED_KEYS.has(p))) {
+      deps.sendJson(res, 400, { error: "Invalid config path" });
+      return;
+    }
+    const { getFieldDef: getFieldDef2 } = await import("./config-registry-7I6GGDOY.js");
+    const fieldDef = getFieldDef2(configPath);
+    if (!fieldDef || fieldDef.scope !== "safe") {
+      deps.sendJson(res, 403, {
+        error: "This config field cannot be modified via the API"
+      });
+      return;
+    }
+    const currentConfig = deps.core.configManager.get();
+    const cloned = structuredClone(currentConfig);
+    let target = cloned;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (target[part] && typeof target[part] === "object" && !Array.isArray(target[part])) {
+        target = target[part];
+      } else if (target[part] === void 0 || target[part] === null) {
+        target[part] = {};
+        target = target[part];
+      } else {
+        deps.sendJson(res, 400, { error: "Invalid config path" });
+        return;
+      }
+    }
+    const lastKey = parts[parts.length - 1];
+    target[lastKey] = value;
+    const { ConfigSchema } = await import("./config-B26J3XXN.js");
+    const result = ConfigSchema.safeParse(cloned);
+    if (!result.success) {
+      deps.sendJson(res, 400, {
+        error: "Validation failed",
+        details: result.error.issues.map((i) => ({
+          path: i.path.join("."),
+          message: i.message
+        }))
+      });
+      return;
+    }
+    const updates = {};
+    let updateTarget = updates;
+    for (let i = 0; i < parts.length - 1; i++) {
+      updateTarget[parts[i]] = {};
+      updateTarget = updateTarget[parts[i]];
+    }
+    updateTarget[lastKey] = value;
+    await deps.core.configManager.save(updates, configPath);
+    const { isHotReloadable: isHotReloadable2 } = await import("./config-registry-7I6GGDOY.js");
+    const needsRestart = !isHotReloadable2(configPath);
+    deps.sendJson(res, 200, {
+      ok: true,
+      needsRestart,
+      config: redactConfig(deps.core.configManager.get())
+    });
+  });
+}
+
+// src/core/api/routes/topics.ts
+function registerTopicRoutes(router, deps) {
+  router.get("/api/topics", async (req, res) => {
+    if (!deps.topicManager) {
+      deps.sendJson(res, 501, { error: "Topic management not available" });
+      return;
+    }
+    const url = req.url || "";
+    const params = new URL(url, "http://localhost").searchParams;
+    const statusParam = params.get("status");
+    const filter = statusParam ? { statuses: statusParam.split(",") } : void 0;
+    const topics = deps.topicManager.listTopics(filter);
+    deps.sendJson(res, 200, { topics });
+  });
+  router.post("/api/topics/cleanup", async (req, res) => {
+    if (!deps.topicManager) {
+      deps.sendJson(res, 501, { error: "Topic management not available" });
+      return;
+    }
+    const body = await deps.readBody(req);
+    let statuses;
+    if (body) {
+      try {
+        statuses = JSON.parse(body).statuses;
+      } catch {
+      }
+    }
+    const result = await deps.topicManager.cleanup(statuses);
+    deps.sendJson(res, 200, result);
+  });
+  router.delete("/api/topics/:sessionId", async (req, res, params) => {
+    if (!deps.topicManager) {
+      deps.sendJson(res, 501, { error: "Topic management not available" });
+      return;
+    }
+    const sessionId = decodeURIComponent(params.sessionId);
+    const url = req.url || "";
+    const urlParams = new URL(url, "http://localhost").searchParams;
+    const force = urlParams.get("force") === "true";
+    const result = await deps.topicManager.deleteTopic(
+      sessionId,
+      force ? { confirmed: true } : void 0
+    );
+    if (result.ok) {
+      deps.sendJson(res, 200, result);
+    } else if (result.needsConfirmation) {
+      deps.sendJson(res, 409, {
+        error: "Session is active",
+        needsConfirmation: true,
+        session: result.session
+      });
+    } else if (result.error === "Cannot delete system topic") {
+      deps.sendJson(res, 403, { error: result.error });
+    } else {
+      deps.sendJson(res, 404, { error: result.error ?? "Not found" });
+    }
+  });
+}
+
+// src/core/api/routes/tunnel.ts
+function registerTunnelRoutes(router, deps) {
+  router.get("/api/tunnel", async (_req, res) => {
+    const tunnel = deps.core.tunnelService;
+    if (tunnel) {
+      deps.sendJson(res, 200, {
+        enabled: true,
+        url: tunnel.getPublicUrl(),
+        provider: deps.core.configManager.get().tunnel.provider
+      });
+    } else {
+      deps.sendJson(res, 200, { enabled: false });
+    }
+  });
+  router.get("/api/tunnel/list", async (_req, res) => {
+    const tunnel = deps.core.tunnelService;
+    if (!tunnel) {
+      deps.sendJson(res, 200, []);
+      return;
+    }
+    deps.sendJson(res, 200, tunnel.listTunnels());
+  });
+  router.post("/api/tunnel", async (req, res) => {
+    const tunnel = deps.core.tunnelService;
+    if (!tunnel) {
+      deps.sendJson(res, 400, { error: "Tunnel service is not enabled" });
+      return;
+    }
+    const body = await deps.readBody(req);
+    if (body === null) {
+      deps.sendJson(res, 413, { error: "Request body too large" });
+      return;
+    }
+    if (!body) {
+      deps.sendJson(res, 400, { error: "Missing request body" });
+      return;
+    }
+    try {
+      const { port, label, sessionId } = JSON.parse(body);
+      if (!port || typeof port !== "number") {
+        deps.sendJson(res, 400, {
+          error: "port is required and must be a number"
+        });
+        return;
+      }
+      const entry = await tunnel.addTunnel(port, { label, sessionId });
+      deps.sendJson(res, 200, entry);
+    } catch (err) {
+      deps.sendJson(res, 400, { error: err.message });
+    }
+  });
+  router.delete("/api/tunnel/:port", async (_req, res, params) => {
+    const tunnel = deps.core.tunnelService;
+    if (!tunnel) {
+      deps.sendJson(res, 400, { error: "Tunnel service is not enabled" });
+      return;
+    }
+    const port = parseInt(params.port, 10);
+    try {
+      await tunnel.stopTunnel(port);
+      deps.sendJson(res, 200, { ok: true });
+    } catch (err) {
+      deps.sendJson(res, 400, { error: err.message });
+    }
+  });
+  router.delete("/api/tunnel", async (_req, res) => {
+    const tunnel = deps.core.tunnelService;
+    if (!tunnel) {
+      deps.sendJson(res, 400, { error: "Tunnel service is not enabled" });
+      return;
+    }
+    const count = tunnel.listTunnels().length;
+    await tunnel.stopAllUser();
+    deps.sendJson(res, 200, { ok: true, stopped: count });
+  });
+}
+
+// src/core/api/routes/agents.ts
+function registerAgentRoutes(router, deps) {
+  router.get("/api/agents", async (_req, res) => {
+    const agents = deps.core.agentManager.getAvailableAgents();
+    const defaultAgent = deps.core.configManager.get().defaultAgent;
+    const agentsWithCaps = agents.map((a) => ({
+      ...a,
+      capabilities: getAgentCapabilities(a.name)
+    }));
+    deps.sendJson(res, 200, { agents: agentsWithCaps, default: defaultAgent });
+  });
+}
+
+// src/core/api/routes/notify.ts
+function registerNotifyRoutes(router, deps) {
+  router.post("/api/notify", async (req, res) => {
+    const body = await deps.readBody(req);
+    let message;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        message = parsed.message;
+      } catch {
+        deps.sendJson(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+    }
+    if (!message) {
+      deps.sendJson(res, 400, { error: "Missing message" });
+      return;
+    }
+    await deps.core.notificationManager.notifyAll({
+      sessionId: "system",
+      type: "completed",
+      summary: message
+    });
+    deps.sendJson(res, 200, { ok: true });
+  });
+}
+
+// src/core/api/index.ts
+var log9 = createChildLogger({ module: "api-server" });
+var DEFAULT_PORT_FILE = path7.join(os2.homedir(), ".openacp", "api.port");
+var cachedVersion;
+function getVersion() {
+  if (cachedVersion) return cachedVersion;
+  try {
+    const __filename = fileURLToPath2(import.meta.url);
+    const pkgPath = path7.resolve(
+      path7.dirname(__filename),
+      "../../../package.json"
+    );
+    const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+    cachedVersion = pkg.version ?? "0.0.0-dev";
+  } catch {
+    cachedVersion = "0.0.0-dev";
+  }
+  return cachedVersion;
+}
+var ApiServer = class {
+  constructor(core, config, portFilePath, topicManager, secretFilePath, uiDir) {
+    this.core = core;
+    this.config = config;
+    this.topicManager = topicManager;
+    this.portFilePath = portFilePath ?? DEFAULT_PORT_FILE;
+    this.secretFilePath = secretFilePath ?? path7.join(os2.homedir(), ".openacp", "api-secret");
+    this.staticServer = new StaticServer(uiDir);
+    this.sseManager = new SSEManager(
+      core.eventBus,
+      () => {
+        const sessions = this.core.sessionManager.listSessions();
+        return {
+          active: sessions.filter(
+            (s) => s.status === "active" || s.status === "initializing"
+          ).length,
+          total: sessions.length
+        };
+      },
+      this.startedAt
+    );
+    this.router = new Router();
+    const deps = {
+      core: this.core,
+      topicManager: this.topicManager,
+      startedAt: this.startedAt,
+      getVersion,
+      sendJson: this.sendJson.bind(this),
+      readBody: this.readBody.bind(this)
+    };
+    registerHealthRoutes(this.router, deps);
+    registerSessionRoutes(this.router, deps);
+    registerConfigRoutes(this.router, deps);
+    registerTopicRoutes(this.router, deps);
+    registerTunnelRoutes(this.router, deps);
+    registerAgentRoutes(this.router, deps);
+    registerNotifyRoutes(this.router, deps);
+  }
+  server = null;
+  actualPort = 0;
+  portFilePath;
+  startedAt = Date.now();
+  secret = "";
+  secretFilePath;
+  sseManager;
+  staticServer;
+  router;
+  async start() {
+    this.loadOrCreateSecret();
+    this.server = http.createServer((req, res) => this.handleRequest(req, res));
+    await new Promise((resolve3, reject) => {
+      this.server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          log9.warn(
+            { port: this.config.port },
+            "API port in use, continuing without API server"
+          );
+          this.server = null;
+          resolve3();
+        } else {
+          reject(err);
+        }
+      });
+      this.server.listen(this.config.port, this.config.host, () => {
+        const addr = this.server.address();
+        if (addr && typeof addr === "object") {
+          this.actualPort = addr.port;
+        }
+        this.writePortFile();
+        log9.info(
+          { host: this.config.host, port: this.actualPort },
+          "API server listening"
+        );
+        this.sseManager.setup();
+        if (this.config.host !== "127.0.0.1" && this.config.host !== "localhost") {
+          log9.warn(
+            "API server binding to non-localhost. Ensure api-secret file is secured."
+          );
+        }
+        resolve3();
+      });
+    });
+  }
+  async stop() {
+    this.sseManager.stop();
+    this.removePortFile();
+    if (this.server) {
+      await new Promise((resolve3) => {
+        this.server.close(() => resolve3());
+      });
+      this.server = null;
+    }
+  }
+  getPort() {
+    return this.actualPort;
+  }
+  getSecret() {
+    return this.secret;
+  }
+  writePortFile() {
+    const dir = path7.dirname(this.portFilePath);
+    fs7.mkdirSync(dir, { recursive: true });
+    fs7.writeFileSync(this.portFilePath, String(this.actualPort));
+  }
+  removePortFile() {
+    try {
+      fs7.unlinkSync(this.portFilePath);
+    } catch {
+    }
+  }
+  loadOrCreateSecret() {
+    const dir = path7.dirname(this.secretFilePath);
+    fs7.mkdirSync(dir, { recursive: true });
+    try {
+      this.secret = fs7.readFileSync(this.secretFilePath, "utf-8").trim();
+      if (this.secret) {
+        try {
+          const stat = fs7.statSync(this.secretFilePath);
+          const mode = stat.mode & 511;
+          if (mode & 63) {
+            log9.warn(
+              { path: this.secretFilePath, mode: "0" + mode.toString(8) },
+              "API secret file has insecure permissions (should be 0600). Run: chmod 600 %s",
+              this.secretFilePath
+            );
+          }
+        } catch {
+        }
+        return;
+      }
+    } catch {
+    }
+    this.secret = crypto.randomBytes(32).toString("hex");
+    fs7.writeFileSync(this.secretFilePath, this.secret, { mode: 384 });
+  }
+  authenticate(req, allowQueryParam = false) {
+    const authHeader = req.headers.authorization;
+    if (authHeader?.startsWith("Bearer ")) {
+      const token = authHeader.slice(7);
+      if (token.length === this.secret.length && crypto.timingSafeEqual(
+        Buffer.from(token, "utf-8"),
+        Buffer.from(this.secret, "utf-8")
+      )) {
+        return true;
+      }
+    }
+    if (allowQueryParam) {
+      const parsedUrl = new URL(req.url || "", "http://localhost");
+      const qToken = parsedUrl.searchParams.get("token");
+      if (qToken && qToken.length === this.secret.length && crypto.timingSafeEqual(
+        Buffer.from(qToken, "utf-8"),
+        Buffer.from(this.secret, "utf-8")
+      )) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async handleRequest(req, res) {
+    const method = req.method?.toUpperCase();
+    const url = req.url || "";
+    if (url.startsWith("/api/")) {
+      const isExempt = method === "GET" && (url === "/api/health" || url === "/api/version" || url.startsWith("/api/events"));
+      if (!isExempt && !this.authenticate(req)) {
+        this.sendJson(res, 401, { error: "Unauthorized" });
+        return;
+      }
+    }
+    try {
+      if (method === "GET" && url.startsWith("/api/events")) {
+        if (!this.authenticate(req, true)) {
+          this.sendJson(res, 401, { error: "Unauthorized" });
+          return;
+        }
+        this.sseManager.handleRequest(req, res);
+        return;
+      }
+      if (url.startsWith("/api/")) {
+        const match = this.router.match(method, url);
+        if (match) {
+          await match.handler(req, res, match.params);
+        } else {
+          this.sendJson(res, 404, { error: "Not found" });
+        }
+        return;
+      }
+      if (!this.staticServer.serve(req, res)) {
+        this.sendJson(res, 404, { error: "Not found" });
+      }
+    } catch (err) {
+      log9.error({ err }, "API request error");
+      this.sendJson(res, 500, { error: "Internal server error" });
+    }
+  }
+  sendJson(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+  }
+  readBody(req) {
+    const MAX_BODY_SIZE = 1024 * 1024;
+    return new Promise((resolve3) => {
+      let data = "";
+      let size = 0;
+      let destroyed = false;
+      req.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > MAX_BODY_SIZE && !destroyed) {
+          destroyed = true;
+          req.destroy();
+          resolve3(null);
+          return;
+        }
+        if (!destroyed) data += chunk;
+      });
+      req.on("end", () => {
+        if (!destroyed) resolve3(data);
+      });
+      req.on("error", () => {
+        if (!destroyed) resolve3("");
+      });
+    });
+  }
+};
+
+// src/core/topic-manager.ts
+var log10 = createChildLogger({ module: "topic-manager" });
+var TopicManager = class {
+  constructor(sessionManager, adapter, systemTopicIds) {
+    this.sessionManager = sessionManager;
+    this.adapter = adapter;
+    this.systemTopicIds = systemTopicIds;
+  }
+  listTopics(filter) {
+    const records = this.sessionManager.listRecords(filter);
+    return records.filter((r) => !this.isSystemTopic(r)).filter((r) => !filter?.statuses?.length || filter.statuses.includes(r.status)).map((r) => ({
+      sessionId: r.sessionId,
+      topicId: r.platform?.topicId ?? null,
+      name: r.name ?? null,
+      status: r.status,
+      agentName: r.agentName,
+      lastActiveAt: r.lastActiveAt
+    }));
+  }
+  async deleteTopic(sessionId, options) {
+    const records = this.sessionManager.listRecords();
+    const record = records.find((r) => r.sessionId === sessionId);
+    if (!record) return { ok: false, error: "Session not found" };
+    if (this.isSystemTopic(record)) return { ok: false, error: "Cannot delete system topic" };
+    const isActive = record.status === "active" || record.status === "initializing";
+    if (isActive && !options?.confirmed) {
+      return {
+        ok: false,
+        needsConfirmation: true,
+        session: { id: record.sessionId, name: record.name ?? null, status: record.status }
+      };
+    }
+    if (isActive) {
+      await this.sessionManager.cancelSession(sessionId);
+    }
+    const topicId = record.platform?.topicId ?? null;
+    if (this.adapter && topicId) {
+      try {
+        await this.adapter.deleteSessionThread(sessionId);
+      } catch (err) {
+        log10.warn({ err, sessionId, topicId }, "Failed to delete platform thread, removing record anyway");
+      }
+    }
+    await this.sessionManager.removeRecord(sessionId);
+    return { ok: true, topicId };
+  }
+  async cleanup(statuses) {
+    const targetStatuses = statuses?.length ? statuses : ["finished", "error", "cancelled"];
+    const records = this.sessionManager.listRecords({ statuses: targetStatuses });
+    const targets = records.filter((r) => !this.isSystemTopic(r)).filter((r) => targetStatuses.includes(r.status));
+    const deleted = [];
+    const failed = [];
+    for (const record of targets) {
+      try {
+        const isActive = record.status === "active" || record.status === "initializing";
+        if (isActive) {
+          await this.sessionManager.cancelSession(record.sessionId);
+        }
+        const topicId = record.platform?.topicId;
+        if (this.adapter && topicId) {
+          try {
+            await this.adapter.deleteSessionThread(record.sessionId);
+          } catch (err) {
+            log10.warn({ err, sessionId: record.sessionId }, "Failed to delete platform thread during cleanup");
+          }
+        }
+        await this.sessionManager.removeRecord(record.sessionId);
+        deleted.push(record.sessionId);
+      } catch (err) {
+        failed.push({ sessionId: record.sessionId, error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    return { deleted, failed };
+  }
+  isSystemTopic(record) {
+    const topicId = record.platform?.topicId;
+    if (!topicId) return false;
+    return topicId === this.systemTopicIds.notificationTopicId || topicId === this.systemTopicIds.assistantTopicId;
+  }
+};
+
+export {
+  nodeToWebWritable,
+  nodeToWebReadable,
+  StderrCapture,
+  TypedEmitter,
+  AgentInstance,
+  AgentManager,
+  PromptQueue,
+  PermissionGate,
+  Session,
+  SessionManager,
+  FileService,
+  SessionBridge,
+  NotificationManager,
+  MessageTransformer,
+  UsageStore,
+  UsageBudget,
+  SecurityGuard,
+  SessionFactory,
+  EventBus,
+  SpeechService,
+  GroqSTT,
+  OpenACPCore,
+  SSEManager,
+  StaticServer,
+  ApiServer,
+  TopicManager
+};
+//# sourceMappingURL=chunk-FEWSQT3U.js.map