@openacp/cli 2026.327.5 → 2026.328.2

package/dist/{chunk-XIBG7LSL.js → chunk-6VR4GWOO.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();
     }
   });
 }
@@ -349,6 +360,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
   stderrCapture;
   terminalManager = new TerminalManager();
   static mcpManager = new McpManager();
+  _destroying = false;
   sessionId;
   agentName;
   promptCapabilities;
@@ -442,15 +454,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}`
         });
       }
@@ -810,11 +824,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 +947,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 +959,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) {
@@ -982,7 +1014,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 +1129,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 +1171,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);
@@ -1220,20 +1256,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 +1379,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 +1473,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 +1509,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()) {
@@ -1496,13 +1566,21 @@ var SessionBridge = class {
   namedHandler;
   /** Send message to adapter, optionally running through message:outgoing middleware */
   async sendMessage(sessionId, message) {
-    const mw = this.deps.middlewareChain;
-    if (mw) {
-      const result = await mw.execute("message:outgoing", { sessionId, message }, async (m) => m);
-      if (!result) return;
-      this.adapter.sendMessage(sessionId, result.message);
-    } else {
-      this.adapter.sendMessage(sessionId, message);
+    try {
+      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).catch((err) => {
+          log2.error({ err, sessionId }, "Failed to send message to adapter");
+        });
+      } else {
+        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() {
@@ -1542,19 +1620,31 @@ var SessionBridge = class {
       if (mw) {
         mw.execute("agent:beforeEvent", { sessionId: this.session.id, event }, async (e) => e).then((result) => {
           if (!result) return;
-          const transformedEvent = result.event;
-          const outgoing = this.handleAgentEvent(transformedEvent);
-          mw.execute("agent:afterEvent", {
-            sessionId: this.session.id,
-            event: transformedEvent,
-            outgoingMessage: outgoing ?? { type: "text", text: "" }
-          }, async (e) => e).catch(() => {
-          });
+          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);
@@ -1678,6 +1768,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 +1873,7 @@ var SessionBridge = class {
         sessionId: this.session.id,
         status: to
       });
-      if (to === "finished" || to === "cancelled") {
+      if (to === "finished") {
         queueMicrotask(() => this.disconnect());
       }
     };
@@ -1947,7 +2040,7 @@ var MessageTransformer = class {
           metadata: {
             tokensUsed: event.tokensUsed,
             contextSize: event.contextSize,
-            cost: event.cost
+            cost: event.cost?.amount
           }
         };
       case "session_end":
@@ -2251,7 +2344,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 {
+        fs3.renameSync(this.filePath, `${this.filePath}.bak`);
+      } catch {
+      }
     }
   }
   cleanup() {
@@ -2392,6 +2489,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 +2499,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 +2529,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 +2551,8 @@ var MiddlewareChain = class {
           }
           this.errorTracker?.increment(entry.pluginName);
           return nextFn();
+        } finally {
+          clearTimeout(timeoutTimer);
         }
         if (handlerResult === null) {
           return null;
@@ -2528,6 +2629,7 @@ var PluginStorageImpl = class {
   constructor(baseDir) {
     this.dataDir = path3.join(baseDir, "data");
     this.kvPath = path3.join(baseDir, "kv.json");
+    fs4.mkdirSync(baseDir, { recursive: true });
   }
   readKv() {
     try {
@@ -2780,6 +2882,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 +2926,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 +2966,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 +2983,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 +3087,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;
@@ -3017,7 +3145,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");
         }
@@ -3056,14 +3184,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 +3202,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 +3284,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 +3525,7 @@ var OpenACPCore = class {
       );
       return null;
     }
-    if (record.status === "error") {
+    if (record.status === "error" || record.status === "cancelled") {
       log6.debug(
         {
           threadId: message.threadId,
@@ -3418,9 +3552,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 +3602,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 +3637,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 +3737,4 @@ export {
   OpenACPCore,
   CommandRegistry
 };
-//# sourceMappingURL=chunk-XIBG7LSL.js.map
+//# sourceMappingURL=chunk-6VR4GWOO.js.map