@openacp/cli 2026.327.5 → 2026.330.2

package/dist/{chunk-XIBG7LSL.js → chunk-7RKPIM3E.js}

@@ -1,6 +1,6 @@
 import {
   AgentCatalog
-} from "./chunk-SHTGQGAU.js";
+} from "./chunk-V2YZWYXT.js";
 import {
   getAgentCapabilities
 } from "./chunk-ZSLHHQPQ.js";
@@ -8,31 +8,42 @@ import {
   readTextFileWithRange
 } from "./chunk-OYSAN7UX.js";
 import {
+  closeSessionLogger,
   createChildLogger,
   createSessionLogger
-} from "./chunk-XMMAGAT4.js";
+} from "./chunk-R6KZYF7D.js";
 
 // src/core/utils/streams.ts
 function nodeToWebWritable(nodeStream) {
   return new WritableStream({
     write(chunk) {
       return new Promise((resolve, reject) => {
-        nodeStream.write(Buffer.from(chunk), (err) => {
-          if (err) reject(err);
-          else resolve();
-        });
+        const ok = nodeStream.write(chunk);
+        if (ok) {
+          resolve();
+          return;
+        }
+        nodeStream.once("drain", resolve);
+        nodeStream.once("error", reject);
       });
+    },
+    close() {
+      nodeStream.end();
+    },
+    abort(reason) {
+      nodeStream.destroy(reason instanceof Error ? reason : new Error(String(reason)));
     }
   });
 }
 function nodeToWebReadable(nodeStream) {
   return new ReadableStream({
     start(controller) {
-      nodeStream.on("data", (chunk) => {
-        controller.enqueue(new Uint8Array(chunk));
-      });
+      nodeStream.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
       nodeStream.on("end", () => controller.close());
       nodeStream.on("error", (err) => controller.error(err));
+    },
+    cancel() {
+      nodeStream.destroy();
     }
   });
 }
