@ganglion/xacpx 0.19.2 → 0.19.3

package/dist/adapters/hermes-acp-shim.js

@@ -0,0 +1,180 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __promiseAll = (args) => Promise.all(args);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/adapters/hermes-shim.ts
+import { fileURLToPath } from "node:url";
+function isDefaultHermesCommand(command) {
+  return command.trim().replaceAll(/\s+/g, " ") === DEFAULT_HERMES_COMMAND;
+}
+function isHermesShimCommand(command) {
+  return command.includes("/hermes-acp-shim.") || command.includes("\\hermes-acp-shim.");
+}
+function resolveHermesAcpShimEntry(moduleUrl = import.meta.url) {
+  if (moduleUrl.endsWith(".ts")) {
+    return fileURLToPath(new URL("./hermes-acp-shim.ts", moduleUrl));
+  }
+  const idx = moduleUrl.lastIndexOf(DIST_MARKER);
+  if (idx !== -1) {
+    return fileURLToPath(new URL(`${moduleUrl.slice(0, idx + DIST_MARKER.length)}adapters/hermes-acp-shim.js`));
+  }
+  return fileURLToPath(new URL("./hermes-acp-shim.js", moduleUrl));
+}
+function quoteAgentCommandToken(token) {
+  return `"${token.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function hermesAcpShimCommand(execPath = process.execPath, shimEntry = resolveHermesAcpShimEntry()) {
+  return [
+    quoteAgentCommandToken(execPath),
+    quoteAgentCommandToken(shimEntry),
+    "hermes",
+    "acp"
+  ].join(" ");
+}
+function stripResumeCapability(line) {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!message || typeof message !== "object")
+    return null;
+  const result = message.result;
+  if (!result || typeof result !== "object")
+    return null;
+  const capabilities = result.agentCapabilities;
+  if (!capabilities || typeof capabilities !== "object")
+    return null;
+  const sessionCapabilities = capabilities.sessionCapabilities;
+  if (!sessionCapabilities || typeof sessionCapabilities !== "object")
+    return null;
+  if (!Object.hasOwn(sessionCapabilities, "resume"))
+    return null;
+  delete sessionCapabilities.resume;
+  return JSON.stringify(message);
+}
+function isInitializeResponse(line) {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return false;
+  }
+  if (!message || typeof message !== "object")
+    return false;
+  const result = message.result;
+  if (!result || typeof result !== "object")
+    return false;
+  const capabilities = result.agentCapabilities;
+  return Boolean(capabilities) && typeof capabilities === "object";
+}
+var DEFAULT_HERMES_COMMAND = "hermes acp", DIST_MARKER = "/dist/";
+var init_hermes_shim = () => {};
+
+// src/adapters/hermes-acp-shim.ts
+init_hermes_shim();
+import { spawn } from "node:child_process";
+import { constants as osConstants } from "node:os";
+var argv = process.argv.slice(2);
+var command = argv.length > 0 ? argv : ["hermes", "acp"];
+var child = spawn(command[0], command.slice(1), {
+  stdio: ["pipe", "pipe", "inherit"],
+  shell: process.platform === "win32"
+});
+child.on("error", (error) => {
+  process.stderr.write(`[hermes-acp-shim] failed to spawn "${command.join(" ")}": ${error.message}
+`);
+  process.exit(1);
+});
+child.on("exit", (code, signal) => {
+  process.exitCode = signal ? 128 + (osConstants.signals[signal] ?? 0) : code ?? 0;
+});
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+  process.on(signal, () => {
+    child.kill(signal);
+  });
+}
+process.stdin.pipe(child.stdin);
+var patched = false;
+var pending = Buffer.alloc(0);
+var NEWLINE = 10;
+var interceptStdout = (chunk) => {
+  pending = pending.length > 0 ? Buffer.concat([pending, chunk]) : chunk;
+  let newlineIndex;
+  while (!patched && (newlineIndex = pending.indexOf(NEWLINE)) !== -1) {
+    const line = pending.subarray(0, newlineIndex + 1);
+    pending = pending.subarray(newlineIndex + 1);
+    const text = line.toString("utf8");
+    const replaced = stripResumeCapability(text);
+    if (replaced !== null) {
+      patched = true;
+      process.stdout.write(`${replaced}
+`);
+    } else {
+      process.stdout.write(line);
+      if (isInitializeResponse(text))
+        patched = true;
+    }
+  }
+  if (patched) {
+    if (pending.length > 0) {
+      process.stdout.write(pending);
+      pending = Buffer.alloc(0);
+    }
+    child.stdout.off("data", interceptStdout);
+    child.stdout.pipe(process.stdout, { end: false });
+  }
+};
+child.stdout.on("data", interceptStdout);
+child.stdout.on("end", () => {
+  if (pending.length > 0) {
+    process.stdout.write(pending);
+    pending = Buffer.alloc(0);
+  }
+});

package/dist/adapters/hermes-shim.d.ts

@@ -0,0 +1,37 @@
+/** The command the 0.19.2 template baked into configs; treated as "no explicit
+ * command" so those configs migrate onto the shim without hand-editing. */
+export declare function isDefaultHermesCommand(command: string): boolean;
+/** A recorded shim command is derived, machine-specific state — the current
+ * install's shim (whose dist path may differ after an upgrade) must replace it.
+ * The leading separator keeps user wrappers like `my-hermes-acp-shim.sh` custom. */
+export declare function isHermesShimCommand(command: string): boolean;
+/**
+ * Path to the shim entry script. Unbundled dev runs (module URL still ends in .ts)
+ * resolve the sibling .ts source, which the dev runtime (bun) executes directly —
+ * checked FIRST so a checkout path that happens to contain `/dist/` cannot
+ * misresolve. Bundled builds (cli.js AND bridge/bridge-main.js both sit under
+ * dist/) anchor on the last `/dist/` segment.
+ */
+export declare function resolveHermesAcpShimEntry(moduleUrl?: string): string;
+/** Quote one token for acpx's `--agent` parser (double quotes; `\` and `"` escaped —
+ * its splitCommandLine treats backslash as an escape inside double quotes). */
+export declare function quoteAgentCommandToken(token: string): string;
+/** Runtime-only agent command for the hermes driver: never persisted to config.
+ *
+ * Tradeoff: the string embeds `process.execPath` and this install's dist path,
+ * and acpx keys its backend session records by EXACT agentCommand equality — so a
+ * node upgrade (nvm paths embed the version) or an install relocation re-keys
+ * hermes session identity: acpx starts a fresh backend record and the old queue
+ * owner ages out via TTL. Accepted because the alternative (a stable bin shim)
+ * isn't worth the packaging surface for a workaround slated for removal. */
+export declare function hermesAcpShimCommand(execPath?: string, shimEntry?: string): string;
+/**
+ * If `line` is the initialize response advertising `sessionCapabilities.resume`,
+ * return the same frame re-serialized without it; otherwise null (caller forwards
+ * the original bytes untouched).
+ */
+export declare function stripResumeCapability(line: string): string | null;
+/** Is `line` an initialize response (the only frame carrying agentCapabilities)?
+ * Lets the shim latch to raw passthrough even when hermes stops advertising
+ * `resume` after the upstream fix, instead of parsing every line forever. */
+export declare function isInitializeResponse(line: string): boolean;

