@openacp/cli 0.6.10 → 2026.41.2

package/dist/chunk-LGP2YGRL.js

@@ -1,4880 +0,0 @@
-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;
-  promptCount = 0;
-  log;
-  permissionGate = new PermissionGate();
-  queue;
-  speechService;
-  pendingContext = null;
-  constructor(opts) {
-    super();
-    this.id = opts.id || nanoid(12);
-    this.channelId = opts.channelId;
-    this.agentName = opts.agentName;
-    this.workingDirectory = opts.workingDirectory;
-    this.agentInstance = opts.agentInstance;
-    this.speechService = opts.speechService;
-    this.log = createSessionLogger(this.id, moduleLog);
-    this.log.info({ agentName: this.agentName }, "Session created");
-    this.queue = new PromptQueue(
-      (text, attachments) => this.processPrompt(text, attachments),
-      (err) => {
-        this.fail("Prompt execution failed");
-        this.log.error({ err }, "Prompt execution failed");
-      }
-    );
-  }
-  // --- State Machine ---
-  get status() {
-    return this._status;
-  }
-  /** Transition to active — from initializing, error, or cancelled */
-  activate() {
-    this.transition("active");
-  }
-  /** Transition to error — from initializing or active */
-  fail(reason) {
-    this.transition("error");
-    this.emit("error", new Error(reason));
-  }
-  /** Transition to finished — from active only. Emits session_end for backward compat. */
-  finish(reason) {
-    this.transition("finished");
-    this.emit("session_end", reason ?? "completed");
-  }
-  /** Transition to cancelled — from active only (terminal session cancel) */
-  markCancelled() {
-    this.transition("cancelled");
-  }
-  transition(to) {
-    const from = this._status;
-    const allowed = VALID_TRANSITIONS[from];
-    if (!allowed?.has(to)) {
-      throw new Error(
-        `Invalid session transition: ${from} \u2192 ${to}`
-      );
-    }
-    this._status = to;
-    this.log.debug({ from, to }, "Session status transition");
-    this.emit("status_change", from, to);
-  }
-  /** Number of prompts waiting in queue */
-  get queueDepth() {
-    return this.queue.pending;
-  }
-  get promptRunning() {
-    return this.queue.isProcessing;
-  }
-  // --- Context Injection ---
-  setContext(markdown) {
-    this.pendingContext = markdown;
-  }
-  // --- Voice Mode ---
-  setVoiceMode(mode) {
-    this.voiceMode = mode;
-    this.log.info({ voiceMode: mode }, "TTS mode changed");
-  }
-  // --- Public API ---
-  async enqueuePrompt(text, attachments) {
-    await this.queue.enqueue(text, attachments);
-  }
-  async processPrompt(text, attachments) {
-    if (text === "\0__warmup__") {
-      await this.runWarmup();
-      return;
-    }
-    this.promptCount++;
-    if (this._status === "initializing") {
-      this.activate();
-    }
-    const promptStart = Date.now();
-    this.log.debug("Prompt execution started");
-    if (this.pendingContext) {
-      text = `[CONVERSATION HISTORY - This is context from previous sessions, not current conversation]
-
-${this.pendingContext}
-
-[END CONVERSATION HISTORY]
-
-${text}`;
-      this.pendingContext = null;
-      this.log.debug("Context injected into prompt");
-    }
-    const processed = await this.maybeTranscribeAudio(text, attachments);
-    const ttsActive = this.voiceMode !== "off" && !!this.speechService?.isTTSAvailable();
-    if (ttsActive) {
-      processed.text += TTS_PROMPT_INSTRUCTION;
-      if (this.voiceMode === "next") {
-        this.voiceMode = "off";
-      }
-    }
-    let accumulatedText = "";
-    const accumulatorListener = ttsActive ? (event) => {
-      if (event.type === "text") {
-        accumulatedText += event.content;
-      }
-    } : null;
-    if (accumulatorListener) {
-      this.on("agent_event", accumulatorListener);
-    }
-    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();
-    }
-  }
-  async generateSummary(timeoutMs = 15e3) {
-    let summary = "";
-    let timer;
-    const captureHandler = (event) => {
-      if (event.type === "text") summary += event.content;
-    };
-    this.pause((event) => event !== "agent_event");
-    this.agentInstance.on("agent_event", captureHandler);
-    try {
-      const promptPromise = this.agentInstance.prompt(
-        "Summarize what you've accomplished so far in this session in 2-3 sentences. Include: key files changed, decisions made, and current status. Reply ONLY with the summary, nothing else."
-      );
-      const timeoutPromise = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error("summary timeout")), timeoutMs);
-      });
-      await Promise.race([promptPromise, timeoutPromise]);
-      return summary.trim().slice(0, 500);
-    } catch {
-      this.log.warn("Failed to generate session summary");
-      return "";
-    } finally {
-      if (timer) clearTimeout(timer);
-      this.agentInstance.off("agent_event", captureHandler);
-      this.clearBuffer();
-      this.resume();
-    }
-  }
-  /** Fire-and-forget warm-up: primes model cache while user types their first message */
-  async warmup() {
-    await this.queue.enqueue("\0__warmup__");
-  }
-  async runWarmup() {
-    this.pause((_event, args) => {
-      const agentEvent = args[0];
-      return agentEvent?.type === "commands_update";
-    });
-    try {
-      const start = Date.now();
-      await this.agentInstance.prompt('Reply with only "ready".');
-      this.activate();
-      this.log.info({ durationMs: Date.now() - start }, "Warm-up complete");
-    } catch (err) {
-      this.log.error({ err }, "Warm-up failed");
-    } finally {
-      this.clearBuffer();
-      this.resume();
-    }
-  }
-  /** 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
-\u23F1 ${Math.round((Date.now() - this.session.createdAt.getTime()) / 6e4)} min \xB7 \u{1F4AC} ${this.session.promptCount} prompts`
-          });
-          break;
-        case "error":
-          this.session.fail(event.message);
-          this.adapter.cleanupSkillCommands(this.session.id);
-          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 fs9 = this.deps.fileService;
-            const sid = this.session.id;
-            const { data, mimeType } = event;
-            const buffer = Buffer.from(data, "base64");
-            const ext = FileService.extensionFromMime(mimeType);
-            fs9.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 fs9 = this.deps.fileService;
-            const sid = this.session.id;
-            const { data, mimeType } = event;
-            const buffer = Buffer.from(data, "base64");
-            const ext = FileService.extensionFromMime(mimeType);
-            fs9.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 meta = event.meta;
-        const metadata = {
-          id: event.id,
-          name: event.name,
-          kind: event.kind,
-          status: event.status,
-          content: event.content,
-          locations: event.locations,
-          rawInput: event.rawInput,
-          displaySummary: meta?.displaySummary,
-          displayTitle: meta?.displayTitle,
-          displayKind: meta?.displayKind
-        };
-        this.enrichWithViewerLinks(event, metadata, sessionContext);
-        return { type: "tool_call", text: event.name, metadata };
-      }
-      case "tool_update": {
-        const meta = event.meta;
-        const metadata = {
-          id: event.id,
-          name: event.name,
-          kind: event.kind,
-          status: event.status,
-          content: event.content,
-          rawInput: event.rawInput,
-          displaySummary: meta?.displaySummary,
-          displayTitle: meta?.displayTitle,
-          displayKind: meta?.displayKind
-        };
-        this.enrichWithViewerLinks(event, metadata, sessionContext);
-        return { type: "tool_update", text: "", metadata };
-      }
-      case "plan":
-        return {
-          type: "plan",
-          text: "",
-          metadata: { entries: event.entries }
-        };
-      case "usage":
-        return {
-          type: "usage",
-          text: "",
-          metadata: {
-            tokensUsed: event.tokensUsed,
-            contextSize: event.contextSize,
-            cost: event.cost
-          }
-        };
-      case "session_end":
-        return { type: "session_end", text: `Done (${event.reason})` };
-      case "error":
-        return { type: "error", text: event.message };
-      case "system_message":
-        return { type: "system_message", text: event.message };
-      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("./dist-UHQK5CXN.js");
-    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/context/context-manager.ts
-import * as os from "os";
-import * as path5 from "path";
-
-// src/core/context/context-cache.ts
-import * as fs5 from "fs";
-import * as path4 from "path";
-import * as crypto from "crypto";
-var DEFAULT_TTL_MS = 60 * 60 * 1e3;
-var ContextCache = class {
-  constructor(cacheDir, ttlMs = DEFAULT_TTL_MS) {
-    this.cacheDir = cacheDir;
-    this.ttlMs = ttlMs;
-    fs5.mkdirSync(cacheDir, { recursive: true });
-  }
-  keyHash(repoPath, queryKey) {
-    return crypto.createHash("sha256").update(`${repoPath}:${queryKey}`).digest("hex").slice(0, 16);
-  }
-  filePath(repoPath, queryKey) {
-    return path4.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
-  }
-  get(repoPath, queryKey) {
-    const fp = this.filePath(repoPath, queryKey);
-    try {
-      const stat = fs5.statSync(fp);
-      if (Date.now() - stat.mtimeMs > this.ttlMs) {
-        fs5.unlinkSync(fp);
-        return null;
-      }
-      return JSON.parse(fs5.readFileSync(fp, "utf-8"));
-    } catch {
-      return null;
-    }
-  }
-  set(repoPath, queryKey, result) {
-    fs5.writeFileSync(this.filePath(repoPath, queryKey), JSON.stringify(result));
-  }
-};
-
-// src/core/context/context-manager.ts
-var ContextManager = class {
-  providers = [];
-  cache;
-  constructor() {
-    this.cache = new ContextCache(path5.join(os.homedir(), ".openacp", "cache", "entire"));
-  }
-  register(provider) {
-    this.providers.push(provider);
-  }
-  async getProvider(repoPath) {
-    for (const provider of this.providers) {
-      if (await provider.isAvailable(repoPath)) return provider;
-    }
-    return null;
-  }
-  async listSessions(query) {
-    const provider = await this.getProvider(query.repoPath);
-    if (!provider) return null;
-    return provider.listSessions(query);
-  }
-  async buildContext(query, options) {
-    const queryKey = `${query.type}:${query.value}:${options?.limit ?? ""}:${options?.maxTokens ?? ""}`;
-    const cached = this.cache.get(query.repoPath, queryKey);
-    if (cached) return cached;
-    const provider = await this.getProvider(query.repoPath);
-    if (!provider) return null;
-    const result = await provider.buildContext(query, options);
-    if (result) this.cache.set(query.repoPath, queryKey, result);
-    return result;
-  }
-};
-
-// src/core/context/context-provider.ts
-var DEFAULT_MAX_TOKENS = 3e4;
-var TOKENS_PER_TURN_ESTIMATE = 400;
-
-// src/core/context/entire/checkpoint-reader.ts
-import { execFileSync as execFileSync2 } from "child_process";
-var ENTIRE_BRANCH = "origin/entire/checkpoints/v1";
-var CHECKPOINT_ID_RE = /^[0-9a-f]{12}$/;
-var SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-var CheckpointReader = class _CheckpointReader {
-  constructor(repoPath) {
-    this.repoPath = repoPath;
-  }
-  // ─── Git execution ───────────────────────────────────────────────────────────
-  /**
-   * Run a git command in the repo directory.
-   * Returns trimmed stdout on success, empty string on failure.
-   */
-  git(...args) {
-    try {
-      return execFileSync2("git", ["-C", this.repoPath, ...args], {
-        encoding: "utf-8"
-      }).trim();
-    } catch {
-      return "";
-    }
-  }
-  // ─── Static helpers ──────────────────────────────────────────────────────────
-  /**
-   * Convert a 12-char checkpoint ID to its shard path: "f634acf05138" → "f6/34acf05138"
-   */
-  static shardPath(cpId) {
-    return `${cpId.slice(0, 2)}/${cpId.slice(2)}`;
-  }
-  /**
-   * Returns true when value looks like a 12-char lowercase hex checkpoint ID.
-   */
-  static isCheckpointId(value) {
-    return CHECKPOINT_ID_RE.test(value);
-  }
-  /**
-   * Returns true when value looks like a UUID (session ID).
-   */
-  static isSessionId(value) {
-    return SESSION_ID_RE.test(value);
-  }
-  /**
-   * Parse checkpoint-level metadata JSON. Returns null on error.
-   */
-  static parseCheckpointMeta(json) {
-    try {
-      const parsed = JSON.parse(json);
-      if (!parsed || typeof parsed !== "object") return null;
-      if (!Array.isArray(parsed.sessions)) return null;
-      return parsed;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Extract Entire-Checkpoint trailer IDs from `git log --format="%H|%(trailers:...)"` output.
-   * Each line is: `<hash>|<trailer_value_or_empty>`. Returns only non-empty trailer values.
-   * Uses the last pipe on each line to locate the trailer value, to be robust against
-   * subject lines that contain pipes.
-   */
-  static parseCheckpointTrailers(output) {
-    const ids = [];
-    for (const line of output.split("\n")) {
-      const pipe = line.lastIndexOf("|");
-      if (pipe === -1) continue;
-      const trailerId = line.slice(pipe + 1).trim();
-      if (trailerId) ids.push(trailerId);
-    }
-    return ids;
-  }
-  // ─── Branch check ────────────────────────────────────────────────────────────
-  async hasEntireBranch() {
-    const out = this.git("branch", "-r");
-    return out.includes("entire/checkpoints/v1");
-  }
-  // ─── Core session fetching ───────────────────────────────────────────────────
-  listAllCheckpointIds() {
-    const out = this.git(
-      "ls-tree",
-      "-r",
-      ENTIRE_BRANCH,
-      "--name-only"
-    );
-    if (!out) return [];
-    const ids = /* @__PURE__ */ new Set();
-    for (const file of out.split("\n")) {
-      const parts = file.split("/");
-      if (parts.length === 3 && parts[2] === "metadata.json") {
-        ids.add(parts[0] + parts[1]);
-      }
-    }
-    return [...ids];
-  }
-  fetchCheckpointMeta(cpId) {
-    const shard = _CheckpointReader.shardPath(cpId);
-    const raw = this.git("show", `${ENTIRE_BRANCH}:${shard}/metadata.json`);
-    if (!raw) return null;
-    return _CheckpointReader.parseCheckpointMeta(raw);
-  }
-  fetchSessionMeta(metaPath) {
-    const normalized = metaPath.startsWith("/") ? metaPath.slice(1) : metaPath;
-    const raw = this.git("show", `${ENTIRE_BRANCH}:${normalized}`);
-    if (!raw) return {};
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return {};
-    }
-  }
-  /**
-   * Build SessionInfo[] from a single checkpoint's metadata.
-   */
-  buildSessionsForCheckpoint(cpId, cpMeta) {
-    const sessions = [];
-    for (let idx = 0; idx < cpMeta.sessions.length; idx++) {
-      const sess = cpMeta.sessions[idx];
-      const transcriptPath = (sess.transcript ?? "").replace(/^\//, "");
-      const metaPath = sess.metadata ?? "";
-      const smeta = this.fetchSessionMeta(metaPath);
-      const createdAt = smeta.created_at ?? "";
-      sessions.push({
-        checkpointId: cpId,
-        sessionIndex: String(idx),
-        transcriptPath,
-        createdAt,
-        endedAt: createdAt,
-        // will be filled from JSONL by conversation builder
-        branch: smeta.branch ?? cpMeta.branch ?? "",
-        agent: smeta.agent ?? "",
-        turnCount: smeta.session_metrics?.turn_count ?? 0,
-        filesTouched: smeta.files_touched ?? cpMeta.files_touched ?? [],
-        sessionId: smeta.session_id ?? ""
-      });
-    }
-    return sessions;
-  }
-  getSessionsForCheckpoint(cpId) {
-    const meta = this.fetchCheckpointMeta(cpId);
-    if (!meta) return [];
-    return this.buildSessionsForCheckpoint(cpId, meta);
-  }
-  // ─── Public resolvers ────────────────────────────────────────────────────────
-  /**
-   * All sessions recorded on a given branch, sorted by createdAt ascending.
-   */
-  async resolveByBranch(branchName) {
-    const cpIds = this.listAllCheckpointIds();
-    const sessions = [];
-    for (const cpId of cpIds) {
-      const meta = this.fetchCheckpointMeta(cpId);
-      if (!meta) continue;
-      if (meta.branch !== branchName) continue;
-      sessions.push(...this.buildSessionsForCheckpoint(cpId, meta));
-    }
-    sessions.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-    return sessions;
-  }
-  /**
-   * Sessions linked to a specific commit via the Entire-Checkpoint git trailer.
-   */
-  async resolveByCommit(commitHash) {
-    const fullHash = this.git("rev-parse", commitHash);
-    if (!fullHash) return [];
-    const cpId = this.git(
-      "log",
-      "-1",
-      "--format=%(trailers:key=Entire-Checkpoint,valueonly)",
-      fullHash
-    );
-    if (!cpId) return [];
-    return this.getSessionsForCheckpoint(cpId.trim());
-  }
-  /**
-   * All sessions from a merged PR (by number or GitHub URL).
-   */
-  async resolveByPr(prInput) {
-    let prNumber;
-    if (/^\d+$/.test(prInput)) {
-      prNumber = prInput;
-    } else {
-      const m = /\/pull\/(\d+)/.exec(prInput);
-      if (!m) return [];
-      prNumber = m[1];
-    }
-    const mergeOut = this.git(
-      "log",
-      "--all",
-      "--oneline",
-      "--grep",
-      `Merge pull request #${prNumber}`
-    );
-    if (!mergeOut) return [];
-    const mergeCommit = mergeOut.split("\n")[0].split(" ")[0];
-    const logOut = this.git(
-      "log",
-      "--format=%H|%(trailers:key=Entire-Checkpoint,valueonly)",
-      `${mergeCommit}^2`,
-      "--not",
-      `${mergeCommit}^1`
-    );
-    if (!logOut) return [];
-    const cpIds = _CheckpointReader.parseCheckpointTrailers(logOut);
-    const sessions = [];
-    for (const cpId of cpIds) {
-      sessions.push(...this.getSessionsForCheckpoint(cpId));
-    }
-    sessions.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-    return sessions;
-  }
-  /**
-   * Sessions matching a specific checkpoint ID.
-   */
-  async resolveByCheckpoint(checkpointId) {
-    return this.getSessionsForCheckpoint(checkpointId);
-  }
-  /**
-   * Find a session by its UUID.
-   */
-  async resolveBySessionId(sessionId) {
-    const cpIds = this.listAllCheckpointIds();
-    for (const cpId of cpIds) {
-      const sessions = this.getSessionsForCheckpoint(cpId);
-      const match = sessions.find((s) => s.sessionId === sessionId);
-      if (match) return [match];
-    }
-    return [];
-  }
-  /**
-   * Latest N sessions across all checkpoints, sorted by createdAt descending.
-   */
-  async resolveLatest(count) {
-    const cpIds = this.listAllCheckpointIds();
-    const all = [];
-    for (const cpId of cpIds) {
-      all.push(...this.getSessionsForCheckpoint(cpId));
-    }
-    all.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-    return all.slice(0, count);
-  }
-  /**
-   * Read the full JSONL transcript content from the entire branch.
-   */
-  getTranscript(transcriptPath) {
-    const normalized = transcriptPath.startsWith("/") ? transcriptPath.slice(1) : transcriptPath;
-    return this.git("show", `${ENTIRE_BRANCH}:${normalized}`);
-  }
-};
-
-// src/core/context/entire/message-cleaner.ts
-var SYSTEM_TAG_PATTERNS = [
-  /<system-reminder>[\s\S]*?<\/system-reminder>/g,
-  /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g,
-  /<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g,
-  /<command-name>[\s\S]*?<\/command-name>/g,
-  /<command-message>[\s\S]*?<\/command-message>/g,
-  /<user-prompt-submit-hook>[\s\S]*?<\/user-prompt-submit-hook>/g,
-  /<ide_selection>[\s\S]*?<\/ide_selection>/g,
-  /<ide_context>[\s\S]*?<\/ide_context>/g,
-  /<ide_opened_file>[\s\S]*?<\/ide_opened_file>/g,
-  /<cursor_context>[\s\S]*?<\/cursor_context>/g,
-  /<attached_files>[\s\S]*?<\/attached_files>/g,
-  /<repo_context>[\s\S]*?<\/repo_context>/g,
-  /<task-notification>[\s\S]*?<\/task-notification>/g
-];
-var COMMAND_ARGS_RE = /<command-args>([\s\S]*?)<\/command-args>/;
-function cleanSystemTags(text) {
-  const argsMatch = COMMAND_ARGS_RE.exec(text);
-  const userArgs = argsMatch?.[1]?.trim() ?? "";
-  text = text.replace(/<command-args>[\s\S]*?<\/command-args>/g, "");
-  for (const pat of SYSTEM_TAG_PATTERNS) {
-    text = text.replace(new RegExp(pat.source, pat.flags), "");
-  }
-  text = text.trim();
-  if (!text && userArgs) return userArgs;
-  if (text && userArgs && text !== userArgs) return `${text}
-${userArgs}`;
-  return text || userArgs;
-}
-var SKILL_INDICATORS = [
-  "Base directory for this skill:",
-  "<HARD-GATE>",
-  "## Checklist",
-  "## Process Flow",
-  "## Key Principles",
-  "digraph brainstorming",
-  "You MUST create a task for each"
-];
-function isSkillPrompt(text) {
-  for (const indicator of SKILL_INDICATORS) {
-    if (text.includes(indicator)) return true;
-  }
-  if (text.length > 2e3) {
-    const headerCount = (text.match(/## /g) || []).length;
-    if (headerCount >= 3) return true;
-  }
-  return false;
-}
-function isNoiseMessage(text) {
-  const cleaned = cleanSystemTags(text);
-  if (!cleaned) return true;
-  if (/^(ready|ready\.)$/i.test(cleaned)) return true;
-  if (cleaned.includes("Tell your human partner that this command is deprecated")) return true;
-  if (cleaned.startsWith("Read the output file to retrieve the result:")) return true;
-  if (/^(opus|sonnet|haiku|claude)(\[.*\])?$/i.test(cleaned)) return true;
-  return false;
-}
-
-// src/core/context/entire/conversation-builder.ts
-function selectMode(totalTurns) {
-  if (totalTurns <= 10) return "full";
-  if (totalTurns <= 25) return "balanced";
-  return "compact";
-}
-function estimateTokens(text) {
-  return Math.floor(text.length / 4);
-}
-function shortenPath(fp) {
-  const parts = fp.split("/");
-  if (parts.length >= 2) return parts.slice(-2).join("/");
-  return fp;
-}
-function countLines(s) {
-  const trimmed = s.trim();
-  if (!trimmed) return 0;
-  return trimmed.split("\n").length;
-}
-function extractText(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.filter((b) => typeof b === "object" && b !== null && b.type === "text").map((b) => b.text).join("\n");
-  }
-  return "";
-}
-function extractContentBlocks(content) {
-  if (typeof content === "string") return [{ type: "text", text: content }];
-  if (Array.isArray(content)) {
-    return content.filter((b) => typeof b === "object" && b !== null);
-  }
-  return [];
-}
-function isToolResultOnly(content) {
-  if (typeof content === "string") return false;
-  if (!Array.isArray(content)) return true;
-  for (const block of content) {
-    if (typeof block === "object" && block !== null) {
-      const b = block;
-      if (b.type === "text" && typeof b.text === "string" && b.text.trim()) return false;
-      if (b.type === "image") return false;
-    }
-  }
-  return true;
-}
-function hasImage(content) {
-  if (!Array.isArray(content)) return false;
-  return content.some((b) => typeof b === "object" && b !== null && b.type === "image");
-}
-function formatEditFull(filePath, oldStr, newStr) {
-  const lines = [];
-  lines.push(`\u270F\uFE0F \`${filePath}\``);
-  lines.push("```diff");
-  for (const line of oldStr.split("\n")) lines.push(`- ${line}`);
-  for (const line of newStr.split("\n")) lines.push(`+ ${line}`);
-  lines.push("```");
-  return lines.join("\n");
-}
-function formatEditBalanced(filePath, oldStr, newStr, maxDiffLines = 12) {
-  const oldLines = oldStr.split("\n");
-  const newLines = newStr.split("\n");
-  const total = oldLines.length + newLines.length;
-  const lines = [];
-  lines.push(`\u270F\uFE0F \`${filePath}\``);
-  lines.push("```diff");
-  if (total <= maxDiffLines) {
-    for (const line of oldLines) lines.push(`- ${line}`);
-    for (const line of newLines) lines.push(`+ ${line}`);
-  } else {
-    const half = Math.floor(maxDiffLines / 2);
-    for (const line of oldLines.slice(0, half)) lines.push(`- ${line}`);
-    if (oldLines.length > half) lines.push(`  ... (-${oldLines.length} lines total)`);
-    for (const line of newLines.slice(0, half)) lines.push(`+ ${line}`);
-    if (newLines.length > half) lines.push(`  ... (+${newLines.length} lines total)`);
-  }
-  lines.push("```");
-  return lines.join("\n");
-}
-function formatEditCompact(filePath, oldStr, newStr) {
-  const oldLines = countLines(oldStr);
-  const newLines = countLines(newStr);
-  let firstNew = "";
-  for (const line of newStr.split("\n")) {
-    const stripped = line.trim();
-    if (stripped && !stripped.startsWith("//") && !stripped.startsWith("*")) {
-      firstNew = stripped.slice(0, 80);
-      break;
-    }
-  }
-  if (firstNew) {
-    return `\u270F\uFE0F \`${filePath}\` (-${oldLines}/+${newLines} lines): \`${firstNew}\``;
-  }
-  return `\u270F\uFE0F \`${filePath}\` (-${oldLines}/+${newLines} lines)`;
-}
-function formatWriteFull(filePath, content) {
-  const lines = [];
-  lines.push(`\u{1F4DD} \`${filePath}\``);
-  lines.push("```");
-  lines.push(content);
-  lines.push("```");
-  return lines.join("\n");
-}
-function formatWriteBalanced(filePath, content, maxLines = 15) {
-  const contentLines = content.split("\n");
-  const lines = [];
-  lines.push(`\u{1F4DD} \`${filePath}\` (${contentLines.length} lines)`);
-  lines.push("```");
-  for (const line of contentLines.slice(0, maxLines)) lines.push(line);
-  if (contentLines.length > maxLines) lines.push(`... (${contentLines.length - maxLines} more lines)`);
-  lines.push("```");
-  return lines.join("\n");
-}
-function formatWriteCompact(filePath, content) {
-  const numLines = countLines(content);
-  return `\u{1F4DD} \`${filePath}\` (${numLines} lines written)`;
-}
-function parseJsonlToTurns(jsonl) {
-  const events = [];
-  for (const rawLine of jsonl.split("\n")) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    try {
-      events.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  let branch = "unknown";
-  for (const e of events) {
-    if (e.gitBranch) {
-      branch = e.gitBranch;
-      break;
-    }
-  }
-  const convEvents = events.filter((e) => e.type === "user" || e.type === "assistant");
-  const turns = [];
-  let currentTurn = null;
-  for (const e of convEvents) {
-    const etype = e.type;
-    const content = e.message?.content ?? [];
-    const ts = e.timestamp ?? "";
-    if (etype === "user") {
-      if (isToolResultOnly(content)) continue;
-      const text = extractText(content);
-      if (isSkillPrompt(text)) continue;
-      if (isNoiseMessage(text)) continue;
-      const cleaned = cleanSystemTags(text);
-      if (!cleaned) continue;
-      if (currentTurn) turns.push(currentTurn);
-      const imgSuffix = hasImage(content) ? " [image]" : "";
-      currentTurn = {
-        userText: cleaned + imgSuffix,
-        userTimestamp: ts,
-        assistantParts: []
-      };
-    } else if (etype === "assistant" && currentTurn) {
-      const blocks = extractContentBlocks(content);
-      let pendingText = null;
-      for (const block of blocks) {
-        const btype = block.type;
-        if (btype === "text") {
-          const text = typeof block.text === "string" ? block.text.trim() : "";
-          if (text) pendingText = text;
-        } else if (btype === "tool_use") {
-          const name = typeof block.name === "string" ? block.name : "";
-          const inp = typeof block.input === "object" && block.input !== null ? block.input : {};
-          if (name === "Edit") {
-            if (pendingText) {
-              currentTurn.assistantParts.push({ type: "text", content: pendingText });
-              pendingText = null;
-            }
-            currentTurn.assistantParts.push({
-              type: "edit",
-              file: shortenPath(inp.file_path ?? ""),
-              old: inp.old_string ?? "",
-              new: inp.new_string ?? ""
-            });
-          } else if (name === "Write") {
-            if (pendingText) {
-              currentTurn.assistantParts.push({ type: "text", content: pendingText });
-              pendingText = null;
-            }
-            currentTurn.assistantParts.push({
-              type: "write",
-              file: shortenPath(inp.file_path ?? ""),
-              fileContent: inp.content ?? ""
-            });
-          }
-        }
-      }
-      if (pendingText) {
-        currentTurn.assistantParts.push({ type: "text", content: pendingText });
-      }
-    }
-  }
-  if (currentTurn) turns.push(currentTurn);
-  const firstTimestamp = turns[0]?.userTimestamp ?? "";
-  const lastTimestamp = turns[turns.length - 1]?.userTimestamp ?? "";
-  return { turns, branch, firstTimestamp, lastTimestamp };
-}
-function buildSessionMarkdown(turns, mode) {
-  const out = [];
-  for (let i = 0; i < turns.length; i++) {
-    const turn = turns[i];
-    const userText = turn.userText.trim();
-    if (!userText) continue;
-    out.push(`**User [${i + 1}]:**`);
-    out.push(userText);
-    out.push("");
-    let hasContent = false;
-    for (const part of turn.assistantParts) {
-      if (part.type === "text") {
-        if (!hasContent) {
-          out.push("**Assistant:**");
-          hasContent = true;
-        }
-        out.push(part.content ?? "");
-        out.push("");
-      } else if (part.type === "edit") {
-        if (!hasContent) {
-          out.push("**Assistant:**");
-          hasContent = true;
-        }
-        const file = part.file ?? "";
-        const oldStr = part.old ?? "";
-        const newStr = part.new ?? "";
-        if (mode === "full") {
-          out.push(formatEditFull(file, oldStr, newStr));
-        } else if (mode === "balanced") {
-          out.push(formatEditBalanced(file, oldStr, newStr));
-        } else {
-          out.push(formatEditCompact(file, oldStr, newStr));
-        }
-        out.push("");
-      } else if (part.type === "write") {
-        if (!hasContent) {
-          out.push("**Assistant:**");
-          hasContent = true;
-        }
-        const file = part.file ?? "";
-        const content = part.fileContent ?? "";
-        if (mode === "full") {
-          out.push(formatWriteFull(file, content));
-        } else if (mode === "balanced") {
-          out.push(formatWriteBalanced(file, content));
-        } else {
-          out.push(formatWriteCompact(file, content));
-        }
-        out.push("");
-      }
-    }
-    out.push("---");
-    out.push("");
-  }
-  return out.join("\n");
-}
-var DISCLAIMER = `> **Note:** This conversation history may contain outdated information. File contents, code, and project state may have changed since these sessions were recorded. Use this as context only \u2014 always verify against current files before acting.`;
-function mergeSessionsMarkdown(sessions, mode, title) {
-  const sorted = [...sessions].sort((a, b) => a.startTime.localeCompare(b.startTime));
-  const totalTurns = sorted.reduce((sum, s) => sum + s.turns, 0);
-  const overallStart = sorted[0]?.startTime.slice(0, 16) ?? "?";
-  const overallEnd = sorted[sorted.length - 1]?.endTime.slice(0, 16) ?? "?";
-  const out = [];
-  out.push(`# Conversation History from ${title}`);
-  out.push(`${sorted.length} sessions | ${totalTurns} turns | ${overallStart} \u2192 ${overallEnd} | mode: ${mode}`);
-  out.push("");
-  for (let i = 0; i < sorted.length; i++) {
-    const s = sorted[i];
-    const start = s.startTime.slice(0, 16);
-    const end = s.endTime.slice(0, 16);
-    out.push(`## Session Conversation History ${i + 1} \u2014 ${start} \u2192 ${end} (${s.agent}, ${s.turns} turns, branch: ${s.branch})`);
-    out.push("");
-    out.push(s.markdown);
-  }
-  out.push(DISCLAIMER);
-  out.push("");
-  return out.join("\n");
-}
-
-// src/core/context/entire/entire-provider.ts
-var EntireProvider = class {
-  name = "entire";
-  async isAvailable(repoPath) {
-    return new CheckpointReader(repoPath).hasEntireBranch();
-  }
-  async listSessions(query) {
-    const reader = new CheckpointReader(query.repoPath);
-    const sessions = await this.resolveSessions(reader, query);
-    const estimatedTokens = sessions.reduce((sum, s) => sum + s.turnCount * TOKENS_PER_TURN_ESTIMATE, 0);
-    return { sessions, estimatedTokens };
-  }
-  async buildContext(query, options) {
-    const maxTokens = options?.maxTokens ?? DEFAULT_MAX_TOKENS;
-    const reader = new CheckpointReader(query.repoPath);
-    let sessions = await this.resolveSessions(reader, query);
-    if (options?.limit && sessions.length > options.limit) {
-      sessions = sessions.slice(-options.limit);
-    }
-    if (sessions.length === 0) {
-      return { markdown: "", tokenEstimate: 0, sessionCount: 0, totalTurns: 0, mode: "full", truncated: false, timeRange: { start: "", end: "" } };
-    }
-    const parsedSessions = [];
-    for (const sess of sessions) {
-      const jsonl = reader.getTranscript(sess.transcriptPath);
-      if (jsonl) parsedSessions.push({ session: sess, jsonl });
-    }
-    if (parsedSessions.length === 0) {
-      return { markdown: "", tokenEstimate: 0, sessionCount: 0, totalTurns: 0, mode: "full", truncated: false, timeRange: { start: "", end: "" } };
-    }
-    const totalTurns = parsedSessions.reduce((sum, ps) => {
-      const parsed = parseJsonlToTurns(ps.jsonl);
-      return sum + parsed.turns.length;
-    }, 0);
-    let mode = selectMode(totalTurns);
-    const title = this.buildTitle(query);
-    let sessionMarkdowns = this.buildSessionMarkdowns(parsedSessions, mode);
-    let merged = mergeSessionsMarkdown(sessionMarkdowns, mode, title);
-    let tokens = estimateTokens(merged);
-    if (tokens > maxTokens && mode !== "compact") {
-      mode = "compact";
-      sessionMarkdowns = this.buildSessionMarkdowns(parsedSessions, "compact");
-      merged = mergeSessionsMarkdown(sessionMarkdowns, "compact", title);
-      tokens = estimateTokens(merged);
-    }
-    let truncated = false;
-    while (tokens > maxTokens && sessionMarkdowns.length > 1) {
-      sessionMarkdowns = sessionMarkdowns.slice(1);
-      truncated = true;
-      merged = mergeSessionsMarkdown(sessionMarkdowns, mode, title);
-      tokens = estimateTokens(merged);
-    }
-    const allTimes = sessionMarkdowns.flatMap((s) => [s.startTime, s.endTime]).filter(Boolean).sort();
-    const finalTurns = sessionMarkdowns.reduce((sum, s) => sum + s.turns, 0);
-    return {
-      markdown: merged,
-      tokenEstimate: tokens,
-      sessionCount: sessionMarkdowns.length,
-      totalTurns: finalTurns,
-      mode,
-      truncated,
-      timeRange: { start: allTimes[0] ?? "", end: allTimes[allTimes.length - 1] ?? "" }
-    };
-  }
-  buildSessionMarkdowns(parsedSessions, mode) {
-    return parsedSessions.map((ps) => {
-      const parsed = parseJsonlToTurns(ps.jsonl);
-      return {
-        markdown: buildSessionMarkdown(parsed.turns, mode),
-        startTime: parsed.firstTimestamp,
-        endTime: parsed.lastTimestamp,
-        agent: ps.session.agent,
-        turns: parsed.turns.length,
-        branch: ps.session.branch,
-        files: ps.session.filesTouched.map((f) => f.split("/").pop() ?? f)
-      };
-    });
-  }
-  async resolveSessions(reader, query) {
-    switch (query.type) {
-      case "branch":
-        return reader.resolveByBranch(query.value);
-      case "commit":
-        return reader.resolveByCommit(query.value);
-      case "pr":
-        return reader.resolveByPr(query.value);
-      case "checkpoint":
-        return reader.resolveByCheckpoint(query.value);
-      case "session":
-        return reader.resolveBySessionId(query.value);
-      case "latest":
-        return reader.resolveLatest(parseInt(query.value) || 5);
-      default:
-        return [];
-    }
-  }
-  buildTitle(query) {
-    switch (query.type) {
-      case "pr":
-        return `PR #${query.value.replace(/.*\/pull\//, "")}`;
-      case "branch":
-        return `branch \`${query.value}\``;
-      case "commit":
-        return `commit \`${query.value.slice(0, 8)}\``;
-      case "checkpoint":
-        return `checkpoint \`${query.value}\``;
-      case "session":
-        return `session \`${query.value.slice(0, 8)}...\``;
-      case "latest":
-        return `latest ${query.value} sessions`;
-      default:
-        return "unknown";
-    }
-  }
-};
-
-// src/core/core.ts
-import path7 from "path";
-import os2 from "os";
-
-// src/core/session-store.ts
-import fs6 from "fs";
-import path6 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 = path6.dirname(this.filePath);
-    if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
-    fs6.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 (!fs6.existsSync(this.filePath)) return;
-    try {
-      const raw = JSON.parse(
-        fs6.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;
-  contextManager;
-  constructor(configManager) {
-    this.configManager = configManager;
-    const config = configManager.get();
-    this.agentCatalog = new AgentCatalog();
-    this.agentCatalog.load();
-    this.agentManager = new AgentManager(this.agentCatalog);
-    const storePath = path7.join(os2.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 = path7.join(os2.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.contextManager = new ContextManager();
-    this.contextManager.register(new EntireProvider());
-    this.fileService = new FileService(
-      path7.join(os2.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-NXABYJTT.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();
-    }
-  }
-  // --- Summary ---
-  async summarizeSession(sessionId) {
-    const session = this.sessionManager.getSession(sessionId);
-    if (session && session.status === "active") {
-      try {
-        const summary = await session.generateSummary();
-        if (!summary) return { ok: false, error: "Agent could not generate summary" };
-        return { ok: true, summary };
-      } catch (err) {
-        return { ok: false, error: err.message };
-      }
-    }
-    const record = this.sessionManager.getSessionRecord(sessionId);
-    if (!record?.agentSessionId) {
-      return { ok: false, error: "Session not found or has no agent history" };
-    }
-    const caps = getAgentCapabilities(record.agentName);
-    if (!caps.supportsResume) {
-      return { ok: false, error: `Agent "${record.agentName}" does not support resume \u2014 cannot summarize ended session` };
-    }
-    let tempSession;
-    try {
-      const agentInstance = await this.agentManager.resume(
-        record.agentName,
-        record.workingDir,
-        record.agentSessionId
-      );
-      tempSession = new Session({
-        id: `summary-${sessionId}`,
-        channelId: record.channelId,
-        agentName: record.agentName,
-        workingDirectory: record.workingDir,
-        agentInstance
-      });
-      tempSession.activate();
-      const summary = await tempSession.generateSummary();
-      if (!summary) return { ok: false, error: "Agent could not generate summary" };
-      return { ok: true, summary };
-    } catch (err) {
-      return { ok: false, error: err.message };
-    } finally {
-      if (tempSession) {
-        try {
-          await tempSession.destroy();
-        } catch {
-        }
-      }
-    }
-  }
-  // --- Archive ---
-  async archiveSession(sessionId) {
-    const session = this.sessionManager.getSession(sessionId);
-    const record = this.sessionManager.getSessionRecord(sessionId);
-    if (!session && !record) return { ok: false, error: "Session not found" };
-    const channelId = session?.channelId ?? record?.channelId;
-    if (!channelId) return { ok: false, error: "No channel for session" };
-    const adapter = this.adapters.get(channelId);
-    if (!adapter) return { ok: false, error: "Adapter not found for session" };
-    try {
-      if (session) {
-        await adapter.archiveSessionTopic(session.id);
-      } else {
-        await adapter.deleteSessionThread(sessionId);
-      }
-      if (session) {
-        try {
-          await this.sessionManager.cancelSession(sessionId);
-        } catch {
-        } finally {
-          session.archiving = false;
-        }
-      }
-      await this.sessionManager.removeRecord(sessionId);
-      return { ok: true };
-    } catch (err) {
-      if (session) session.archiving = false;
-      return { ok: false, error: err.message };
-    }
-  }
-  // --- Message Routing ---
-  async handleMessage(message) {
-    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
-    );
-  }
-  async createSessionWithContext(params) {
-    let contextResult = null;
-    try {
-      contextResult = await this.contextManager.buildContext(
-        params.contextQuery,
-        params.contextOptions
-      );
-    } catch (err) {
-      log7.warn({ err }, "Context building failed, proceeding without context");
-    }
-    const session = await this.createSession({
-      channelId: params.channelId,
-      agentName: params.agentName,
-      workingDirectory: params.workingDirectory,
-      createThread: params.createThread
-    });
-    if (contextResult) {
-      session.setContext(contextResult.markdown);
-    }
-    return { session, contextResult };
-  }
-  // --- Lazy Resume ---
-  /**
-   * Get active session by thread, or attempt lazy resume from store.
-   * Used by adapter command handlers that need a session but don't go through handleMessage().
-   */
-  async getOrResumeSession(channelId, threadId) {
-    const session = this.sessionManager.getSessionByThread(channelId, threadId);
-    if (session) return session;
-    return this.lazyResume({ channelId, threadId, userId: "", text: "" });
-  }
-  async lazyResume(message) {
-    const store = this.sessionStore;
-    if (!store) return null;
-    const lockKey = `${message.channelId}:${message.threadId}`;
-    const existing = this.resumeLocks.get(lockKey);
-    if (existing) return existing;
-    const record = store.findByPlatform(
-      message.channelId,
-      (p) => String(p.topicId) === message.threadId
-    );
-    if (!record) {
-      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 fs7 from "fs";
-import * as path8 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 = path8.resolve(path8.dirname(__filename), "../../ui/dist");
-      if (fs7.existsSync(path8.join(candidate, "index.html"))) {
-        this.uiDir = candidate;
-      }
-      if (!this.uiDir) {
-        const publishCandidate = path8.resolve(
-          path8.dirname(__filename),
-          "../ui"
-        );
-        if (fs7.existsSync(path8.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 = path8.normalize(urlPath);
-    const filePath = path8.join(this.uiDir, safePath);
-    if (!filePath.startsWith(this.uiDir + path8.sep) && filePath !== this.uiDir)
-      return false;
-    if (fs7.existsSync(filePath) && fs7.statSync(filePath).isFile()) {
-      const ext = path8.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
-      });
-      fs7.createReadStream(filePath).pipe(res);
-      return true;
-    }
-    const indexPath = path8.join(this.uiDir, "index.html");
-    if (fs7.existsSync(indexPath)) {
-      res.writeHead(200, {
-        "Content-Type": "text/html; charset=utf-8",
-        "Cache-Control": "no-cache"
-      });
-      fs7.createReadStream(indexPath).pipe(res);
-      return true;
-    }
-    return false;
-  }
-};
-
-// src/core/api/index.ts
-import * as http from "http";
-import * as fs8 from "fs";
-import * as path9 from "path";
-import * as os3 from "os";
-import * as crypto2 from "crypto";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/core/api/router.ts
-var Router = class {
-  routes = [];
-  get(path10, handler) {
-    this.add("GET", path10, handler);
-  }
-  post(path10, handler) {
-    this.add("POST", path10, handler);
-  }
-  put(path10, handler) {
-    this.add("PUT", path10, handler);
-  }
-  patch(path10, handler) {
-    this.add("PATCH", path10, handler);
-  }
-  delete(path10, handler) {
-    this.add("DELETE", path10, 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, path10, handler) {
-    const keys = [];
-    const pattern = path10.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/summary", async (_req, res, params) => {
-    const sessionId = decodeURIComponent(params.sessionId);
-    const result = await deps.core.summarizeSession(sessionId);
-    if (result.ok) {
-      deps.sendJson(res, 200, result);
-    } else {
-      deps.sendJson(res, 400, result);
-    }
-  });
-  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-AHYI4MYL.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-AHYI4MYL.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-6S355X75.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-AHYI4MYL.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 = path9.join(os3.homedir(), ".openacp", "api.port");
-var cachedVersion;
-function getVersion() {
-  if (cachedVersion) return cachedVersion;
-  try {
-    const __filename = fileURLToPath2(import.meta.url);
-    const pkgPath = path9.resolve(
-      path9.dirname(__filename),
-      "../../../package.json"
-    );
-    const pkg = JSON.parse(fs8.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 ?? path9.join(os3.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 = path9.dirname(this.portFilePath);
-    fs8.mkdirSync(dir, { recursive: true });
-    fs8.writeFileSync(this.portFilePath, String(this.actualPort));
-  }
-  removePortFile() {
-    try {
-      fs8.unlinkSync(this.portFilePath);
-    } catch {
-    }
-  }
-  loadOrCreateSecret() {
-    const dir = path9.dirname(this.secretFilePath);
-    fs8.mkdirSync(dir, { recursive: true });
-    try {
-      this.secret = fs8.readFileSync(this.secretFilePath, "utf-8").trim();
-      if (this.secret) {
-        try {
-          const stat = fs8.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 = crypto2.randomBytes(32).toString("hex");
-    fs8.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 && crypto2.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 && crypto2.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,
-  ContextManager,
-  DEFAULT_MAX_TOKENS,
-  CheckpointReader,
-  EntireProvider,
-  OpenACPCore,
-  SSEManager,
-  StaticServer,
-  ApiServer,
-  TopicManager
-};
-//# sourceMappingURL=chunk-LGP2YGRL.js.map