@@ -131,8 +142,8 @@ var TypedEmitter = class {
 // src/core/agents/agent-instance.ts
 import { spawn as spawn2, execFileSync } from "child_process";
 import { Transform } from "stream";
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 import { PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
 
@@ -286,15 +297,48 @@ var McpManager = class {
   }
 };
 
+// src/core/utils/debug-tracer.ts
+import fs from "fs";
+import path from "path";
+var DEBUG_ENABLED = process.env.OPENACP_DEBUG === "true" || process.env.OPENACP_DEBUG === "1";
+var DebugTracer = class {
+  constructor(sessionId, workingDirectory) {
+    this.sessionId = sessionId;
+    this.workingDirectory = workingDirectory;
+    this.logDir = path.join(workingDirectory, ".log");
+  }
+  dirCreated = false;
+  logDir;
+  log(layer, data) {
+    try {
+      if (!this.dirCreated) {
+        fs.mkdirSync(this.logDir, { recursive: true });
+        this.dirCreated = true;
+      }
+      const filePath = path.join(this.logDir, `${this.sessionId}_${layer}.jsonl`);
+      const line = JSON.stringify({ ts: Date.now(), ...data }) + "\n";
+      fs.appendFileSync(filePath, line);
+    } catch {
+    }
+  }
+  /** No-op cleanup — establishes the pattern for future async implementations */
+  destroy() {
+  }
+};
+function createDebugTracer(sessionId, workingDirectory) {
+  if (!DEBUG_ENABLED) return null;
+  return new DebugTracer(sessionId, workingDirectory);
+}
+
 // src/core/agents/agent-instance.ts
 var log = createChildLogger({ module: "agent-instance" });
 function findPackageRoot(startDir) {
   let dir = startDir;
-  while (dir !== path.dirname(dir)) {
-    if (fs.existsSync(path.join(dir, "package.json"))) {
+  while (dir !== path2.dirname(dir)) {
+    if (fs2.existsSync(path2.join(dir, "package.json"))) {
       return dir;
     }
-    dir = path.dirname(dir);
+    dir = path2.dirname(dir);
   }
   return startDir;
 }
@@ -306,26 +350,26 @@ function resolveAgentCommand(cmd) {
   }
   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")
+      path2.resolve(root, "node_modules", "@zed-industries", cmd, "dist", "index.js"),
+      path2.resolve(root, "node_modules", cmd, "dist", "index.js")
     ];
     for (const jsPath of packageDirs) {
-      if (fs.existsSync(jsPath)) {
+      if (fs2.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");
+    const localBin = path2.resolve(root, "node_modules", ".bin", cmd);
+    if (fs2.existsSync(localBin)) {
+      const content = fs2.readFileSync(localBin, "utf-8");
       if (content.startsWith("#!/usr/bin/env node")) {
         return { command: process.execPath, args: [localBin] };
       }
       const match = content.match(/"([^"]+\.js)"/);
       if (match) {
-        const target = path.resolve(path.dirname(localBin), match[1]);
-        if (fs.existsSync(target)) {
+        const target = path2.resolve(path2.dirname(localBin), match[1]);
+        if (fs2.existsSync(target)) {
           return { command: process.execPath, args: [target] };
         }
       }
@@ -334,7 +378,7 @@ function resolveAgentCommand(cmd) {
   try {
     const fullPath = execFileSync("which", [cmd], { encoding: "utf-8" }).trim();
     if (fullPath) {
-      const content = fs.readFileSync(fullPath, "utf-8");
+      const content = fs2.readFileSync(fullPath, "utf-8");
       if (content.startsWith("#!/usr/bin/env node")) {
         return { command: process.execPath, args: [fullPath] };
       }
@@ -349,10 +393,12 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
   stderrCapture;
   terminalManager = new TerminalManager();
   static mcpManager = new McpManager();
+  _destroying = false;
   sessionId;
   agentName;
   promptCapabilities;
   middlewareChain;
+  debugTracer = null;
   // Callback — set by core when wiring events
   onPermissionRequest = async () => "";
   constructor(agentName) {
@@ -395,20 +441,28 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
     });
     const stdinLogger = new Transform({
       transform(chunk, _enc, cb) {
-        log.debug(
-          { direction: "send", raw: chunk.toString().trimEnd() },
-          "ACP raw"
-        );
+        if (instance.debugTracer) {
+          const raw = chunk.toString().trimEnd();
+          try {
+            instance.debugTracer.log("acp", { dir: "send", data: JSON.parse(raw) });
+          } catch {
+            instance.debugTracer.log("acp", { dir: "send", data: raw });
+          }
+        }
         cb(null, chunk);
       }
     });
     stdinLogger.pipe(instance.child.stdin);
     const stdoutLogger = new Transform({
       transform(chunk, _enc, cb) {
-        log.debug(
-          { direction: "recv", raw: chunk.toString().trimEnd() },
-          "ACP raw"
-        );
+        if (instance.debugTracer) {
+          const raw = chunk.toString().trimEnd();
+          try {
+            instance.debugTracer.log("acp", { dir: "recv", data: JSON.parse(raw) });
+          } catch {
+            instance.debugTracer.log("acp", { dir: "recv", data: raw });
+          }
+        }
         cb(null, chunk);
       }
     });
@@ -442,15 +496,17 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
   }
   setupCrashDetection() {
     this.child.on("exit", (code, signal) => {
+      if (this._destroying) return;
       log.info(
         { sessionId: this.sessionId, exitCode: code, signal },
         "Agent process exited"
       );
-      if (code !== 0 && code !== null) {
+      if (code !== 0 && code !== null || signal) {
         const stderr = this.stderrCapture.getLastLines();
         this.emit("agent_event", {
           type: "error",
-          message: `Agent crashed (exit code ${code})
+          message: signal ? `Agent killed by signal ${signal}
+${stderr}` : `Agent crashed (exit code ${code})
 ${stderr}`
         });
       }
@@ -475,6 +531,7 @@ ${stderr}`
       mcpServers: resolvedMcp
     });
     instance.sessionId = response.sessionId;
+    instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
     instance.setupCrashDetection();
     log.info(
       { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
@@ -495,6 +552,7 @@ ${stderr}`
         cwd: workingDirectory
       });
       instance.sessionId = response.sessionId;
+      instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
       log.info(
         { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
         "Agent resume complete"
@@ -510,6 +568,7 @@ ${stderr}`
         mcpServers: resolvedMcp
       });
       instance.sessionId = response.sessionId;
+      instance.debugTracer = createDebugTracer(response.sessionId, workingDirectory);
       log.info(
         { sessionId: response.sessionId, durationMs: Date.now() - spawnStart },
         "Agent fallback spawn complete"
@@ -698,8 +757,8 @@ ${stderr}`
           writePath = result.path;
           writeContent = result.content;
         }
-        await fs.promises.mkdir(path.dirname(writePath), { recursive: true });
-        await fs.promises.writeFile(writePath, writeContent, "utf-8");
+        await fs2.promises.mkdir(path2.dirname(writePath), { recursive: true });
+        await fs2.promises.writeFile(writePath, writeContent, "utf-8");
         return {};
       },
       // ── Terminal operations (delegated to TerminalManager) ─────────────
@@ -783,10 +842,10 @@ ${stderr}`
     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);
+        const data = await fs2.promises.readFile(att.filePath);
         contentBlocks.push({ type: "image", data: data.toString("base64"), mimeType: att.mimeType });
       } else if (att.type === "audio" && this.promptCapabilities?.audio && !tooLarge) {
-        const data = await fs.promises.readFile(att.filePath);
+        const data = await fs2.promises.readFile(att.filePath);
         contentBlocks.push({ type: "audio", data: data.toString("base64"), mimeType: att.mimeType });
       } else {
         if ((att.type === "image" || att.type === "audio") && !tooLarge) {
@@ -810,11 +869,23 @@ ${stderr}`
     await this.connection.cancel({ sessionId: this.sessionId });
   }
   async destroy() {
+    this._destroying = true;
     this.terminalManager.destroyAll();
-    this.child.kill("SIGTERM");
-    setTimeout(() => {
-      if (!this.child.killed) this.child.kill("SIGKILL");
-    }, 1e4);
+    if (this.child.exitCode !== null) return;
+    await new Promise((resolve) => {
+      this.child.on("exit", () => {
+        clearTimeout(forceKillTimer);
+        resolve();
+      });
+      this.child.kill("SIGTERM");
+      const forceKillTimer = setTimeout(() => {
+        if (this.child.exitCode === null) this.child.kill("SIGKILL");
+        resolve();
+      }, 1e4);
+      if (typeof forceKillTimer === "object" && forceKillTimer !== null && "unref" in forceKillTimer) {
+        forceKillTimer.unref();
+      }
+    });
   }
 };
 
@@ -921,6 +992,9 @@ var PermissionGate = class {
     this.timeoutMs = timeoutMs ?? DEFAULT_TIMEOUT_MS;
   }
   setPending(request) {
+    if (!this.settled && this.rejectFn) {
+      this.rejectFn(new Error("Superseded by new permission request"));
+    }
     this.request = request;
     this.settled = false;
     this.clearTimeout();
@@ -930,6 +1004,9 @@ var PermissionGate = class {
       this.timeoutTimer = setTimeout(() => {
         this.reject("Permission request timed out (no response received)");
       }, this.timeoutMs);
+      if (typeof this.timeoutTimer === "object" && "unref" in this.timeoutTimer) {
+        this.timeoutTimer.unref();
+      }
     });
   }
   resolve(optionId) {
@@ -971,7 +1048,7 @@ var PermissionGate = class {
 
 // src/core/sessions/session.ts
 import { nanoid } from "nanoid";
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 var moduleLog = createChildLogger({ module: "session" });
 var TTS_PROMPT_INSTRUCTION = `
 
@@ -982,7 +1059,7 @@ 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"]),
+  error: /* @__PURE__ */ new Set(["active", "cancelled"]),
   cancelled: /* @__PURE__ */ new Set(["active"]),
   finished: /* @__PURE__ */ new Set()
 };
@@ -1097,30 +1174,28 @@ var Session = class extends TypedEmitter {
       await this.runWarmup();
       return;
     }
+    if (this._status === "finished") return;
     this.promptCount++;
-    if (this._status === "initializing") {
+    if (this._status === "initializing" || this._status === "cancelled" || this._status === "error") {
       this.activate();
     }
     const promptStart = Date.now();
     this.log.debug("Prompt execution started");
-    if (this.pendingContext) {
+    const contextUsed = this.pendingContext;
+    if (contextUsed) {
       text = `[CONVERSATION HISTORY - This is context from previous sessions, not current conversation]
 
-${this.pendingContext}
+${contextUsed}
 
 [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) => {
@@ -1141,6 +1216,12 @@ ${text}`;
       if (response && typeof response === "object" && "stopReason" in response) {
         stopReason = response.stopReason ?? "end_turn";
       }
+      if (contextUsed) {
+        this.pendingContext = null;
+      }
+      if (ttsActive && this.voiceMode === "next") {
+        this.voiceMode = "off";
+      }
     } finally {
       if (accumulatorListener) {
         this.off("agent_event", accumulatorListener);
@@ -1184,7 +1265,7 @@ ${text}`;
       try {
         const audioPath = att.originalFilePath || att.filePath;
         const audioMime = att.originalFilePath ? "audio/ogg" : att.mimeType;
-        const audioBuffer = await fs2.promises.readFile(audioPath);
+        const audioBuffer = await fs3.promises.readFile(audioPath);
         const result = await this.speechService.transcribe(audioBuffer, audioMime);
         this.log.info({ provider: "stt", duration: result.duration }, "Voice transcribed");
         this.emit("agent_event", {
@@ -1220,20 +1301,26 @@ ${result.text}` : result.text;
       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
+      let ttsTimer;
+      const timeoutPromise = new Promise((_, reject) => {
+        ttsTimer = setTimeout(() => reject(new Error("TTS synthesis timed out")), TTS_TIMEOUT_MS);
       });
-      this.log.info("TTS synthesis completed");
+      try {
+        const result = await Promise.race([
+          this.speechService.synthesize(ttsText),
+          timeoutPromise
+        ]);
+        const base64 = result.audioBuffer.toString("base64");
+        this.emit("agent_event", {
+          type: "audio_content",
+          data: base64,
+          mimeType: result.mimeType
+        });
+        this.emit("agent_event", { type: "tts_strip" });
+        this.log.info("TTS synthesis completed");
+      } finally {
+        clearTimeout(ttsTimer);
+      }
     } catch (err) {
       this.log.warn({ err }, "TTS synthesis failed, skipping");
     }
@@ -1337,7 +1424,12 @@ ${result.text}` : result.text;
   }
   async destroy() {
     this.log.info("Session destroyed");
+    if (this.permissionGate.isPending) {
+      this.permissionGate.reject("Session destroyed");
+    }
+    this.queue.clear();
     await this.agentInstance.destroy();
+    closeSessionLogger(this.log);
   }
 };
 
@@ -1426,8 +1518,12 @@ var SessionManager = class {
   async cancelSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (session) {
-      await session.abortPrompt();
+      try {
+        await session.abortPrompt();
+      } catch {
+      }
       session.markCancelled();
+      this.sessions.delete(sessionId);
     }
     if (this.store) {
       const record = this.store.get(sessionId);
@@ -1458,6 +1554,25 @@ var SessionManager = class {
     await this.store.remove(sessionId);
     this.eventBus?.emit("session:deleted", { sessionId });
   }
+  /**
+   * Graceful shutdown: persist session state without killing agent subprocesses.
+   * Agent processes will exit naturally when the parent process terminates.
+   */
+  async shutdownAll() {
+    if (this.store) {
+      for (const session of this.sessions.values()) {
+        const record = this.store.get(session.id);
+        if (record) {
+          await this.store.save({ ...record, status: "finished" });
+        }
+      }
+    }
+    this.sessions.clear();
+  }
+  /**
+   * Forcefully destroy all sessions (kill agent subprocesses).
+   * Use only when sessions must be fully torn down (e.g. archive).
+   */
   async destroyAll() {
     if (this.store) {
       for (const session of this.sessions.values()) {
@@ -1494,15 +1609,29 @@ var SessionBridge = class {
   sessionEventHandler;
   statusChangeHandler;
   namedHandler;
+  get tracer() {
+    return this.session.agentInstance.debugTracer ?? null;
+  }
   /** Send message to adapter, optionally running through message:outgoing middleware */
   async sendMessage(sessionId, message) {
-    const mw = this.deps.middlewareChain;
-    if (mw) {
-      const result = await mw.execute("message:outgoing", { sessionId, message }, async (m) => m);
-      if (!result) return;
-      this.adapter.sendMessage(sessionId, result.message);
-    } else {
-      this.adapter.sendMessage(sessionId, message);
+    try {
+      const mw = this.deps.middlewareChain;
+      if (mw) {
+        const result = await mw.execute("message:outgoing", { sessionId, message }, async (m) => m);
+        this.tracer?.log("core", { step: "middleware:outgoing", sessionId, hook: "message:outgoing", blocked: !result });
+        if (!result) return;
+        this.tracer?.log("core", { step: "dispatch", sessionId, message: result.message });
+        this.adapter.sendMessage(sessionId, result.message).catch((err) => {
+          log2.error({ err, sessionId }, "Failed to send message to adapter");
+        });
+      } else {
+        this.tracer?.log("core", { step: "dispatch", sessionId, message });
+        this.adapter.sendMessage(sessionId, message).catch((err) => {
+          log2.error({ err, sessionId }, "Failed to send message to adapter");
+        });
+      }
+    } catch (err) {
+      log2.error({ err, sessionId }, "Error in sendMessage middleware");
     }
   }
   connect() {
@@ -1538,23 +1667,37 @@ var SessionBridge = class {
   }
   wireSessionToAdapter() {
     this.sessionEventHandler = (event) => {
+      this.tracer?.log("core", { step: "agent_event", sessionId: this.session.id, event });
       const mw = this.deps.middlewareChain;
       if (mw) {
         mw.execute("agent:beforeEvent", { sessionId: this.session.id, event }, async (e) => e).then((result) => {
+          this.tracer?.log("core", { step: "middleware:before", sessionId: this.session.id, hook: "agent:beforeEvent", blocked: !result });
           if (!result) return;
-          const transformedEvent = result.event;
-          const outgoing = this.handleAgentEvent(transformedEvent);
-          mw.execute("agent:afterEvent", {
-            sessionId: this.session.id,
-            event: transformedEvent,
-            outgoingMessage: outgoing ?? { type: "text", text: "" }
-          }, async (e) => e).catch(() => {
-          });
+          try {
+            const transformedEvent = result.event;
+            const outgoing = this.handleAgentEvent(transformedEvent);
+            mw.execute("agent:afterEvent", {
+              sessionId: this.session.id,
+              event: transformedEvent,
+              outgoingMessage: outgoing ?? { type: "text", text: "" }
+            }, async (e) => e).catch(() => {
+            });
+          } catch (err) {
+            log2.error({ err, sessionId: this.session.id }, "Error handling agent event after middleware");
+          }
         }).catch(() => {
-          this.handleAgentEvent(event);
+          try {
+            this.handleAgentEvent(event);
+          } catch (err) {
+            log2.error({ err, sessionId: this.session.id }, "Error handling agent event (middleware fallback)");
+          }
         });
       } else {
-        this.handleAgentEvent(event);
+        try {
+          this.handleAgentEvent(event);
+        } catch (err) {
+          log2.error({ err, sessionId: this.session.id }, "Error handling agent event");
+        }
       }
     };
     this.session.on("agent_event", this.sessionEventHandler);
@@ -1578,6 +1721,7 @@ var SessionBridge = class {
       case "plan":
       case "usage":
         outgoing = this.deps.messageTransformer.transform(event, ctx);
+        this.tracer?.log("core", { step: "transform", sessionId: this.session.id, input: event, output: outgoing });
         this.sendMessage(this.session.id, outgoing);
         break;
       case "session_end":
@@ -1607,12 +1751,12 @@ var SessionBridge = class {
         break;
       case "image_content": {
         if (this.deps.fileService) {
-          const fs5 = this.deps.fileService;
+          const fs6 = this.deps.fileService;
           const sid = this.session.id;
           const { data, mimeType } = event;
           const buffer = Buffer.from(data, "base64");
-          const ext = fs5.extensionFromMime(mimeType);
-          fs5.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
+          const ext = fs6.extensionFromMime(mimeType);
+          fs6.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
             this.sendMessage(sid, {
               type: "attachment",
               text: "",
@@ -1624,12 +1768,12 @@ var SessionBridge = class {
       }
       case "audio_content": {
         if (this.deps.fileService) {
-          const fs5 = this.deps.fileService;
+          const fs6 = this.deps.fileService;
           const sid = this.session.id;
           const { data, mimeType } = event;
           const buffer = Buffer.from(data, "base64");
-          const ext = fs5.extensionFromMime(mimeType);
-          fs5.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
+          const ext = fs6.extensionFromMime(mimeType);
+          fs6.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
             this.sendMessage(sid, {
               type: "attachment",
               text: "",
@@ -1678,6 +1822,9 @@ var SessionBridge = class {
         outgoing = this.deps.messageTransformer.transform(event);
         this.sendMessage(this.session.id, outgoing);
         break;
+      case "tts_strip":
+        this.adapter.stripTTSBlock?.(this.session.id);
+        break;
     }
     this.deps.eventBus?.emit("agent:event", {
       sessionId: this.session.id,
@@ -1780,7 +1927,7 @@ var SessionBridge = class {
         sessionId: this.session.id,
         status: to
       });
-      if (to === "finished" || to === "cancelled") {
+      if (to === "finished") {
         queueMicrotask(() => this.disconnect());
       }
     };
@@ -1803,14 +1950,22 @@ function extractFileInfo(name, kind, content, rawInput, meta) {
   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 };
+    const toolResponse = resolveToolResponse(m);
+    if (toolResponse) {
+      const file = toolResponse.file;
+      if (typeof file?.filePath === "string" && typeof file?.content === "string") {
+        info = { filePath: file.filePath, content: file.content };
+      }
+      if (!info && typeof toolResponse.filePath === "string" && typeof toolResponse.originalFile === "string") {
+        const originalFile = toolResponse.originalFile;
+        const oldString = typeof toolResponse.oldString === "string" ? toolResponse.oldString : void 0;
+        const newString = typeof toolResponse.newString === "string" ? toolResponse.newString : void 0;
+        const newContent = oldString && newString ? originalFile.replace(oldString, newString) : originalFile;
+        info = { filePath: toolResponse.filePath, content: newContent, oldContent: originalFile };
+      }
+      if (!info && typeof toolResponse.filePath === "string" && typeof toolResponse.content === "string") {
+        info = { filePath: toolResponse.filePath, content: toolResponse.content };
+      }
     }
   }
   if (!info && rawInput && typeof rawInput === "object") {
@@ -1819,7 +1974,19 @@ function extractFileInfo(name, kind, content, rawInput, meta) {
     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 (kind === "edit") {
+        const oldStr = typeof ri.old_string === "string" ? ri.old_string : typeof ri.oldText === "string" ? ri.oldText : void 0;
+        const newStr = typeof ri.new_string === "string" ? ri.new_string : typeof ri.newText === "string" ? ri.newText : void 0;
+        if (newStr) {
+          info = { filePath, content: newStr, oldContent: oldStr };
+        } else {
+          info = { filePath, content: riContent || parsed?.content, oldContent: parsed?.oldContent };
+        }
+      } else if (kind === "write") {
+        info = { filePath, content: riContent || parsed?.content, oldContent: parsed?.oldContent };
+      } else {
+        info = { filePath, content: parsed?.content || riContent, oldContent: parsed?.oldContent };
+      }
     }
   }
   if (!info && content) {
@@ -1833,6 +2000,16 @@ function extractFileInfo(name, kind, content, rawInput, meta) {
   if (!info.filePath || !info.content) return null;
   return info;
 }
+function resolveToolResponse(meta) {
+  const claudeCode = meta.claudeCode;
+  if (claudeCode?.toolResponse && typeof claudeCode.toolResponse === "object") {
+    return claudeCode.toolResponse;
+  }
+  if (meta.toolResponse && typeof meta.toolResponse === "object") {
+    return meta.toolResponse;
+  }
+  return void 0;
+}
 function parseContent(content) {
   if (typeof content === "string") {
     return { content };
@@ -1891,7 +2068,30 @@ function parseContent(content) {
 
 // src/core/message-transformer.ts
 var log3 = createChildLogger({ module: "message-transformer" });
+function computeLineDiff(oldStr, newStr) {
+  const oldLines = oldStr ? oldStr.split("\n") : [];
+  const newLines = newStr ? newStr.split("\n") : [];
+  let prefixLen = 0;
+  const minLen = Math.min(oldLines.length, newLines.length);
+  while (prefixLen < minLen && oldLines[prefixLen] === newLines[prefixLen]) {
+    prefixLen++;
+  }
+  let suffixLen = 0;
+  const maxSuffix = minLen - prefixLen;
+  while (suffixLen < maxSuffix && oldLines[oldLines.length - 1 - suffixLen] === newLines[newLines.length - 1 - suffixLen]) {
+    suffixLen++;
+  }
+  return {
+    added: Math.max(0, newLines.length - prefixLen - suffixLen),
+    removed: Math.max(0, oldLines.length - prefixLen - suffixLen)
+  };
+}
 var MessageTransformer = class {
+  tunnelService;
+  /** Cache rawInput from tool_call so it's available in tool_update (which often lacks it) */
+  toolRawInputCache = /* @__PURE__ */ new Map();
+  /** Cache viewer links generated from intermediate updates so completion events carry them */
+  toolViewerCache = /* @__PURE__ */ new Map();
   constructor(tunnelService) {
     this.tunnelService = tunnelService;
   }
@@ -1902,6 +2102,9 @@ var MessageTransformer = class {
       case "thought":
         return { type: "thought", text: event.content };
       case "tool_call": {
+        if (event.id && this.isNonEmptyInput(event.rawInput)) {
+          this.toolRawInputCache.set(event.id, event.rawInput);
+        }
         const meta = event.meta;
         const metadata = {
           id: event.id,
@@ -1919,6 +2122,14 @@ var MessageTransformer = class {
         return { type: "tool_call", text: event.name, metadata };
       }
       case "tool_update": {
+        if (event.id && this.isNonEmptyInput(event.rawInput)) {
+          this.toolRawInputCache.set(event.id, event.rawInput);
+        }
+        const cachedRawInput = event.id ? this.toolRawInputCache.get(event.id) : void 0;
+        const effectiveRawInput = this.isNonEmptyInput(event.rawInput) ? event.rawInput : cachedRawInput;
+        if (event.id && (event.status === "completed" || event.status === "done" || event.status === "failed" || event.status === "error")) {
+          this.toolRawInputCache.delete(event.id);
+        }
         const meta = event.meta;
         const metadata = {
           id: event.id,
@@ -1926,12 +2137,28 @@ var MessageTransformer = class {
           kind: event.kind,
           status: event.status,
           content: event.content,
-          rawInput: event.rawInput,
+          rawInput: effectiveRawInput,
           displaySummary: meta?.displaySummary,
           displayTitle: meta?.displayTitle,
           displayKind: meta?.displayKind
         };
-        this.enrichWithViewerLinks(event, metadata, sessionContext);
+        const enrichEvent = { ...event, rawInput: effectiveRawInput };
+        this.enrichWithViewerLinks(enrichEvent, metadata, sessionContext);
+        if (event.id) {
+          const cached = this.toolViewerCache.get(event.id);
+          if (cached) {
+            metadata.viewerLinks = cached.viewerLinks;
+            metadata.viewerFilePath = cached.viewerFilePath;
+          } else if (metadata.viewerLinks) {
+            this.toolViewerCache.set(event.id, {
+              viewerLinks: metadata.viewerLinks,
+              viewerFilePath: metadata.viewerFilePath
+            });
+          }
+          if (event.status === "completed" || event.status === "done" || event.status === "failed" || event.status === "error") {
+            this.toolViewerCache.delete(event.id);
+          }
+        }
         return { type: "tool_update", text: "", metadata };
       }
       case "plan":
@@ -1947,7 +2174,7 @@ var MessageTransformer = class {
           metadata: {
             tokensUsed: event.tokensUsed,
             contextSize: event.contextSize,
-            cost: event.cost
+            cost: event.cost?.amount
           }
         };
       case "session_end":
@@ -2001,12 +2228,38 @@ var MessageTransformer = class {
         return { type: "text", text: "" };
     }
   }
+  /** Check if rawInput is a non-empty object (not null, not {}) */
+  isNonEmptyInput(input) {
+    return input !== null && input !== void 0 && typeof input === "object" && !Array.isArray(input) && Object.keys(input).length > 0;
+  }
   enrichWithViewerLinks(event, metadata, sessionContext) {
-    if (!this.tunnelService || !sessionContext) return;
-    const name = "name" in event ? event.name || "" : "";
     const kind = "kind" in event ? event.kind : void 0;
+    if (!metadata.diffStats && (kind === "edit" || kind === "write")) {
+      const ri = event.rawInput;
+      if (ri) {
+        const oldStr = typeof ri.old_string === "string" ? ri.old_string : typeof ri.oldText === "string" ? ri.oldText : null;
+        const newStr = typeof ri.new_string === "string" ? ri.new_string : typeof ri.newText === "string" ? ri.newText : typeof ri.content === "string" ? ri.content : null;
+        if (oldStr !== null && newStr !== null) {
+          const stats = computeLineDiff(oldStr, newStr);
+          if (stats.added > 0 || stats.removed > 0) {
+            metadata.diffStats = stats;
+          }
+        } else if (oldStr === null && newStr !== null && kind === "write") {
+          const added = newStr.split("\n").length;
+          if (added > 0) metadata.diffStats = { added, removed: 0 };
+        }
+      }
+    }
+    if (!this.tunnelService || !sessionContext) {
+      log3.debug(
+        { hasTunnel: !!this.tunnelService, hasCtx: !!sessionContext, kind },
+        "enrichWithViewerLinks: skipping (no tunnel or session context)"
+      );
+      return;
+    }
+    const name = "name" in event ? event.name || "" : "";
     log3.debug(
-      { name, kind, status: event.status, hasContent: !!event.content },
+      { name, kind, status: event.status, hasContent: !!event.content, hasRawInput: !!event.rawInput },
       "enrichWithViewerLinks: inspecting event"
     );
     const fileInfo = extractFileInfo(
@@ -2016,7 +2269,18 @@ var MessageTransformer = class {
       event.rawInput,
       event.meta
     );
-    if (!fileInfo) return;
+    if (!fileInfo) {
+      log3.debug(
+        { name, kind, hasContent: !!event.content, hasRawInput: !!event.rawInput, hasMeta: !!event.meta },
+        "enrichWithViewerLinks: extractFileInfo returned null"
+      );
+      return;
+    }
+    const publicUrl = this.tunnelService.getPublicUrl();
+    if (publicUrl.startsWith("http://localhost") || publicUrl.startsWith("http://127.0.0.1")) {
+      log3.debug({ kind, filePath: fileInfo.filePath }, "enrichWithViewerLinks: skipping (no public tunnel URL)");
+      return;
+    }
     log3.info(
       {
         name,
@@ -2037,6 +2301,12 @@ var MessageTransformer = class {
         sessionContext.workingDirectory
       );
       if (id2) viewerLinks.diff = this.tunnelService.diffUrl(id2);
+      if (!metadata.diffStats) {
+        const stats = computeLineDiff(fileInfo.oldContent, fileInfo.content);
+        if (stats.added > 0 || stats.removed > 0) {
+          metadata.diffStats = stats;
+        }
+      }
     }
     const id = store.storeFile(
       sessionContext.id,
@@ -2152,12 +2422,12 @@ var EventBus = class extends TypedEmitter {
 };
 
 // src/core/core.ts
-import path4 from "path";
+import path5 from "path";
 import os from "os";
 
 // src/core/sessions/session-store.ts
-import fs3 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path3 from "path";
 var log5 = createChildLogger({ module: "session-store" });
 var DEBOUNCE_MS = 2e3;
 var JsonFileSessionStore = class {
@@ -2219,9 +2489,9 @@ var JsonFileSessionStore = class {
       version: 1,
       sessions: Object.fromEntries(this.records)
     };
-    const dir = path2.dirname(this.filePath);
-    if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
-    fs3.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+    const dir = path3.dirname(this.filePath);
+    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+    fs4.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
   }
   destroy() {
     if (this.debounceTimer) clearTimeout(this.debounceTimer);
@@ -2234,10 +2504,10 @@ var JsonFileSessionStore = class {
     }
   }
   load() {
-    if (!fs3.existsSync(this.filePath)) return;
+    if (!fs4.existsSync(this.filePath)) return;
     try {
       const raw = JSON.parse(
-        fs3.readFileSync(this.filePath, "utf-8")
+        fs4.readFileSync(this.filePath, "utf-8")
       );
       if (raw.version !== 1) {
         log5.warn(
@@ -2251,7 +2521,11 @@ var JsonFileSessionStore = class {
       }
       log5.debug({ count: this.records.size }, "Loaded session records");
     } catch (err) {
-      log5.error({ err }, "Failed to load session store");
+      log5.error({ err }, "Failed to load session store, backing up corrupt file");
+      try {
+        fs4.renameSync(this.filePath, `${this.filePath}.bak`);
+      } catch {
+      }
     }
   }
   cleanup() {
@@ -2392,6 +2666,7 @@ var MiddlewareChain = class {
     const existing = this.chains.get(hook);
     if (existing) {
       existing.push(entry);
+      existing.sort((a, b) => a.priority - b.priority);
     } else {
       this.chains.set(hook, [entry]);
     }
@@ -2401,7 +2676,7 @@ var MiddlewareChain = class {
     if (!handlers || handlers.length === 0) {
       return coreHandler(payload);
     }
-    const sorted = [...handlers].sort((a, b) => a.priority - b.priority);
+    const sorted = handlers;
     let cachedResult = void 0;
     const buildNext = (index, currentPayload) => {
       return async () => {
@@ -2431,15 +2706,16 @@ var MiddlewareChain = class {
           return nextResult;
         };
         let handlerResult;
+        let timeoutTimer;
         try {
           const timeoutPromise = new Promise((_, reject) => {
-            const timer = setTimeout(
+            timeoutTimer = setTimeout(
               () => reject(new Error(`Middleware timeout: ${entry.pluginName} on hook ${hook}`)),
               MIDDLEWARE_TIMEOUT_MS
             );
-            if (typeof timer === "object" && timer !== null && "unref" in timer) {
+            if (typeof timeoutTimer === "object" && timeoutTimer !== null && "unref" in timeoutTimer) {
               ;
-              timer.unref();
+              timeoutTimer.unref();
             }
           });
           handlerResult = await Promise.race([
@@ -2452,6 +2728,8 @@ var MiddlewareChain = class {
           }
           this.errorTracker?.increment(entry.pluginName);
           return nextFn();
+        } finally {
+          clearTimeout(timeoutTimer);
         }
         if (handlerResult === null) {
           return null;
@@ -2519,26 +2797,27 @@ var ErrorTracker = class {
 };
 
 // src/core/plugin/plugin-storage.ts
-import fs4 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path4 from "path";
 var PluginStorageImpl = class {
   kvPath;
   dataDir;
   writeChain = Promise.resolve();
   constructor(baseDir) {
-    this.dataDir = path3.join(baseDir, "data");
-    this.kvPath = path3.join(baseDir, "kv.json");
+    this.dataDir = path4.join(baseDir, "data");
+    this.kvPath = path4.join(baseDir, "kv.json");
+    fs5.mkdirSync(baseDir, { recursive: true });
   }
   readKv() {
     try {
-      const raw = fs4.readFileSync(this.kvPath, "utf-8");
+      const raw = fs5.readFileSync(this.kvPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return {};
     }
   }
   writeKv(data) {
-    fs4.writeFileSync(this.kvPath, JSON.stringify(data), "utf-8");
+    fs5.writeFileSync(this.kvPath, JSON.stringify(data), "utf-8");
   }
   async get(key) {
     const data = this.readKv();
@@ -2564,7 +2843,7 @@ var PluginStorageImpl = class {
     return Object.keys(this.readKv());
   }
   getDataDir() {
-    fs4.mkdirSync(this.dataDir, { recursive: true });
+    fs5.mkdirSync(this.dataDir, { recursive: true });
     return this.dataDir;
   }
 };
@@ -2780,6 +3059,9 @@ var LifecycleManager = class {
   get failedPlugins() {
     return [...this._failed];
   }
+  get registry() {
+    return this.pluginRegistry;
+  }
   constructor(opts) {
     this.serviceRegistry = opts?.serviceRegistry ?? new ServiceRegistry();
     this.middlewareChain = opts?.middlewareChain ?? new MiddlewareChain();
@@ -2821,6 +3103,8 @@ var LifecycleManager = class {
     try {
       sorted = resolveLoadOrder(allForResolution);
     } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.log?.error(`Plugin dependency resolution failed: ${error.message}`);
       for (const p of plugins) {
         this._failed.add(p.name);
       }
@@ -2859,7 +3143,11 @@ var LifecycleManager = class {
             settings: this.settingsManager.createAPI(plugin.name),
             log: pluginLog
           };
-          const newSettings = await plugin.migrate(migrateCtx, oldSettings, registryEntry.version);
+          const newSettings = await withTimeout(
+            plugin.migrate(migrateCtx, oldSettings, registryEntry.version),
+            SETUP_TIMEOUT_MS,
+            `${plugin.name}.migrate()`
+          );
           if (newSettings && typeof newSettings === "object") {
             await migrateCtx.settings.setAll(newSettings);
           }
@@ -2872,11 +3160,23 @@ var LifecycleManager = class {
       let pluginConfig;
       if (this.settingsManager) {
         pluginConfig = await this.settingsManager.loadSettings(plugin.name);
+        const settingsPath = this.settingsManager.getSettingsPath(plugin.name);
+        this.getPluginLogger(plugin.name).debug(`Settings loaded from ${settingsPath}: ${Object.keys(pluginConfig).length} keys`);
         if (Object.keys(pluginConfig).length === 0) {
           pluginConfig = resolvePluginConfig(plugin.name, this.config);
         }
       } else {
         pluginConfig = resolvePluginConfig(plugin.name, this.config);
+        this.getPluginLogger(plugin.name).debug("No settingsManager, using legacy config");
+      }
+      if (plugin.settingsSchema && this.settingsManager) {
+        const validation = this.settingsManager.validateSettings(plugin.name, pluginConfig, plugin.settingsSchema);
+        if (!validation.valid) {
+          this._failed.add(plugin.name);
+          this.getPluginLogger(plugin.name).error(`Settings validation failed: ${validation.errors?.join("; ")}`);
+          this.eventBus?.emit("plugin:failed", { name: plugin.name, error: `Settings validation failed: ${validation.errors?.join("; ")}` });
+          continue;
+        }
       }
       const ctx = createPluginContext({
         pluginName: plugin.name,
@@ -2964,20 +3264,25 @@ var OpenACPCore = class {
   sessionFactory;
   lifecycleManager;
   // --- Lazy getters: resolve from ServiceRegistry (populated by plugins during boot) ---
+  getService(name) {
+    const svc = this.lifecycleManager.serviceRegistry.get(name);
+    if (!svc) throw new Error(`Service '${name}' not registered \u2014 is the ${name} plugin loaded?`);
+    return svc;
+  }
   get securityGuard() {
-    return this.lifecycleManager.serviceRegistry.get("security");
+    return this.getService("security");
   }
   get notificationManager() {
-    return this.lifecycleManager.serviceRegistry.get("notifications");
+    return this.getService("notifications");
   }
   get fileService() {
-    return this.lifecycleManager.serviceRegistry.get("file-service");
+    return this.getService("file-service");
   }
   get speechService() {
-    return this.lifecycleManager.serviceRegistry.get("speech");
+    return this.getService("speech");
   }
   get contextManager() {
-    return this.lifecycleManager.serviceRegistry.get("context");
+    return this.getService("context");
   }
   constructor(configManager) {
     this.configManager = configManager;
@@ -2985,7 +3290,7 @@ var OpenACPCore = class {
     this.agentCatalog = new AgentCatalog();
     this.agentCatalog.load();
     this.agentManager = new AgentManager(this.agentCatalog);
-    const storePath = path4.join(os.homedir(), ".openacp", "sessions.json");
+    const storePath = path5.join(os.homedir(), ".openacp", "sessions.json");
     this.sessionStore = new JsonFileSessionStore(
       storePath,
       config.sessionStore.ttlDays
@@ -3008,7 +3313,7 @@ var OpenACPCore = class {
       sessions: this.sessionManager,
       config: this.configManager,
       core: this,
-      storagePath: path4.join(os.homedir(), ".openacp", "plugins", "data"),
+      storagePath: path5.join(os.homedir(), ".openacp", "plugins", "data"),
       log: createChildLogger({ module: "plugin" })
     });
     this.sessionFactory.middlewareChain = this.lifecycleManager.middlewareChain;
@@ -3017,7 +3322,7 @@ var OpenACPCore = class {
       "config:changed",
       async ({ path: configPath, value }) => {
         if (configPath === "logging.level" && typeof value === "string") {
-          const { setLogLevel } = await import("./log-LZ7FTRKG.js");
+          const { setLogLevel } = await import("./log-YZ243M5G.js");
           setLogLevel(value);
           log6.info({ level: value }, "Log level changed at runtime");
         }
@@ -3041,7 +3346,7 @@ var OpenACPCore = class {
   }
   set tunnelService(service) {
     this._tunnelService = service;
-    this.messageTransformer = new MessageTransformer(service);
+    this.messageTransformer.tunnelService = service;
   }
   registerAdapter(name, adapter) {
     this.adapters.set(name, adapter);
@@ -3056,14 +3361,17 @@ var OpenACPCore = class {
   }
   async stop() {
     try {
-      await this.notificationManager.notifyAll({
-        sessionId: "system",
-        type: "error",
-        summary: "OpenACP is shutting down"
-      });
+      const nm = this.lifecycleManager.serviceRegistry.get("notifications");
+      if (nm) {
+        await nm.notifyAll({
+          sessionId: "system",
+          type: "error",
+          summary: "OpenACP is shutting down"
+        });
+      }
     } catch {
     }
-    await this.sessionManager.destroyAll();
+    await this.sessionManager.shutdownAll();
     for (const adapter of this.adapters.values()) {
       await adapter.stop();
     }
@@ -3071,30 +3379,30 @@ var OpenACPCore = class {
   // --- 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 (!session) return { ok: false, error: "Session not found (must be in memory)" };
+    if (session.status !== "active" && session.status !== "cancelled" && session.status !== "error") {
+      return { ok: false, error: `Cannot archive session in '${session.status}' state` };
+    }
+    const adapter = this.adapters.get(session.channelId);
     if (!adapter) return { ok: false, error: "Adapter not found for session" };
+    if (!adapter.archiveSessionTopic) return { ok: false, error: "Adapter does not support topic archiving" };
     try {
-      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;
+      const newThreadId = await adapter.archiveSessionTopic(session.id);
+      session.threadId = newThreadId;
+      try {
+        const platform = {};
+        if (session.channelId === "telegram") {
+          platform.topicId = Number(newThreadId);
+        } else {
+          platform.threadId = newThreadId;
         }
+        await this.sessionManager.patchRecord(sessionId, { platform });
+      } catch (patchErr) {
+        log6.warn({ err: patchErr, sessionId }, "Failed to update session record after archive \u2014 session will work but may not survive restart");
       }
-      await this.sessionManager.removeRecord(sessionId);
-      return { ok: true };
+      return { ok: true, newThreadId };
     } catch (err) {
-      if (session) session.archiving = false;
+      session.archiving = false;
       return { ok: false, error: err.message };
     }
   }
@@ -3153,6 +3461,9 @@ var OpenACPCore = class {
   // --- Unified Session Creation Pipeline ---
   async createSession(params) {
     const session = await this.sessionFactory.create(params);
+    if (params.threadId) {
+      session.threadId = params.threadId;
+    }
     const adapter = this.adapters.get(params.channelId);
     if (params.createThread && adapter) {
       const threadId = await adapter.createSessionThread(
@@ -3391,7 +3702,7 @@ var OpenACPCore = class {
       );
       return null;
     }
-    if (record.status === "error") {
+    if (record.status === "error" || record.status === "cancelled") {
       log6.debug(
         {
           threadId: message.threadId,
@@ -3418,9 +3729,9 @@ var OpenACPCore = class {
           workingDirectory: record.workingDir,
           resumeAgentSessionId: record.agentSessionId,
           existingSessionId: record.sessionId,
-          initialName: record.name
+          initialName: record.name,
+          threadId: message.threadId
         });
-        session.threadId = message.threadId;
         session.activate();
         session.dangerousMode = record.dangerousMode ?? false;
         log6.info(
@@ -3468,7 +3779,7 @@ var CommandRegistry = class _CommandRegistry {
   commands = /* @__PURE__ */ new Map();
   /** Adapter-specific overrides: `channelId:commandName` → RegisteredCommand */
   overrides = /* @__PURE__ */ new Map();
-  static ADAPTER_SCOPES = /* @__PURE__ */ new Set(["telegram", "discord", "slack"]);
+  static ADAPTER_SCOPES = /* @__PURE__ */ new Set(["telegram", "discord"]);
   /**
    * Register a command definition.
    * @param def - Command definition
@@ -3503,22 +3814,18 @@ var CommandRegistry = class _CommandRegistry {
   get(name) {
     return this.commands.get(name);
   }
-  /** Remove a command by short name. Also removes its qualified name entry. */
+  /** Remove a command by name (short or qualified). Also removes its qualified name entry. */
   unregister(name) {
     const cmd = this.commands.get(name);
-    if (cmd) {
-      this.commands.delete(name);
-      if (cmd.scope) {
-        this.commands.delete(`${cmd.scope}:${name}`);
-      }
-    }
-    if (!cmd) {
-      this.commands.delete(name);
+    if (!cmd) return;
+    this.commands.delete(name);
+    if (cmd.scope) {
+      this.commands.delete(`${cmd.scope}:${cmd.name}`);
+      this.commands.delete(cmd.name);
     }
   }
   /** Remove all commands registered by a given plugin. */
   unregisterByPlugin(pluginName) {
-    const scope = _CommandRegistry.extractScope(pluginName);
     const toDelete = [];
     for (const [key, cmd] of this.commands) {
       if (cmd.pluginName === pluginName) {
@@ -3607,4 +3914,4 @@ export {
   OpenACPCore,
   CommandRegistry
 };
-//# sourceMappingURL=chunk-XIBG7LSL.js.map
+//# sourceMappingURL=chunk-7RKPIM3E.js.map