package/dist/cli.js

@@ -4868,6 +4868,76 @@ var init_local_agent_bin = __esm(() => {
   };
 });
 
+// src/adapters/hermes-shim.ts
+import { fileURLToPath } from "node:url";
+function isDefaultHermesCommand(command) {
+  return command.trim().replaceAll(/\s+/g, " ") === DEFAULT_HERMES_COMMAND;
+}
+function isHermesShimCommand(command) {
+  return command.includes("/hermes-acp-shim.") || command.includes("\\hermes-acp-shim.");
+}
+function resolveHermesAcpShimEntry(moduleUrl = import.meta.url) {
+  if (moduleUrl.endsWith(".ts")) {
+    return fileURLToPath(new URL("./hermes-acp-shim.ts", moduleUrl));
+  }
+  const idx = moduleUrl.lastIndexOf(DIST_MARKER);
+  if (idx !== -1) {
+    return fileURLToPath(new URL(`${moduleUrl.slice(0, idx + DIST_MARKER.length)}adapters/hermes-acp-shim.js`));
+  }
+  return fileURLToPath(new URL("./hermes-acp-shim.js", moduleUrl));
+}
+function quoteAgentCommandToken(token) {
+  return `"${token.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function hermesAcpShimCommand(execPath = process.execPath, shimEntry = resolveHermesAcpShimEntry()) {
+  return [
+    quoteAgentCommandToken(execPath),
+    quoteAgentCommandToken(shimEntry),
+    "hermes",
+    "acp"
+  ].join(" ");
+}
+function stripResumeCapability(line) {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!message || typeof message !== "object")
+    return null;
+  const result = message.result;
+  if (!result || typeof result !== "object")
+    return null;
+  const capabilities = result.agentCapabilities;
+  if (!capabilities || typeof capabilities !== "object")
+    return null;
+  const sessionCapabilities = capabilities.sessionCapabilities;
+  if (!sessionCapabilities || typeof sessionCapabilities !== "object")
+    return null;
+  if (!Object.hasOwn(sessionCapabilities, "resume"))
+    return null;
+  delete sessionCapabilities.resume;
+  return JSON.stringify(message);
+}
+function isInitializeResponse(line) {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return false;
+  }
+  if (!message || typeof message !== "object")
+    return false;
+  const result = message.result;
+  if (!result || typeof result !== "object")
+    return false;
+  const capabilities = result.agentCapabilities;
+  return Boolean(capabilities) && typeof capabilities === "object";
+}
+var DEFAULT_HERMES_COMMAND = "hermes acp", DIST_MARKER = "/dist/";
+var init_hermes_shim = () => {};
+
 // src/config/resolve-agent-command.ts
 function resolveAgentCommand(driver, command) {
   if (!command) {
@@ -4876,6 +4946,9 @@ function resolveAgentCommand(driver, command) {
   if (driver === "codex" && isLegacyCodexCommand(command)) {
     return;
   }
+  if (driver === "hermes" && isDefaultHermesCommand(command)) {
+    return;
+  }
   return command;
 }
 function resolveRuntimeAgentCommand(driver, command, preferLocal = true, adapterVersions, adapterRegistry) {
@@ -4886,6 +4959,8 @@ function resolveRuntimeAgentCommand(driver, command, preferLocal = true, adapter
   const managed = resolveManagedAdapterCommand(driver, adapterVersions, adapterRegistry);
   if (managed)
     return managed;
+  if (driver === "hermes")
+    return hermesAcpShimCommand();
   return preferLocal ? resolveLocalAgentCommand(driver) : undefined;
 }
 function resolveConfiguredAgentCommand(agent3, transport) {
@@ -4898,6 +4973,7 @@ function isLegacyCodexCommand(command) {
 var init_resolve_agent_command = __esm(() => {
   init_local_agent_bin();
   init_adapter_catalog();
+  init_hermes_shim();
 });
 
 // src/config/load-config.ts
@@ -5763,8 +5839,7 @@ var init_agent_templates = __esm(() => {
       driver: "grok-build"
     },
     hermes: {
-      driver: "hermes",
-      command: "hermes acp"
+      driver: "hermes"
     },
     iflow: {
       driver: "iflow"
@@ -12755,11 +12830,11 @@ var require_dist = __commonJS((exports, module) => {
 // src/version.ts
 import fs from "node:fs";
 import path2 from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 function readVersion(moduleUrl = import.meta.url) {
   let dir;
   try {
-    dir = path2.dirname(fileURLToPath(moduleUrl));
+    dir = path2.dirname(fileURLToPath2(moduleUrl));
   } catch {
     return "unknown";
   }
@@ -13832,10 +13907,10 @@ import { readFileSync as readFileSync3 } from "node:fs";
 import { copyFile, mkdir as mkdir4, readFile as readFile7, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname4, join as join8 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveCoreRoot() {
   try {
-    let dir = dirname4(fileURLToPath2(import.meta.url));
+    let dir = dirname4(fileURLToPath3(import.meta.url));
     for (let depth = 0;depth < 12; depth++) {
       try {
         const pkg = JSON.parse(readFileSync3(join8(dir, "package.json"), "utf-8"));
@@ -31351,7 +31426,8 @@ class SessionService {
     const effectiveReplyMode = channelId === "relay" ? "stream" : undefined;
     const currentAgentCommand = resolveConfiguredAgentCommand(agentConfig, this.config.transport);
     const configuredAgentCommand = resolveAgentCommand(agentConfig.driver, agentConfig.command);
-    const recordedAgentCommand = agentConfig.driver === "codex" && session3.transport_agent_command && isLegacyCodexCommand(session3.transport_agent_command) ? undefined : session3.transport_agent_command;
+    const recordedIsDerived = Boolean(session3.transport_agent_command) && (agentConfig.driver === "codex" && isLegacyCodexCommand(session3.transport_agent_command) || agentConfig.driver === "hermes" && (isDefaultHermesCommand(session3.transport_agent_command) || isHermesShimCommand(session3.transport_agent_command)));
+    const recordedAgentCommand = recordedIsDerived ? undefined : session3.transport_agent_command;
     return {
       alias: session3.alias,
       agent: session3.agent,
@@ -31519,6 +31595,7 @@ class SessionService {
 var init_session_service = __esm(() => {
   init_resolve_agent_command();
   init_adapter_catalog();
+  init_hermes_shim();
   init_i18n();
   init_channel_scope();
 });
@@ -32232,7 +32309,7 @@ var init_command_timeouts = __esm(() => {
 
 // src/transport/acpx-bridge/acpx-bridge-client.ts
 import { spawn as spawn10 } from "node:child_process";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { createInterface } from "node:readline";
 function bridgeRequestTimeoutMs(method, sessionInitTimeoutMs = DEFAULT_SESSION_INIT_TIMEOUT_MS) {
   switch (method) {
@@ -32440,7 +32517,7 @@ function buildBridgeSpawnSpec(options) {
   };
 }
 async function spawnAcpxBridgeClient(options = {}) {
-  const bridgeEntryPath = options.bridgeEntryPath ?? fileURLToPath4(new URL("../../bridge/bridge-main.ts", import.meta.url));
+  const bridgeEntryPath = options.bridgeEntryPath ?? fileURLToPath5(new URL("../../bridge/bridge-main.ts", import.meta.url));
   const spawnSpec = buildBridgeSpawnSpec({
     execPath: process.execPath,
     bridgeEntryPath
@@ -37193,7 +37270,7 @@ function buildControlMetadata(senderId, isOwner) {
     ...isOwner === undefined ? {} : { isOwner }
   };
 }
-var CANCEL_DRAIN_TIMEOUT_MS = 5000, QUEUE_PREVIEW_MAX = 120, TURN_IDLE_TIMEOUT_REASON;
+var CANCEL_DRAIN_TIMEOUT_MS = 5000, QUEUE_PREVIEW_MAX = 120, QUEUE_MAX_DEPTH = 20, TURN_IDLE_TIMEOUT_REASON;
 var init_turn_support = __esm(() => {
   TURN_IDLE_TIMEOUT_REASON = Symbol("turn-idle-timeout");
 });
@@ -37392,14 +37469,17 @@ class TurnQueue {
   deps;
   setTimer;
   clearTimer;
+  cancelDrainTimeoutMs;
   constructor(deps) {
     this.deps = deps;
     this.setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
     this.clearTimer = deps.clearTimer ?? ((id) => clearTimeout(id));
+    this.cancelDrainTimeoutMs = deps.cancelDrainTimeoutMs ?? CANCEL_DRAIN_TIMEOUT_MS;
   }
   inFlight = new Map;
   queues = new Map;
   draining = new Set;
+  removing = new Set;
   queueLength(chatKey, sessionAlias) {
     return this.queues.get(turnKey(chatKey, sessionAlias))?.length ?? 0;
   }
@@ -37420,9 +37500,13 @@ class TurnQueue {
     const key = turnKey(params.chatKey, params.sessionAlias);
     if (!params.drained) {
       const existing = this.inFlight.get(key);
-      const busy = this.draining.has(key) || existing !== undefined && !existing.controller.signal.aborted;
+      const busy = this.removing.has(key) || this.draining.has(key) || existing !== undefined && !existing.controller.signal.aborted;
       if (busy) {
         if (params.queueable) {
+          const q = this.queues.get(key) ?? [];
+          if (q.length >= QUEUE_MAX_DEPTH) {
+            return { ok: false, errorMessage: "queue-full" };
+          }
           const id = randomUUID3();
           const item = {
             id,
@@ -37433,7 +37517,6 @@ class TurnQueue {
             ...params.accountId !== undefined ? { accountId: params.accountId } : {},
             ...params.media !== undefined ? { media: params.media } : {}
           };
-          const q = this.queues.get(key) ?? [];
           q.push(item);
           this.queues.set(key, q);
           this.emitQueueUpdated(params.chatKey, params.sessionAlias);
@@ -37554,6 +37637,28 @@ class TurnQueue {
     entry.controller.abort();
     return true;
   }
+  async clearSession(chatKey, sessionAlias) {
+    const key = turnKey(chatKey, sessionAlias);
+    if (this.queues.delete(key)) {
+      this.emitQueueUpdated(chatKey, sessionAlias);
+    }
+    const entry = this.inFlight.get(key);
+    if (entry) {
+      entry.controller.abort();
+      await raceWithTimeout(entry.settled, this.cancelDrainTimeoutMs);
+      if (this.queues.delete(key)) {
+        this.emitQueueUpdated(chatKey, sessionAlias);
+      }
+    }
+    const cleared = !this.inFlight.has(key) && !this.draining.has(key);
+    if (cleared) {
+      this.removing.add(key);
+    }
+    return { cleared };
+  }
+  finishClear(chatKey, sessionAlias) {
+    this.removing.delete(turnKey(chatKey, sessionAlias));
+  }
   cancelQueuedItem(chatKey, sessionAlias, itemId) {
     const key = turnKey(chatKey, sessionAlias);
     const q = this.queues.get(key);
@@ -37595,6 +37700,7 @@ class ControlService {
       runTurn: (req, signal, onActivity) => this.runner.run(req, signal, onActivity),
       ...this.deps.turnIdleTimeoutMs ? { turnIdleTimeoutMs: this.deps.turnIdleTimeoutMs } : {},
       ...this.deps.onTurnIdleTimeout ? { onIdleTimeout: this.deps.onTurnIdleTimeout } : {},
+      ...this.deps.cancelDrainTimeoutMs !== undefined ? { cancelDrainTimeoutMs: this.deps.cancelDrainTimeoutMs } : {},
       emitQueueUpdated: (chatKey, sessionAlias, items) => this.deps.events.emit({ type: "queue-updated", chatKey, sessionAlias, items }),
       detectSessionsChanged: async (detection) => {
         try {
@@ -37912,19 +38018,35 @@ class ControlService {
   }
   async removeSession(chatKey, alias) {
     const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
-    const result = await this.deps.removeSessionWithTransport(internalAlias);
-    this.deps.events.emit({ type: "sessions-changed" });
-    return result;
+    const { cleared } = await this.turnQueue.clearSession(chatKey, alias);
+    if (!cleared) {
+      throw new Error(`session "${alias}" is still finishing a stopped turn; retry in a moment`);
+    }
+    try {
+      const result = await this.deps.removeSessionWithTransport(internalAlias);
+      this.deps.events.emit({ type: "sessions-changed" });
+      return result;
+    } finally {
+      this.turnQueue.finishClear(chatKey, alias);
+    }
   }
   async archiveSession(chatKey, alias) {
     const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
-    await this.deps.archiveSessionWithTransport(internalAlias);
-    const session3 = await this.deps.sessions.getSession(internalAlias).catch(() => {
-      return;
-    });
-    if (session3)
-      this.deps.sessionWarmth?.markCold(session3);
-    this.deps.events.emit({ type: "sessions-changed" });
+    const { cleared } = await this.turnQueue.clearSession(chatKey, alias);
+    if (!cleared) {
+      throw new Error(`session "${alias}" is still finishing a stopped turn; retry in a moment`);
+    }
+    try {
+      await this.deps.archiveSessionWithTransport(internalAlias);
+      const session3 = await this.deps.sessions.getSession(internalAlias).catch(() => {
+        return;
+      });
+      if (session3)
+        this.deps.sessionWarmth?.markCold(session3);
+      this.deps.events.emit({ type: "sessions-changed" });
+    } finally {
+      this.turnQueue.finishClear(chatKey, alias);
+    }
   }
   async unarchiveSession(chatKey, alias) {
     const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
@@ -38555,7 +38677,7 @@ __export(exports_main, {
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { homedir as homedir17 } from "node:os";
 import { dirname as dirname16, join as join26 } from "node:path";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
 function startProgressHeartbeat(orchestration3, config4, logger, channel) {
   const thresholdSeconds = config4.orchestration.progressHeartbeatSeconds;
   if (thresholdSeconds <= 0) {
@@ -39311,9 +39433,9 @@ function resolveRuntimePaths() {
 }
 function resolveBridgeEntryPath() {
   if (import.meta.url.includes("/dist/")) {
-    return fileURLToPath5(new URL("./bridge/bridge-main.js", import.meta.url));
+    return fileURLToPath6(new URL("./bridge/bridge-main.js", import.meta.url));
   }
-  return fileURLToPath5(new URL("./bridge/bridge-main.ts", import.meta.url));
+  return fileURLToPath6(new URL("./bridge/bridge-main.ts", import.meta.url));
 }
 function resolveAppLogPath(configPath) {
   const rootDir = dirname16(configPath);
@@ -39568,7 +39690,7 @@ var init_config_check = __esm(async () => {
 
 // src/doctor/checks/daemon-check.ts
 import { readdir as readdir7, readFile as readFile17, rm as rm12 } from "node:fs/promises";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 import { homedir as homedir18 } from "node:os";
 import { join as join27 } from "node:path";
 async function checkDaemon(options = {}) {
@@ -39724,7 +39846,7 @@ async function defaultRemoveConsumerLock(path16) {
   await rm12(path16, { force: true });
 }
 function resolveCliEntryPath() {
-  return process.argv[1] ?? fileURLToPath6(import.meta.url);
+  return process.argv[1] ?? fileURLToPath7(import.meta.url);
 }
 function formatError5(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
@@ -41080,7 +41202,7 @@ init_core_home();
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { homedir as homedir23 } from "node:os";
 import { dirname as dirname18, join as join30, sep as sep3 } from "node:path";
-import { fileURLToPath as fileURLToPath7 } from "node:url";
+import { fileURLToPath as fileURLToPath8 } from "node:url";
 
 // src/runtime/migrate-core-home.ts
 init_core_home();
@@ -55122,7 +55244,7 @@ init_plugin_home();
 import { spawn as spawn4 } from "node:child_process";
 import { readFile as readFile9 } from "node:fs/promises";
 import { dirname as dirname8, join as join13 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/plugins/package-manager.ts
 init_plugin_home();
@@ -55467,7 +55589,7 @@ async function runInherit(command, args) {
 }
 async function readPackageName() {
   try {
-    const here = dirname8(fileURLToPath3(import.meta.url));
+    const here = dirname8(fileURLToPath4(import.meta.url));
     for (const candidate of [join13(here, "..", "package.json"), join13(here, "..", "..", "package.json")]) {
       try {
         const parsed = JSON.parse(await readFile9(candidate, "utf8"));
@@ -58126,7 +58248,7 @@ function resolveCliEntryPath2() {
   if (process.argv[1]) {
     return process.argv[1];
   }
-  return fileURLToPath7(import.meta.url);
+  return fileURLToPath8(import.meta.url);
 }
 function parseDoctorArgs(args) {
   const options = {};

package/dist/control/control-service.d.ts

@@ -100,6 +100,7 @@ export interface ControlServiceDeps {
     gitWorktreesRoot?: string;
     turnIdleTimeoutMs?: () => number;
     onTurnIdleTimeout?: (detail: TurnIdleTimeoutDetail) => void;
+    cancelDrainTimeoutMs?: number;
 }
 export interface ControlPromptInput {
     chatKey: string;

package/dist/control/turn-queue.d.ts

@@ -14,6 +14,7 @@ export interface TurnQueueDeps {
     onIdleTimeout?: (detail: TurnIdleTimeoutDetail) => void;
     setTimer?: (fn: () => void, ms: number) => unknown;
     clearTimer?: (id: unknown) => void;
+    cancelDrainTimeoutMs?: number;
 }
 export interface SubmitParams {
     chatKey: string;
@@ -37,16 +38,41 @@ export declare class TurnQueue {
     private readonly deps;
     private readonly setTimer;
     private readonly clearTimer;
+    private readonly cancelDrainTimeoutMs;
     constructor(deps: TurnQueueDeps);
     private readonly inFlight;
     private readonly queues;
     private readonly draining;
+    private readonly removing;
     queueLength(chatKey: string, sessionAlias: string): number;
     isBusy(chatKey: string, sessionAlias: string): boolean;
     private emitQueueUpdated;
     submit(params: SubmitParams): Promise<SubmitResult>;
     private advanceQueue;
     cancelTurn(chatKey: string, sessionAlias: string): boolean;
+    /** Tear down all turn state for a session that is being removed or archived: drop every
+     *  queued prompt, abort a running turn, and wait (bounded) for it to unwind. The queue is
+     *  cleared BEFORE the abort so the aborting turn's finally sees it empty and releases the
+     *  slot instead of draining a head onto the dead session. Returns `cleared: false` when the
+     *  session still holds turn state after the bounded wait (a wedged turn that outlived the
+     *  timeout, or a fresh prompt that slipped in during the unwind) — the caller MUST NOT
+     *  proceed with removal/archive then, or the surviving turn's events would write history
+     *  rows for a session that no longer exists.
+     *
+     *  NOT side-effect-free even when it returns `cleared: false`: it has already aborted the
+     *  in-flight turn and dropped every queued prompt (emitting `queue-updated([])`). The caller
+     *  should surface a retry, not present the failure as a no-op.
+     *
+     *  On `cleared: true` it arms a teardown guard (the busy gate now rejects new turns for this
+     *  session) so a scheduled turn cannot cold-start during the caller's transport teardown. The
+     *  caller MUST call `finishClear` once teardown settles (success or failure) to release it. */
+    clearSession(chatKey: string, sessionAlias: string): Promise<{
+        cleared: boolean;
+    }>;
+    /** Release the teardown guard armed by a successful `clearSession`. MUST be called by the
+     *  caller once transport removal/archive settles (in a finally), whether it succeeded or
+     *  threw — otherwise the session key stays wedged as busy forever. */
+    finishClear(chatKey: string, sessionAlias: string): void;
     /** Remove a pending queued prompt (by id) before it drains. No-ops (returns
      *  `{ cancelled: false }`) when the queue or the id is absent/already drained — e.g. a race
      *  where the item drained into a running turn just before the cancel arrived. Does NOT touch

package/dist/control/turn-support.d.ts

@@ -13,6 +13,7 @@ export interface QueuedPrompt {
 }
 export declare const CANCEL_DRAIN_TIMEOUT_MS = 5000;
 export declare const QUEUE_PREVIEW_MAX = 120;
+export declare const QUEUE_MAX_DEPTH = 20;
 export declare function raceWithTimeout(promise: Promise<void>, ms: number): Promise<void>;
 export declare const TURN_IDLE_TIMEOUT_REASON: unique symbol;
 /** Detail handed to the idle-timeout observability hook when the inactivity watchdog reclaims a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganglion/xacpx",
-  "version": "0.19.2",
+  "version": "0.19.3",
   "description": "随时随地通过聊天频道（微信 / 飞书 / 元宝等）远程控制 `acpx` 上的 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",
@@ -42,7 +42,7 @@
     "clean:dist": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
     "clean:channel-yuanbao": "node -e \"require('node:fs').rmSync('packages/channel-yuanbao/dist',{recursive:true,force:true})\"",
     "clean:channel-feishu": "node -e \"require('node:fs').rmSync('packages/channel-feishu/dist',{recursive:true,force:true})\"",
-    "build": "bun run clean:dist && bun build ./src/cli.ts ./src/bridge/bridge-main.ts ./src/plugin-api.ts --outdir ./dist --target node --external node-pty && bun run build:plugin-api",
+    "build": "bun run clean:dist && bun build ./src/cli.ts ./src/bridge/bridge-main.ts ./src/adapters/hermes-acp-shim.ts ./src/plugin-api.ts --outdir ./dist --target node --external node-pty && bun run build:plugin-api",
     "build:plugin-api": "tsc -p tsconfig.plugin-api.json",
     "build:channel-yuanbao": "bun run build:plugin-api && bun run clean:channel-yuanbao && bun build ./packages/channel-yuanbao/src/index.ts --outdir ./packages/channel-yuanbao/dist --target node --external xacpx && tsc -p packages/channel-yuanbao/tsconfig.json",
     "build:channel-feishu": "bun run build:plugin-api && bun run clean:channel-feishu && bun build ./packages/channel-feishu/src/index.ts --outdir ./packages/channel-feishu/dist --target node --external xacpx && tsc -p packages/channel-feishu/tsconfig.json",