@fangyb/ahchat-bridge 0.1.0

package/dist/chunk-7SODRWIG.js

@@ -0,0 +1,4525 @@
+// src/config.ts
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+var DEFAULT_QUERY_CONFIG = {
+  maxActive: 50,
+  idleTimeoutMs: 6e4,
+  evictionIntervalMs: 3e4,
+  statusReportIntervalMs: 6e4
+};
+function readEnvString(name, fallback) {
+  const v = process.env[name];
+  return v && v.length > 0 ? v : fallback;
+}
+function readEnvInt(name, fallback) {
+  const v = process.env[name];
+  if (!v || v.length === 0) return fallback;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function generateStableBridgeId() {
+  const raw = `${os.hostname()}:${os.userInfo().username}`;
+  const hash = crypto.createHash("sha256").update(raw).digest("hex").slice(0, 12);
+  return `bridge_${hash}`;
+}
+function tryReadJsonConfig(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return {};
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function mergeQueryConfig(file) {
+  const q = file.queryConfig;
+  return {
+    maxActive: readEnvInt("AHCHAT_BRIDGE_MAX_ACTIVE", q?.maxActive ?? DEFAULT_QUERY_CONFIG.maxActive),
+    idleTimeoutMs: readEnvInt(
+      "AHCHAT_BRIDGE_IDLE_TIMEOUT_MS",
+      q?.idleTimeoutMs ?? DEFAULT_QUERY_CONFIG.idleTimeoutMs
+    ),
+    evictionIntervalMs: readEnvInt(
+      "AHCHAT_BRIDGE_EVICTION_INTERVAL_MS",
+      q?.evictionIntervalMs ?? DEFAULT_QUERY_CONFIG.evictionIntervalMs
+    ),
+    statusReportIntervalMs: readEnvInt(
+      "AHCHAT_BRIDGE_STATUS_REPORT_MS",
+      q?.statusReportIntervalMs ?? DEFAULT_QUERY_CONFIG.statusReportIntervalMs
+    )
+  };
+}
+function loadBridgeConfig() {
+  const dataDir = readEnvString(
+    "AHCHAT_DATA_DIR",
+    path.join(os.homedir(), ".ahchat")
+  );
+  const fileConfig = tryReadJsonConfig(path.join(dataDir, "bridge.json"));
+  return {
+    serverUrl: readEnvString(
+      "AHCHAT_BRIDGE_SERVER_URL",
+      fileConfig.serverUrl ?? "ws://localhost:3001/ws/bridge"
+    ),
+    bridgeId: readEnvString(
+      "AHCHAT_BRIDGE_ID",
+      fileConfig.bridgeId ?? generateStableBridgeId()
+    ),
+    logLevel: readEnvString(
+      "AHCHAT_LOG_LEVEL",
+      fileConfig.logLevel ?? "INFO"
+    ),
+    dataDir,
+    dbPath: readEnvString(
+      "AHCHAT_DB_PATH",
+      fileConfig.dbPath ?? path.join(dataDir, "data.db")
+    ),
+    serverApiUrl: readEnvString(
+      "AHCHAT_SERVER_API_URL",
+      fileConfig.serverApiUrl ?? "http://localhost:3001"
+    ),
+    queryConfig: mergeQueryConfig(fileConfig)
+  };
+}
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+// src/logger.ts
+import os3 from "os";
+import path3 from "path";
+
+// ../logger/src/types.ts
+var LOG_LEVEL_VALUE = {
+  TRACE: 0,
+  DEBUG: 1,
+  INFO: 2,
+  WARN: 3,
+  ERROR: 4,
+  FATAL: 5
+};
+
+// ../logger/src/logger.ts
+function serializeError(err) {
+  if (err instanceof Error) {
+    return { name: err.name, message: err.message, stack: err.stack };
+  }
+  if (typeof err === "object" && err !== null && "message" in err) {
+    const o = err;
+    return {
+      name: typeof o.name === "string" ? o.name : "Error",
+      message: String(o.message),
+      ...typeof o.stack === "string" ? { stack: o.stack } : {}
+    };
+  }
+  return { name: "Error", message: String(err) };
+}
+function stripReservedFields(data) {
+  if (!data) return void 0;
+  const rest = { ...data };
+  delete rest.traceId;
+  delete rest.error;
+  return Object.keys(rest).length > 0 ? rest : void 0;
+}
+var Logger = class {
+  config;
+  levelValue;
+  constructor(config) {
+    this.config = config;
+    this.levelValue = LOG_LEVEL_VALUE[config.level];
+  }
+  trace(msg, data) {
+    this.log("TRACE", msg, data);
+  }
+  debug(msg, data) {
+    this.log("DEBUG", msg, data);
+  }
+  info(msg, data) {
+    this.log("INFO", msg, data);
+  }
+  warn(msg, data) {
+    this.log("WARN", msg, data);
+  }
+  error(msg, data) {
+    this.log("ERROR", msg, data);
+  }
+  fatal(msg, data) {
+    this.log("FATAL", msg, data);
+  }
+  log(level, msg, data) {
+    if (LOG_LEVEL_VALUE[level] < this.levelValue) return;
+    const traceId = typeof data?.traceId === "string" ? data.traceId : void 0;
+    const hasError = data && "error" in data && data.error !== void 0;
+    const error = hasError ? serializeError(data.error) : void 0;
+    const rest = stripReservedFields(data);
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      source: this.config.source,
+      module: this.config.module,
+      msg,
+      ...traceId ? { traceId } : {},
+      ...error ? { error } : {},
+      ...rest ? { data: rest } : {}
+    };
+    for (const transport of this.config.transports) {
+      transport(entry);
+    }
+  }
+};
+
+// ../logger/src/formatters/json.ts
+var jsonFormatter = (entry) => JSON.stringify(entry);
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "process";
+import os2 from "os";
+import tty from "tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os2.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open2, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open2;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open2;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open: open2,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// ../logger/src/formatters/pretty.ts
+var LEVEL_COLOR = {
+  TRACE: source_default.gray,
+  DEBUG: source_default.cyan,
+  INFO: source_default.green,
+  WARN: source_default.yellow,
+  ERROR: source_default.red,
+  FATAL: source_default.bgRed.white
+};
+function formatLocalTs(iso) {
+  const d = new Date(iso);
+  const pad = (n, w = 2) => String(n).padStart(w, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
+}
+var prettyFormatter = (entry) => {
+  const ts = formatLocalTs(entry.ts);
+  const level = LEVEL_COLOR[entry.level](entry.level.padEnd(5));
+  const scope = source_default.gray(`[${entry.source}:${entry.module}]`);
+  const data = entry.data && Object.keys(entry.data).length > 0 ? ` ${source_default.gray(JSON.stringify(entry.data))}` : "";
+  const trace = entry.traceId ? source_default.gray(` traceId=${entry.traceId}`) : "";
+  const errPart = entry.error ? source_default.red(
+    ` ${entry.error.name}: ${entry.error.message}${entry.error.stack ? `
+${entry.error.stack}` : ""}`
+  ) : "";
+  return `${ts} ${level} ${scope} ${entry.msg}${data}${trace}${errPart}`;
+};
+
+// ../logger/src/transports/console.ts
+function consoleTransport(opts) {
+  const fmt = opts?.formatter ?? jsonFormatter;
+  return (entry) => {
+    const line = fmt(entry);
+    if (LOG_LEVEL_VALUE[entry.level] >= LOG_LEVEL_VALUE.ERROR) {
+      console.error(line);
+    } else {
+      console.log(line);
+    }
+  };
+}
+
+// ../logger/src/transports/file.ts
+import path2 from "path";
+
+// ../../node_modules/.pnpm/rotating-file-stream@3.2.9/node_modules/rotating-file-stream/dist/esm/index.js
+import { exec } from "child_process";
+import { createGzip } from "zlib";
+import { Writable } from "stream";
+import { access, constants, createReadStream, createWriteStream } from "fs";
+import { mkdir, open, readFile, rename, stat, unlink, writeFile } from "fs/promises";
+import { sep } from "path";
+import { TextDecoder } from "util";
+import { setTimeout as setTimeout2 } from "timers";
+async function exists(filename) {
+  return new Promise((resolve) => access(filename, constants.F_OK, (error) => resolve(!error)));
+}
+var RotatingFileStreamError = class extends Error {
+  code = "RFS-TOO-MANY";
+  constructor() {
+    super("Too many destination file attempts");
+  }
+};
+var RotatingFileStream = class extends Writable {
+  createGzip;
+  exec;
+  file;
+  filename;
+  finished;
+  fsCreateReadStream;
+  fsCreateWriteStream;
+  fsOpen;
+  fsReadFile;
+  fsStat;
+  fsUnlink;
+  generator;
+  initPromise;
+  last;
+  maxTimeout;
+  next;
+  options;
+  prev;
+  rotation;
+  size;
+  stdout;
+  timeout;
+  timeoutPromise;
+  constructor(generator, options) {
+    const { encoding, history, maxFiles, maxSize, path: path10 } = options;
+    super({ decodeStrings: true, defaultEncoding: encoding });
+    this.createGzip = createGzip;
+    this.exec = exec;
+    this.filename = path10 + generator(null);
+    this.fsCreateReadStream = createReadStream;
+    this.fsCreateWriteStream = createWriteStream;
+    this.fsOpen = open;
+    this.fsReadFile = readFile;
+    this.fsStat = stat;
+    this.fsUnlink = unlink;
+    this.generator = generator;
+    this.maxTimeout = 2147483640;
+    this.options = options;
+    this.stdout = process.stdout;
+    if (maxFiles || maxSize)
+      options.history = path10 + (history ? history : this.generator(null) + ".txt");
+    this.on("close", () => this.finished ? null : this.emit("finish"));
+    this.on("finish", () => this.finished = this.clear());
+    (async () => {
+      try {
+        this.initPromise = this.init();
+        await this.initPromise;
+        delete this.initPromise;
+      } catch (e) {
+      }
+    })();
+  }
+  _destroy(error, callback) {
+    this.refinal(error, callback);
+  }
+  _final(callback) {
+    this.refinal(void 0, callback);
+  }
+  _write(chunk, encoding, callback) {
+    this.rewrite([{ chunk, encoding }], 0, callback);
+  }
+  _writev(chunks, callback) {
+    this.rewrite(chunks, 0, callback);
+  }
+  async refinal(error, callback) {
+    try {
+      this.clear();
+      if (this.initPromise)
+        await this.initPromise;
+      if (this.timeoutPromise)
+        await this.timeoutPromise;
+      await this.reclose();
+    } catch (e) {
+      return callback(error || e);
+    }
+    callback(error);
+  }
+  async rewrite(chunks, index, callback) {
+    const { size, teeToStdout } = this.options;
+    try {
+      if (this.initPromise)
+        await this.initPromise;
+      for (let i = 0; i < chunks.length; ++i) {
+        const { chunk } = chunks[i];
+        this.size += chunk.length;
+        if (this.timeoutPromise)
+          await this.timeoutPromise;
+        await this.file.write(chunk);
+        if (teeToStdout && !this.stdout.destroyed)
+          this.stdout.write(chunk);
+        if (size && this.size >= size)
+          await this.rotate();
+      }
+    } catch (e) {
+      return callback(e);
+    }
+    callback();
+  }
+  async init() {
+    const { immutable, initialRotation, interval, size } = this.options;
+    if (immutable)
+      return new Promise((resolve, reject) => process.nextTick(() => this.immutate(true).then(resolve).catch(reject)));
+    let stats;
+    try {
+      stats = await stat(this.filename);
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+      return this.reopen(0);
+    }
+    if (!stats.isFile())
+      throw new Error(`Can't write on: ${this.filename} (it is not a file)`);
+    if (initialRotation) {
+      this.intervalBounds(this.now());
+      const prev = this.prev;
+      this.intervalBounds(new Date(stats.mtime.getTime()));
+      if (prev !== this.prev)
+        return this.rotate();
+    }
+    this.size = stats.size;
+    if (!size || stats.size < size)
+      return this.reopen(stats.size);
+    if (interval)
+      this.intervalBounds(this.now());
+    return this.rotate();
+  }
+  async makePath(name) {
+    return mkdir(name.split(sep).slice(0, -1).join(sep), { recursive: true });
+  }
+  async reopen(size) {
+    let file;
+    try {
+      file = await open(this.filename, "a", this.options.mode);
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+      await this.makePath(this.filename);
+      file = await open(this.filename, "a", this.options.mode);
+    }
+    this.file = file;
+    this.size = size;
+    this.interval();
+    this.emit("open", this.filename);
+  }
+  async reclose() {
+    const { file } = this;
+    if (!file)
+      return;
+    delete this.file;
+    return file.close();
+  }
+  now() {
+    return /* @__PURE__ */ new Date();
+  }
+  async rotate() {
+    const { immutable, rotate } = this.options;
+    this.size = 0;
+    this.rotation = this.now();
+    this.clear();
+    this.emit("rotation");
+    await this.reclose();
+    if (rotate)
+      return this.classical();
+    if (immutable)
+      return this.immutate(false);
+    return this.move();
+  }
+  async findName() {
+    const { interval, path: path10, intervalBoundary } = this.options;
+    for (let index = 1; index < 1e3; ++index) {
+      const filename = path10 + this.generator(interval && intervalBoundary ? new Date(this.prev) : this.rotation, index);
+      if (!await exists(filename))
+        return filename;
+    }
+    throw new RotatingFileStreamError();
+  }
+  async move() {
+    const { compress } = this.options;
+    const filename = await this.findName();
+    await this.touch(filename);
+    if (compress)
+      await this.compress(filename);
+    else
+      await rename(this.filename, filename);
+    return this.rotated(filename);
+  }
+  async touch(filename) {
+    let file;
+    try {
+      file = await this.fsOpen(filename, "a");
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+      await this.makePath(filename);
+      file = await open(filename, "a");
+    }
+    await file.close();
+    return this.unlink(filename);
+  }
+  async classical() {
+    const { compress, path: path10, rotate } = this.options;
+    let rotatedName = "";
+    for (let count = rotate; count > 0; --count) {
+      const currName = path10 + this.generator(count);
+      const prevName = count === 1 ? this.filename : path10 + this.generator(count - 1);
+      if (!await exists(prevName))
+        continue;
+      if (!rotatedName)
+        rotatedName = currName;
+      if (count === 1 && compress)
+        await this.compress(currName);
+      else {
+        try {
+          await rename(prevName, currName);
+        } catch (e) {
+          if (e.code !== "ENOENT")
+            throw e;
+          await this.makePath(currName);
+          await rename(prevName, currName);
+        }
+      }
+    }
+    return this.rotated(rotatedName);
+  }
+  clear() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    return true;
+  }
+  intervalBoundsBig(now) {
+    const year = this.options.intervalUTC ? now.getUTCFullYear() : now.getFullYear();
+    let month = this.options.intervalUTC ? now.getUTCMonth() : now.getMonth();
+    let day = this.options.intervalUTC ? now.getUTCDate() : now.getDate();
+    let hours = this.options.intervalUTC ? now.getUTCHours() : now.getHours();
+    const { num, unit } = this.options.interval;
+    if (unit === "M") {
+      day = 1;
+      hours = 0;
+    } else if (unit === "d")
+      hours = 0;
+    else
+      hours = parseInt(hours / num, 10) * num;
+    this.prev = new Date(year, month, day, hours, 0, 0, 0).getTime();
+    if (unit === "M")
+      month += num;
+    else if (unit === "d")
+      day += num;
+    else
+      hours += num;
+    this.next = new Date(year, month, day, hours, 0, 0, 0).getTime();
+  }
+  intervalBounds(now) {
+    const unit = this.options.interval.unit;
+    if (unit === "M" || unit === "d" || unit === "h")
+      this.intervalBoundsBig(now);
+    else {
+      let period = 1e3 * this.options.interval.num;
+      if (unit === "m")
+        period *= 60;
+      this.prev = parseInt(now.getTime() / period, 10) * period;
+      this.next = this.prev + period;
+    }
+    return new Date(this.prev);
+  }
+  interval() {
+    if (!this.options.interval)
+      return;
+    this.intervalBounds(this.now());
+    const set = async () => {
+      const time = this.next - this.now().getTime();
+      if (time <= 0) {
+        try {
+          this.timeoutPromise = this.rotate();
+          await this.timeoutPromise;
+          delete this.timeoutPromise;
+        } catch (e) {
+        }
+      } else {
+        this.timeout = setTimeout2(set, time > this.maxTimeout ? this.maxTimeout : time);
+        this.timeout.unref();
+      }
+    };
+    set();
+  }
+  async compress(filename) {
+    const { compress } = this.options;
+    if (typeof compress === "function") {
+      await new Promise((resolve, reject) => {
+        this.exec(compress(this.filename, filename), (error, stdout, stderr) => {
+          this.emit("external", stdout, stderr);
+          error ? reject(error) : resolve();
+        });
+      });
+    } else
+      await this.gzip(filename);
+    return this.unlink(this.filename);
+  }
+  async gzip(filename) {
+    const { mode } = this.options;
+    const options = mode ? { mode } : {};
+    const inp = this.fsCreateReadStream(this.filename, {});
+    const out = this.fsCreateWriteStream(filename, options);
+    const zip = this.createGzip();
+    await new Promise((resolve, reject) => {
+      inp.once("error", reject);
+      out.once("error", reject);
+      zip.once("error", reject);
+      out.once("finish", resolve);
+      inp.pipe(zip).pipe(out);
+    });
+    await Promise.all([
+      new Promise((resolve) => zip.close(resolve)),
+      new Promise((resolve) => out.close((err) => {
+        if (err)
+          this.emit("warning", err);
+        resolve();
+      }))
+    ]);
+  }
+  async rotated(filename) {
+    const { maxFiles, maxSize } = this.options;
+    if (maxFiles || maxSize)
+      await this.history(filename);
+    this.emit("rotated", filename);
+    return this.reopen(0);
+  }
+  async history(filename) {
+    const { history, maxFiles, maxSize } = this.options;
+    const res = [];
+    let files = [filename];
+    try {
+      const content = await this.fsReadFile(history, "utf8");
+      files = [...content.toString().split("\n"), filename];
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+    }
+    for (const file of files) {
+      if (file) {
+        try {
+          const stats = await this.fsStat(file);
+          if (stats.isFile()) {
+            res.push({
+              name: file,
+              size: stats.size,
+              time: stats.mtime.getTime()
+            });
+          } else
+            this.emit("warning", new Error(`File '${file}' contained in history is not a regular file`));
+        } catch (e) {
+          if (e.code !== "ENOENT")
+            throw e;
+        }
+      }
+    }
+    res.sort((a, b) => a.time - b.time);
+    if (maxFiles) {
+      while (res.length > maxFiles) {
+        const file = res.shift();
+        await this.unlink(file.name);
+        this.emit("removed", file.name, true);
+      }
+    }
+    if (maxSize) {
+      while (res.reduce((size, file) => size + file.size, 0) > maxSize) {
+        const file = res.shift();
+        await this.unlink(file.name);
+        this.emit("removed", file.name, false);
+      }
+    }
+    await writeFile(history, res.map((e) => e.name).join("\n") + "\n", "utf-8");
+    this.emit("history");
+  }
+  async immutate(first) {
+    const { size } = this.options;
+    const now = this.now();
+    for (let index = 1; index < 1e3; ++index) {
+      let fileSize = 0;
+      let stats = void 0;
+      this.filename = this.options.path + this.generator(now, index);
+      try {
+        stats = await this.fsStat(this.filename);
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
+      }
+      if (stats) {
+        fileSize = stats.size;
+        if (!stats.isFile())
+          throw new Error(`Can't write on: '${this.filename}' (it is not a file)`);
+        if (size && fileSize >= size)
+          continue;
+      }
+      if (first) {
+        this.last = this.filename;
+        return this.reopen(fileSize);
+      }
+      await this.rotated(this.last);
+      this.last = this.filename;
+      return;
+    }
+    throw new RotatingFileStreamError();
+  }
+  async unlink(filename) {
+    try {
+      await this.fsUnlink(filename);
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+      this.emit("warning", e);
+    }
+  }
+};
+function buildNumberCheck(field) {
+  return (type, options, value) => {
+    const converted = parseInt(value, 10);
+    if (type !== "number" || converted !== value || converted <= 0)
+      throw new Error(`'${field}' option must be a positive integer number`);
+  };
+}
+function buildStringCheck(field, check) {
+  return (type, options, value) => {
+    if (type !== "string")
+      throw new Error(`Don't know how to handle 'options.${field}' type: ${type}`);
+    options[field] = check(value);
+  };
+}
+function checkMeasure(value, what, units) {
+  const ret = {};
+  ret.num = parseInt(value, 10);
+  if (isNaN(ret.num))
+    throw new Error(`Unknown 'options.${what}' format: ${value}`);
+  if (ret.num <= 0)
+    throw new Error(`A positive integer number is expected for 'options.${what}'`);
+  ret.unit = value.replace(/^[ 0]*/g, "").substr((ret.num + "").length, 1);
+  if (ret.unit.length === 0)
+    throw new Error(`Missing unit for 'options.${what}'`);
+  if (!units[ret.unit])
+    throw new Error(`Unknown 'options.${what}' unit: ${ret.unit}`);
+  return ret;
+}
+var intervalUnits = { M: true, d: true, h: true, m: true, s: true };
+function checkIntervalUnit(ret, unit, amount) {
+  if (parseInt(amount / ret.num, 10) * ret.num !== amount)
+    throw new Error(`An integer divider of ${amount} is expected as ${unit} for 'options.interval'`);
+}
+function checkInterval(value) {
+  const ret = checkMeasure(value, "interval", intervalUnits);
+  switch (ret.unit) {
+    case "h":
+      checkIntervalUnit(ret, "hours", 24);
+      break;
+    case "m":
+      checkIntervalUnit(ret, "minutes", 60);
+      break;
+    case "s":
+      checkIntervalUnit(ret, "seconds", 60);
+      break;
+  }
+  return ret;
+}
+var sizeUnits = { B: true, G: true, K: true, M: true };
+function checkSize(value) {
+  const ret = checkMeasure(value, "size", sizeUnits);
+  if (ret.unit === "K")
+    return ret.num * 1024;
+  if (ret.unit === "M")
+    return ret.num * 1048576;
+  if (ret.unit === "G")
+    return ret.num * 1073741824;
+  return ret.num;
+}
+var checks = {
+  encoding: (type, options, value) => new TextDecoder(value),
+  immutable: () => {
+  },
+  initialRotation: () => {
+  },
+  interval: buildStringCheck("interval", checkInterval),
+  intervalBoundary: () => {
+  },
+  intervalUTC: () => {
+  },
+  maxFiles: buildNumberCheck("maxFiles"),
+  maxSize: buildStringCheck("maxSize", checkSize),
+  mode: () => {
+  },
+  omitExtension: () => {
+  },
+  rotate: buildNumberCheck("rotate"),
+  size: buildStringCheck("size", checkSize),
+  teeToStdout: () => {
+  },
+  ...{
+    compress: (type, options, value) => {
+      if (value === false)
+        return;
+      if (!value)
+        throw new Error("A value for 'options.compress' must be specified");
+      if (type === "boolean")
+        return options.compress = (source, dest) => `cat ${source} | gzip -c9 > ${dest}`;
+      if (type === "function")
+        return;
+      if (type !== "string")
+        throw new Error(`Don't know how to handle 'options.compress' type: ${type}`);
+      if (value !== "gzip")
+        throw new Error(`Don't know how to handle compression method: ${value}`);
+    },
+    history: (type) => {
+      if (type !== "string")
+        throw new Error(`Don't know how to handle 'options.history' type: ${type}`);
+    },
+    path: (type, options, value) => {
+      if (type !== "string")
+        throw new Error(`Don't know how to handle 'options.path' type: ${type}`);
+      if (value[value.length - 1] !== sep)
+        options.path = value + sep;
+    }
+  }
+};
+function checkOpts(options) {
+  const ret = {};
+  let opt;
+  for (opt in options) {
+    const value = options[opt];
+    const type = typeof value;
+    if (!(opt in checks))
+      throw new Error(`Unknown option: ${opt}`);
+    ret[opt] = options[opt];
+    checks[opt](type, ret, value);
+  }
+  if (!ret.path)
+    ret.path = "";
+  if (!ret.interval) {
+    delete ret.immutable;
+    delete ret.initialRotation;
+    delete ret.intervalBoundary;
+    delete ret.intervalUTC;
+  }
+  if (ret.rotate) {
+    delete ret.history;
+    delete ret.immutable;
+    delete ret.maxFiles;
+    delete ret.maxSize;
+    delete ret.intervalBoundary;
+    delete ret.intervalUTC;
+  }
+  if (ret.immutable)
+    delete ret.compress;
+  if (!ret.intervalBoundary)
+    delete ret.initialRotation;
+  return ret;
+}
+function createClassical(filename, compress, omitExtension) {
+  return (index) => index ? `${filename}.${index}${compress && !omitExtension ? ".gz" : ""}` : filename;
+}
+function createGenerator(filename, compress, omitExtension) {
+  const pad = (num) => (num > 9 ? "" : "0") + num;
+  return (time, index) => {
+    if (!time)
+      return filename;
+    const month = time.getFullYear() + "" + pad(time.getMonth() + 1);
+    const day = pad(time.getDate());
+    const hour = pad(time.getHours());
+    const minute = pad(time.getMinutes());
+    return month + day + "-" + hour + minute + "-" + pad(index) + "-" + filename + (compress && !omitExtension ? ".gz" : "");
+  };
+}
+function createStream(filename, options) {
+  if (typeof options === "undefined")
+    options = {};
+  else if (typeof options !== "object")
+    throw new Error(`The "options" argument must be of type object. Received type ${typeof options}`);
+  const opts = checkOpts(options);
+  const { compress, omitExtension } = opts;
+  let generator;
+  if (typeof filename === "string")
+    generator = options.rotate ? createClassical(filename, !!compress, omitExtension) : createGenerator(filename, !!compress, omitExtension);
+  else if (typeof filename === "function")
+    generator = filename;
+  else
+    throw new Error(`The "filename" argument must be one of type string or function. Received type ${typeof filename}`);
+  return new RotatingFileStream(generator, opts);
+}
+
+// ../logger/src/transports/file.ts
+function parseSize(maxSize) {
+  const trimmed = maxSize.trim().toUpperCase();
+  if (trimmed.endsWith("MB")) {
+    return `${trimmed.slice(0, -2)}M`;
+  }
+  return trimmed;
+}
+function fileTransport(opts) {
+  const fmt = opts.formatter ?? jsonFormatter;
+  const dir = path2.dirname(opts.path);
+  const filename = path2.basename(opts.path);
+  const stream = createStream(filename, {
+    path: dir,
+    size: opts.rotate?.maxSize ? parseSize(opts.rotate.maxSize) : "50M",
+    maxFiles: opts.rotate?.maxFiles ?? 7
+  });
+  return (entry) => {
+    stream.write(`${fmt(entry)}
+`);
+  };
+}
+
+// ../logger/src/index.ts
+function createLogger(config) {
+  return new Logger(config);
+}
+
+// src/logger.ts
+var bridgeConfig = loadBridgeConfig();
+var isTest = !!process.env["VITEST"];
+var LOG_DIR = path3.join(os3.homedir(), ".ahchat", "logs");
+var LOG_FILE = path3.join(LOG_DIR, "bridge.log");
+if (!isTest) ensureDir(LOG_DIR);
+function createModuleLogger(module) {
+  const transports = [consoleTransport({ formatter: prettyFormatter })];
+  if (!isTest) {
+    transports.push(
+      fileTransport({
+        path: LOG_FILE,
+        formatter: jsonFormatter,
+        rotate: { maxSize: "20MB", maxFiles: 5 }
+      })
+    );
+  }
+  return createLogger({
+    source: "bridge",
+    module,
+    level: bridgeConfig.logLevel,
+    transports
+  });
+}
+
+// src/askQuestionRegistry.ts
+var logger = createModuleLogger("askQuestionRegistry");
+var ASK_QUESTION_TIMEOUT_MS = 12e4;
+var TIMEOUT_ANSWER = "[User did not respond within 120 seconds. Please decide whether to proceed with reasonable defaults or skip this step.]";
+var AskQuestionRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  /** Register a pending question; always resolves (never rejects). */
+  register(questionId, agentId, onTimeout, timeoutMs = ASK_QUESTION_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        if (!this.entries.has(questionId)) return;
+        this.entries.delete(questionId);
+        logger.warn("AskQuestion timeout", { questionId, agentId, timeoutMs });
+        try {
+          onTimeout();
+        } catch (e) {
+          logger.error("onTimeout cb threw", { error: e });
+        }
+        resolve(TIMEOUT_ANSWER);
+      }, timeoutMs);
+      this.entries.set(questionId, { resolve, timer, agentId, askedAt: Date.now() });
+      logger.info("AskQuestion registered", { questionId, agentId, timeoutMs });
+    });
+  }
+  resolve(questionId, answerText) {
+    const entry = this.entries.get(questionId);
+    if (!entry) {
+      logger.warn("AskQuestion resolve: id not found (may be timed out)", { questionId });
+      return false;
+    }
+    clearTimeout(entry.timer);
+    this.entries.delete(questionId);
+    logger.info("AskQuestion resolved", {
+      questionId,
+      agentId: entry.agentId,
+      waitedMs: Date.now() - entry.askedAt,
+      answerLen: answerText.length,
+      answerSample: answerText.slice(0, 200)
+    });
+    entry.resolve(answerText);
+    return true;
+  }
+  cancelAll(reason) {
+    if (this.entries.size === 0) return;
+    logger.warn("AskQuestion cancelAll", { reason, count: this.entries.size });
+    for (const [, entry] of this.entries) {
+      clearTimeout(entry.timer);
+      entry.resolve(`[${reason}]`);
+    }
+    this.entries.clear();
+  }
+  cancelOne(questionId, reason) {
+    const entry = this.entries.get(questionId);
+    if (!entry) return false;
+    clearTimeout(entry.timer);
+    this.entries.delete(questionId);
+    entry.resolve(`[${reason}]`);
+    return true;
+  }
+  size() {
+    return this.entries.size;
+  }
+};
+
+// ../shared/src/constants.ts
+var NO_REPLY_TOKEN = "<no-reply/>";
+var PLATFORM_AGENT_RULES = `
+You are an Agent in AHChat, a multi-agent IM platform where humans and Agents
+participate as peers in 1:1 and group conversations.
+
+# Default style
+- IM-style replies: short, direct, concrete. No multi-paragraph essays unless asked.
+- Don't quote your own name back to the user; don't refer to yourself in third person.
+- Don't append meta-commentary like "Here's my answer:" \u2014 just answer.
+- Use the same language as the most recent message in the conversation.
+
+# Group chat \u2014 when to speak
+You may receive messages where the speaker is the human user OR a fellow Agent.
+
+When the speaker is a fellow Agent (NOT the user):
+- Default behavior: reply with exactly \`<no-reply/>\` and stay silent.
+- ONLY speak if ONE of the following holds:
+  (a) the speaker @mentioned you by name;
+  (b) the speaker stated something factually wrong that you uniquely can correct;
+  (c) the topic genuinely requires your specific expertise and nobody else has it.
+- Agreeing, paraphrasing, summarizing, thanking, or politely expanding are
+  NOT sufficient reasons to speak. When in doubt, \`<no-reply/>\`.
+
+When the speaker is the human user:
+- Follow the per-message instructions (mentioned / overhearer / open-floor) in
+  the dispatch. The same \`<no-reply/>\` semantics apply when you have nothing
+  meaningful to add.
+
+# Length & conciseness in group chat
+- In group chat, default to short. Long-form only when explicitly asked.
+- In 1:1 chat with the human, you may write longer answers when warranted.
+
+# Tools
+- File paths: prefer relative; absolute only when necessary.
+- After Write, don't re-Read the same content unless verifying.
+
+# Cross-scope awareness (Neural Bus)
+You operate across multiple conversations (1:1 and groups). Each conversation has
+independent context, but you can bridge them using the neural_recall and neural_relay tools:
+
+- neural_recall: Recall what you did/said in another conversation.
+  Use when asked to report on, summarize, or reference another group's activities.
+  Parameters: target_scope (e.g. "group:grp_xxx"), time_range (e.g. "30m", "3h", "7d").
+- neural_relay: Ask your other-scope self to execute a task or speak in that conversation.
+  Parameters: target_scope, task, mode ("internal" or "external").
+  - mode="internal": Wait for your other-scope self to finish and return the result.
+    Use for "summarize group B" / "aggregate group B progress" type requests.
+  - mode="external": Fire-and-forget. Your other-scope self will speak/act there.
+    Use for "tell people in group B to do X" type delegation.
+
+Your other-scope instances share your identity and personality. Treat relay responses
+as your own work product, not as a separate agent's output.
+When asked about other conversations' content, always try neural_recall first.
+`.trim();
+var FAN_OUT_TRACE_TTL_MS = 10 * 6e4;
+
+// ../../node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/index.js
+import { webcrypto as crypto2 } from "crypto";
+
+// ../../node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (bytes < 0 || bytes > 1024) throw new RangeError("Wrong ID size");
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto2.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto2.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
+// ../shared/src/utils.ts
+function createMessageId() {
+  return `msg_${nanoid(12)}`;
+}
+function createAskQuestionId() {
+  return `aq_${nanoid(12)}`;
+}
+function isWSMessage(data) {
+  return typeof data === "object" && data !== null && "type" in data && "payload" in data;
+}
+function parseWSMessage(raw) {
+  const parsed = JSON.parse(raw);
+  if (!isWSMessage(parsed)) {
+    throw new Error("Invalid WS message: missing type/payload");
+  }
+  return parsed;
+}
+
+// ../shared/src/utils/agentConfig.ts
+function parseAgentConfig(raw) {
+  if (!raw || typeof raw !== "string") return {};
+  try {
+    const v = JSON.parse(raw);
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      const out = {};
+      const model = v.model;
+      if (typeof model === "string" && model.trim()) {
+        out.model = model.trim();
+      }
+      return out;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+// src/scope.ts
+function scopeKey(scope) {
+  return scope.kind === "single" ? "single" : `group:${scope.groupId}`;
+}
+function runtimeKey(agentId, scope) {
+  return `${agentId}::${scopeKey(scope)}`;
+}
+
+// src/askUserQuestionGuard.ts
+var logger2 = createModuleLogger("askUserQuestionGuard");
+function formatAnswerForSDK(p) {
+  const parts = ["[User Response]"];
+  if (p.selectedLabels.length > 0) {
+    parts.push(`\u9009\u62E9\uFF1A${p.selectedLabels.join("\u3001")}`);
+  }
+  if (p.freeformText && p.freeformText.trim()) {
+    parts.push(`\u5907\u6CE8\uFF1A${p.freeformText.trim()}`);
+  }
+  if (parts.length === 1) {
+    parts.push("\uFF08\u7528\u6237\u672A\u9009\u62E9\u4EFB\u4F55\u9009\u9879\u4E5F\u672A\u586B\u5199\u5907\u6CE8\uFF09");
+  }
+  return parts.join("\n");
+}
+function makeAskUserQuestionGuard(deps) {
+  return async (input) => {
+    const task = deps.getCurrentTask();
+    if (!task) {
+      logger2.error("AskUserQuestion received but no currentTask", { agentId: deps.agentId });
+      return { behavior: "deny", message: "[Internal error: no active task context]" };
+    }
+    const questions = input.questions ?? [];
+    if (questions.length === 0) {
+      logger2.warn("AskUserQuestion called with empty questions array", { agentId: deps.agentId });
+      return { behavior: "deny", message: "[Internal error: empty questions]" };
+    }
+    if (questions.length > 1) {
+      logger2.warn("AskUserQuestion received multi questions, Plan A only handles questions[0]", {
+        agentId: deps.agentId,
+        count: questions.length
+      });
+    }
+    const q = questions[0];
+    const questionId = createAskQuestionId();
+    const askedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const options = (q.options ?? []).map((o) => ({
+      label: o.label,
+      description: o.description
+    }));
+    const multiSelect = Boolean(q.multiSelect);
+    logger2.info("AskUserQuestion intercepted, emitting agent:ask_user_question", {
+      agentId: deps.agentId,
+      scope: scopeKey(deps.scope),
+      groupId: task.groupId,
+      questionId,
+      replyMessageId: task.replyMessageId,
+      question: q.question.slice(0, 200),
+      optionCount: options.length,
+      multiSelect,
+      traceId: task.traceId
+    });
+    deps.emit({
+      type: "agent:ask_user_question",
+      payload: {
+        questionId,
+        replyMessageId: task.replyMessageId,
+        agentId: deps.agentId,
+        conversationId: task.conversationId,
+        groupId: task.groupId,
+        question: q.question,
+        header: q.header,
+        options,
+        multiSelect,
+        askedAt,
+        timeoutMs: ASK_QUESTION_TIMEOUT_MS,
+        traceId: task.traceId
+      }
+    });
+    logger2.info("AskUserQuestion agent status awaiting_user", {
+      agentId: deps.agentId,
+      questionId,
+      groupId: task.groupId,
+      traceId: task.traceId
+    });
+    deps.emit({
+      type: "agent:status",
+      payload: { agentId: deps.agentId, status: "awaiting_user" }
+    });
+    const answerText = await deps.registry.register(questionId, deps.agentId, () => {
+      deps.emit({
+        type: "ask_question_updated",
+        payload: {
+          questionId,
+          agentId: deps.agentId,
+          conversationId: task.conversationId,
+          status: "timeout",
+          cancelReason: "timeout",
+          traceId: task.traceId
+        }
+      });
+    });
+    logger2.info("AskUserQuestion agent status thinking (resume SDK)", {
+      agentId: deps.agentId,
+      questionId,
+      groupId: task.groupId,
+      traceId: task.traceId
+    });
+    deps.emit({
+      type: "agent:status",
+      payload: { agentId: deps.agentId, status: "thinking" }
+    });
+    logger2.info("AskUserQuestion answered, returning deny+message to SDK", {
+      agentId: deps.agentId,
+      questionId,
+      replyMessageId: task.replyMessageId,
+      answerSample: answerText.slice(0, 200),
+      traceId: task.traceId
+    });
+    return { behavior: "deny", message: answerText };
+  };
+}
+
+// src/wsMetrics.ts
+import { monitorEventLoopDelay } from "perf_hooks";
+var logger3 = createModuleLogger("ws.metrics");
+var WsMetrics = class {
+  recv = /* @__PURE__ */ new Map();
+  send = /* @__PURE__ */ new Map();
+  sdkOut = /* @__PURE__ */ new Map();
+  timer = null;
+  loopHist = null;
+  start(intervalMs = 5e3) {
+    if (this.timer) return;
+    this.loopHist = monitorEventLoopDelay({ resolution: 20 });
+    this.loopHist.enable();
+    this.timer = setInterval(() => this.flush(intervalMs), intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.loopHist?.disable();
+    this.loopHist = null;
+  }
+  incRecv(type) {
+    this.recv.set(type, (this.recv.get(type) ?? 0) + 1);
+  }
+  incSend(type) {
+    this.send.set(type, (this.send.get(type) ?? 0) + 1);
+  }
+  incSdkOut(type) {
+    this.sdkOut.set(type, (this.sdkOut.get(type) ?? 0) + 1);
+  }
+  mapToObj(m) {
+    const out = {};
+    for (const [k, v] of m) out[k] = v;
+    return out;
+  }
+  flush(intervalMs) {
+    const hist = this.loopHist;
+    const stats = hist ? {
+      loopMaxMs: Math.round(hist.max / 1e6),
+      loopP99Ms: Math.round(hist.percentile(99) / 1e6),
+      loopMeanMs: Math.round(hist.mean / 1e6)
+    } : {};
+    if (hist) hist.reset();
+    const recvSum = [...this.recv.values()].reduce((a, b) => a + b, 0);
+    const sendSum = [...this.send.values()].reduce((a, b) => a + b, 0);
+    const sdkSum = [...this.sdkOut.values()].reduce((a, b) => a + b, 0);
+    if (recvSum + sendSum + sdkSum === 0 && (stats.loopMaxMs ?? 0) < 50) return;
+    logger3.info("WS metrics", {
+      windowMs: intervalMs,
+      ...stats,
+      sums: { recv: recvSum, send: sendSum, sdkOut: sdkSum },
+      recv: this.mapToObj(this.recv),
+      send: this.mapToObj(this.send),
+      sdkOut: this.mapToObj(this.sdkOut)
+    });
+    this.recv.clear();
+    this.send.clear();
+    this.sdkOut.clear();
+  }
+};
+var wsMetrics = new WsMetrics();
+
+// src/agentManager.ts
+import fs2 from "fs/promises";
+import os4 from "os";
+import path6 from "path";
+
+// src/inputController.ts
+var InputController = class {
+  queue = [];
+  pendingResolve = null;
+  closed = false;
+  /** User messages buffered but not yet yielded to the SDK iterator. */
+  get queueSize() {
+    return this.queue.length;
+  }
+  push(content, sessionId, onYielded) {
+    if (this.closed) return;
+    const msg = {
+      type: "user",
+      session_id: sessionId,
+      message: { role: "user", content },
+      parent_tool_use_id: null
+    };
+    const entry = { msg, onYielded };
+    if (this.pendingResolve) {
+      const resolve = this.pendingResolve;
+      this.pendingResolve = null;
+      resolve(entry);
+    } else {
+      this.queue.push(entry);
+    }
+  }
+  close() {
+    this.closed = true;
+    if (this.pendingResolve) {
+      const resolve = this.pendingResolve;
+      this.pendingResolve = null;
+      resolve(null);
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    while (!this.closed) {
+      let entry;
+      if (this.queue.length > 0) {
+        entry = this.queue.shift();
+      } else {
+        entry = await new Promise((resolve) => {
+          if (this.closed) {
+            resolve(null);
+            return;
+          }
+          this.pendingResolve = resolve;
+        });
+        if (entry === null) break;
+      }
+      entry.onYielded?.();
+      yield entry.msg;
+    }
+  }
+};
+
+// src/permissionGuard.ts
+import path5 from "path";
+
+// ../shared/src/utils/pathSafety.ts
+import path4 from "path";
+function isPathInside(parent, child) {
+  const resolvedParent = path4.resolve(parent);
+  const resolvedChild = path4.resolve(child);
+  if (resolvedParent === resolvedChild) return true;
+  const rel = path4.relative(resolvedParent, resolvedChild);
+  if (rel === "") return true;
+  return !rel.startsWith("..") && !path4.isAbsolute(rel);
+}
+
+// src/permissionGuard.ts
+var WRITE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function makeCwdPermissionGuard(cwd, agentId, scope, log) {
+  const scopeStr = scopeKey(scope);
+  return async (toolName, input) => {
+    if (!WRITE_TOOLS.has(toolName)) {
+      return { behavior: "allow" };
+    }
+    const raw = input.file_path ?? input.path ?? input.notebook_path;
+    if (typeof raw !== "string" || raw.length === 0) {
+      return { behavior: "allow" };
+    }
+    const abs = path5.isAbsolute(raw) ? raw : path5.resolve(cwd, raw);
+    if (isPathInside(cwd, abs)) {
+      return { behavior: "allow" };
+    }
+    log("canUseTool deny: write outside cwd", { agentId, scope: scopeStr, toolName, target: raw, abs, cwd });
+    return {
+      behavior: "deny",
+      message: `\u5DE5\u4F5C\u76EE\u5F55\u5916\u4E0D\u53EF\u5199\u5165\uFF1A${abs}\uFF08cwd=${cwd}\uFF09`
+    };
+  };
+}
+
+// src/neuralBus.ts
+var logger4 = createModuleLogger("neural.bus");
+var NeuralJournal = class {
+  buffer = [];
+  maxEntries;
+  constructor(maxEntries = 200) {
+    this.maxEntries = maxEntries;
+  }
+  append(event) {
+    if (this.buffer.length >= this.maxEntries) {
+      this.buffer.shift();
+    }
+    this.buffer.push(event);
+  }
+  query(filter) {
+    const now = Date.now();
+    return this.buffer.filter((e) => {
+      if (filter.excludeScope && e.sourceScope === filter.excludeScope) return false;
+      if (filter.targetScope && e.sourceScope !== filter.targetScope) return false;
+      if (filter.sinceMs && now - e.timestamp > filter.sinceMs) return false;
+      if (filter.type && e.type !== filter.type) return false;
+      return true;
+    });
+  }
+  get size() {
+    return this.buffer.length;
+  }
+  clear() {
+    this.buffer = [];
+  }
+};
+var eventCounter = 0;
+function generateEventId() {
+  return `ne_${Date.now().toString(36)}_${(eventCounter++).toString(36)}`;
+}
+var relayCounter = 0;
+function generateRelayId() {
+  return `nr_${Date.now().toString(36)}_${(relayCounter++).toString(36)}`;
+}
+var RELAY_TIMEOUT_MS = 12e4;
+var RELAY_TIMEOUT_MESSAGE = "[\u8DE8\u5BF9\u8BDD\u4E2D\u7EE7\u8D85\u65F6\uFF1A\u76EE\u6807\u5BF9\u8BDD\u672A\u5728 120 \u79D2\u5185\u5B8C\u6210\u5904\u7406\u3002\u8BF7\u7A0D\u540E\u91CD\u8BD5\u6216\u76F4\u63A5\u5728\u76EE\u6807\u5BF9\u8BDD\u4E2D\u64CD\u4F5C\u3002]";
+var AgentNeuralBus = class {
+  agentId;
+  journal;
+  pendingRelays = /* @__PURE__ */ new Map();
+  relayQueue = [];
+  constructor(agentId, maxEntries = 200) {
+    this.agentId = agentId;
+    this.journal = new NeuralJournal(maxEntries);
+  }
+  /**
+   * Publish a turn summary after task completion.
+   * Called by AgentManager.onTaskCompleted for cross-scope awareness.
+   */
+  publish(sourceScope, summary, detail) {
+    if (!summary || summary.trim().length === 0) return;
+    const event = {
+      id: generateEventId(),
+      sourceScope,
+      timestamp: Date.now(),
+      type: "turn_summary",
+      summary: summary.trim(),
+      detail: detail?.slice(0, 2e3)
+    };
+    this.journal.append(event);
+    logger4.info("NeuralBus event published", {
+      agentId: this.agentId,
+      sourceScope,
+      eventId: event.id,
+      summaryLen: event.summary.length,
+      hasDetail: !!detail
+    });
+  }
+  /**
+   * Query cross-scope digest for passive injection.
+   * Returns events from OTHER scopes (excludes requestingScope).
+   */
+  queryDigest(requestingScope, sinceMs) {
+    return this.journal.query({
+      excludeScope: requestingScope,
+      sinceMs,
+      type: "turn_summary"
+    });
+  }
+  /**
+   * Query detailed cross-scope history for NeuralRecall tool.
+   * Returns events with detail field populated.
+   */
+  queryDetail(requestingScope, targetScope, sinceMs) {
+    const events = this.journal.query({
+      excludeScope: requestingScope,
+      targetScope,
+      sinceMs,
+      type: "turn_summary"
+    });
+    return events.filter((e) => e.detail != null);
+  }
+  /**
+   * Create a relay request to another scope.
+   * For mode='internal': returns a Promise that resolves when target scope completes.
+   * For mode='external': returns immediately with ack message.
+   */
+  relay(params) {
+    const relayId = generateRelayId();
+    const timeoutMs = params.timeoutMs ?? RELAY_TIMEOUT_MS;
+    if (params.mode === "external") {
+      const request2 = {
+        id: relayId,
+        fromScope: params.fromScope,
+        toScope: params.toScope,
+        message: params.message,
+        mode: "external",
+        timeoutMs,
+        createdAt: Date.now(),
+        conversationId: params.conversationId,
+        groupId: params.groupId
+      };
+      this.relayQueue.push(request2);
+      logger4.info("NeuralBus external relay queued", {
+        agentId: this.agentId,
+        relayId,
+        fromScope: params.fromScope,
+        toScope: params.toScope,
+        messageLen: params.message.length,
+        conversationId: params.conversationId,
+        groupId: params.groupId
+      });
+      return { relayId };
+    }
+    let resolveRef;
+    let rejectRef;
+    const promise = new Promise((resolve, reject) => {
+      resolveRef = resolve;
+      rejectRef = reject;
+    });
+    const timer = setTimeout(() => {
+      const req = this.pendingRelays.get(relayId);
+      if (!req) return;
+      this.pendingRelays.delete(relayId);
+      logger4.warn("NeuralBus internal relay timeout", {
+        agentId: this.agentId,
+        relayId,
+        fromScope: params.fromScope,
+        toScope: params.toScope,
+        timeoutMs
+      });
+      req.resolve?.(RELAY_TIMEOUT_MESSAGE);
+    }, timeoutMs);
+    const request = {
+      id: relayId,
+      fromScope: params.fromScope,
+      toScope: params.toScope,
+      message: params.message,
+      mode: "internal",
+      resolve: resolveRef,
+      reject: rejectRef,
+      timer,
+      timeoutMs,
+      createdAt: Date.now()
+    };
+    this.pendingRelays.set(relayId, request);
+    this.relayQueue.push(request);
+    logger4.info("NeuralBus internal relay queued", {
+      agentId: this.agentId,
+      relayId,
+      fromScope: params.fromScope,
+      toScope: params.toScope,
+      messageLen: params.message.length,
+      timeoutMs
+    });
+    return { relayId, promise };
+  }
+  /**
+   * Consume a pending relay for the target scope (called by wakeup mechanism).
+   * Returns the next relay destined for this scope, or undefined.
+   */
+  consumeRelay(targetScope) {
+    const idx = this.relayQueue.findIndex((r) => r.toScope === targetScope);
+    if (idx === -1) return void 0;
+    return this.relayQueue.splice(idx, 1)[0];
+  }
+  /**
+   * Resolve an internal relay with the response from the target scope.
+   */
+  resolveRelay(relayId, response) {
+    const req = this.pendingRelays.get(relayId);
+    if (!req) {
+      return false;
+    }
+    if (req.timer) clearTimeout(req.timer);
+    this.pendingRelays.delete(relayId);
+    logger4.info("NeuralBus relay resolved", {
+      agentId: this.agentId,
+      relayId,
+      fromScope: req.fromScope,
+      toScope: req.toScope,
+      responseLen: response.length,
+      waitedMs: Date.now() - req.createdAt
+    });
+    req.resolve?.(response);
+    return true;
+  }
+  /**
+   * Cancel all pending relays (e.g. on agent terminate).
+   */
+  cancelAll(reason) {
+    for (const [, req] of this.pendingRelays) {
+      if (req.timer) clearTimeout(req.timer);
+      req.resolve?.(`[\u4E2D\u7EE7\u53D6\u6D88\uFF1A${reason}]`);
+    }
+    this.pendingRelays.clear();
+    this.relayQueue.length = 0;
+    logger4.info("NeuralBus cancelAll", { agentId: this.agentId, reason });
+  }
+  get pendingRelayCount() {
+    return this.pendingRelays.size;
+  }
+  get relayQueueSize() {
+    return this.relayQueue.length;
+  }
+};
+
+// src/neuralDigestFormatter.ts
+function extractTurnSummary(accumulatedText) {
+  const trimmed = (accumulatedText ?? "").trim();
+  if (!trimmed || trimmed === NO_REPLY_TOKEN) return "";
+  const firstLine = trimmed.split("\n")[0] ?? "";
+  const cleaned = firstLine.replace(/^#+\s*/, "").trim();
+  if (cleaned.length <= 100) return cleaned;
+  return cleaned.slice(0, 97) + "...";
+}
+function formatScopeLabel(scopeKey2) {
+  if (scopeKey2 === "single") return "\u5355\u804A";
+  if (scopeKey2.startsWith("group:")) {
+    const groupId = scopeKey2.slice(6);
+    return `\u7FA4\u300C${groupId}\u300D`;
+  }
+  return scopeKey2;
+}
+function formatRelativeTime(timestamp) {
+  const diff = Date.now() - timestamp;
+  const seconds = Math.floor(diff / 1e3);
+  if (seconds < 60) return "\u521A\u521A";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}\u5206\u949F\u524D`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}\u5C0F\u65F6\u524D`;
+  const days = Math.floor(hours / 24);
+  return `${days}\u5929\u524D`;
+}
+function formatDigestPrefix(events) {
+  if (events.length === 0) return "";
+  const sorted = [...events].sort((a, b) => b.timestamp - a.timestamp);
+  const lines = sorted.map((e) => {
+    const time = formatRelativeTime(e.timestamp);
+    const scope = formatScopeLabel(e.sourceScope);
+    return `- ${time} ${scope}\uFF1A${e.summary}`;
+  });
+  return `[\u4F60\u5728\u5176\u4ED6\u5BF9\u8BDD\u4E2D\u7684\u8FD1\u51B5]
+${lines.join("\n")}`;
+}
+function formatRecallResponse(events, targetScopeLabel) {
+  if (events.length === 0) {
+    const scopeHint = targetScopeLabel ? `\u5728${targetScopeLabel}` : "\u5728\u5176\u4ED6\u5BF9\u8BDD\u4E2D";
+    return `[\u8DE8\u5BF9\u8BDD\u56DE\u5FC6] \u4F60${scopeHint}\u6682\u65E0\u8FD1\u671F\u6D3B\u52A8\u8BB0\u5F55\u3002`;
+  }
+  const sorted = [...events].sort((a, b) => b.timestamp - a.timestamp);
+  const header = targetScopeLabel ? `[\u8DE8\u5BF9\u8BDD\u56DE\u5FC6 \u2014 ${targetScopeLabel}]` : "[\u8DE8\u5BF9\u8BDD\u56DE\u5FC6]";
+  const entries = sorted.map((e) => {
+    const time = formatRelativeTime(e.timestamp);
+    const scope = formatScopeLabel(e.sourceScope);
+    const detailBlock = e.detail ? `
+  \u5185\u5BB9\u6458\u8981\uFF1A${e.detail.slice(0, 500)}` : "";
+    return `- ${time} ${scope}\uFF1A${e.summary}${detailBlock}`;
+  });
+  return `${header}
+${entries.join("\n\n")}`;
+}
+
+// src/neuralMcpServer.ts
+var logger5 = createModuleLogger("neural.mcpServer");
+var TIME_RANGE_MAP = {
+  "5m": 5 * 6e4,
+  "15m": 15 * 6e4,
+  "30m": 30 * 6e4,
+  "1h": 60 * 6e4,
+  "3h": 3 * 60 * 6e4,
+  "6h": 6 * 60 * 6e4,
+  "12h": 12 * 60 * 6e4,
+  "24h": 24 * 60 * 6e4,
+  "1d": 24 * 60 * 6e4,
+  "3d": 3 * 24 * 60 * 6e4,
+  "7d": 7 * 24 * 60 * 6e4
+};
+function parseTimeRange(raw) {
+  if (!raw) return void 0;
+  const normalized = raw.toLowerCase().trim();
+  if (TIME_RANGE_MAP[normalized] != null) return TIME_RANGE_MAP[normalized];
+  const match = /^(\d+)\s*(m|min|h|hour|d|day)s?$/.exec(normalized);
+  if (match) {
+    const num = parseInt(match[1], 10);
+    const unit = match[2];
+    if (unit === "m" || unit === "min") return num * 6e4;
+    if (unit === "h" || unit === "hour") return num * 60 * 6e4;
+    if (unit === "d" || unit === "day") return num * 24 * 60 * 6e4;
+  }
+  return void 0;
+}
+async function createNeuralMcpServer(deps) {
+  const sdk = await import("@anthropic-ai/claude-agent-sdk");
+  const { z } = await import("zod");
+  const currentScope = scopeKey(deps.scope);
+  const neuralRecall = sdk.tool(
+    "neural_recall",
+    `\u56DE\u5FC6\u4F60\u5728\u5176\u4ED6\u5BF9\u8BDD\uFF08\u7FA4\u804A\u6216\u5355\u804A\uFF09\u4E2D\u505A\u8FC7\u7684\u4E8B\u60C5\u3002\u5F53\u88AB\u8981\u6C42\u6C47\u62A5\u3001\u603B\u7ED3\u3001\u5F15\u7528\u5176\u4ED6\u5BF9\u8BDD\u7684\u6D3B\u52A8\u65F6\u4F7F\u7528\u3002
+\u4F60\u5F53\u524D\u6240\u5728\u7684\u5BF9\u8BDD scope \u662F: ${currentScope}\u3002\u6B64\u5DE5\u5177\u53EA\u8FD4\u56DE\u5176\u4ED6 scope \u7684\u8BB0\u5F55\u3002`,
+    {
+      target_scope: z.string().optional().describe(
+        '\u76EE\u6807\u5BF9\u8BDD\u7684 scope key\u3002\u5982 "single"\uFF08\u5355\u804A\uFF09\u3001"group:grp_xxx"\uFF08\u67D0\u4E2A\u7FA4\uFF09\u3002\u4E0D\u586B\u5219\u8FD4\u56DE\u6240\u6709\u5176\u4ED6\u5BF9\u8BDD\u7684\u8BB0\u5F55\u3002'
+      ),
+      time_range: z.string().optional().describe(
+        '\u65F6\u95F4\u8303\u56F4\u3002\u5982 "30m"\uFF0830\u5206\u949F\uFF09\u3001"3h"\uFF083\u5C0F\u65F6\uFF09\u3001"7d"\uFF087\u5929\uFF09\u3002\u4E0D\u586B\u5219\u8FD4\u56DE\u5168\u90E8\u3002'
+      )
+    },
+    async (args) => {
+      const bus = deps.neuralBusManager.getOrCreate(deps.agentId);
+      logger5.info("neural_recall tool called", {
+        agentId: deps.agentId,
+        currentScope,
+        targetScope: args.target_scope,
+        timeRange: args.time_range,
+        journalSize: bus.journal.size
+      });
+      let resolvedTargetScope = args.target_scope;
+      let targetLabel;
+      if (args.target_scope && args.target_scope.startsWith("group:")) {
+        const resolved = await deps.groupRegistry.resolveScope(args.target_scope);
+        if (resolved) {
+          resolvedTargetScope = resolved.scopeKey;
+          targetLabel = resolved.groupName;
+        } else {
+          targetLabel = formatScopeLabel(args.target_scope);
+        }
+      } else {
+        targetLabel = args.target_scope ? formatScopeLabel(args.target_scope) : void 0;
+      }
+      const sinceMs = parseTimeRange(args.time_range);
+      const events = bus.queryDetail(currentScope, resolvedTargetScope, sinceMs);
+      const response = formatRecallResponse(events, targetLabel);
+      logger5.info("neural_recall returning", {
+        agentId: deps.agentId,
+        eventCount: events.length,
+        responseLen: response.length,
+        targetScope: args.target_scope
+      });
+      return {
+        content: [{ type: "text", text: response }]
+      };
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+  const neuralRelay = sdk.tool(
+    "neural_relay",
+    `\u8DE8\u5BF9\u8BDD\u4E2D\u7EE7\uFF1A\u8BA9\u4F60\u5728\u53E6\u4E00\u4E2A\u5BF9\u8BDD\uFF08\u7FA4\u804A\u6216\u5355\u804A\uFF09\u4E2D\u7684\u5206\u8EAB\u6267\u884C\u4EFB\u52A1\u6216\u53D1\u8A00\u3002
+\u4F60\u5F53\u524D\u6240\u5728\u7684 scope \u662F: ${currentScope}\u3002\u4F60\u53EF\u4EE5\u5411\u4F60\u5728\u5176\u4ED6 scope \u7684\u5206\u8EAB\u53D1\u9001\u6307\u4EE4\u3002
+
+\u4E24\u79CD\u6A21\u5F0F:
+- internal: \u7B49\u5F85\u76EE\u6807\u5206\u8EAB\u5904\u7406\u5B8C\u6210\u5E76\u8FD4\u56DE\u7ED3\u679C\u7ED9\u4F60\uFF08\u9002\u5408"\u5E2E\u6211\u6C47\u603B\u7FA4B\u7684\u8FDB\u5C55"\uFF09\u3002
+- external: \u901A\u77E5\u76EE\u6807\u5206\u8EAB\u53BB\u505A\u67D0\u4E8B\uFF0C\u4E0D\u7B49\u7ED3\u679C\uFF08\u9002\u5408"\u8BA9\u7FA4B\u7684\u4EA7\u54C1\u7ECF\u7406\u53BB\u7814\u7A76\u7ADE\u54C1"\uFF09\u3002`,
+    {
+      target_scope: z.string().describe(
+        '\u76EE\u6807\u5BF9\u8BDD scope key\u3002\u5982 "single"\uFF08\u5355\u804A\uFF09\u3001"group:grp_xxx"\uFF08\u67D0\u4E2A\u7FA4\uFF09\u3002\u4E0D\u80FD\u662F\u4F60\u5F53\u524D\u7684 scope\u3002'
+      ),
+      task: z.string().describe("\u8981\u4F20\u8FBE\u7ED9\u76EE\u6807\u5206\u8EAB\u7684\u4EFB\u52A1\u63CF\u8FF0\u6216\u6D88\u606F\u5185\u5BB9\u3002"),
+      mode: z.enum(["internal", "external"]).default("internal").describe(
+        "internal=\u7B49\u5F85\u7ED3\u679C\u8FD4\u56DE; external=\u901A\u77E5\u540E\u7ACB\u5373\u7EE7\u7EED"
+      )
+    },
+    async (args) => {
+      const bus = deps.neuralBusManager.getOrCreate(deps.agentId);
+      logger5.info("neural_relay tool called", {
+        agentId: deps.agentId,
+        currentScope,
+        targetScope: args.target_scope,
+        mode: args.mode,
+        taskLen: args.task.length,
+        journalSize: bus.journal.size
+      });
+      if (!args.task.trim()) {
+        return {
+          content: [{ type: "text", text: "[\u795E\u7ECF\u4E2D\u7EE7] \u4EFB\u52A1\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A\u3002" }],
+          isError: true
+        };
+      }
+      let resolvedToScope = args.target_scope;
+      let resolvedConversationId;
+      let resolvedGroupId;
+      let resolvedGroupName;
+      if (args.target_scope.startsWith("group:")) {
+        const resolved = await deps.groupRegistry.resolveScope(args.target_scope);
+        if (!resolved) {
+          logger5.info("neural_relay: scope not found", { agentId: deps.agentId, targetScope: args.target_scope });
+          return {
+            content: [{ type: "text", text: `[\u795E\u7ECF\u4E2D\u7EE7] \u627E\u4E0D\u5230\u7FA4\u300C${args.target_scope.slice(6)}\u300D\u3002\u8BF7\u786E\u8BA4\u7FA4\u540D\u662F\u5426\u6B63\u786E\u3002` }],
+            isError: true
+          };
+        }
+        resolvedToScope = resolved.scopeKey;
+        resolvedConversationId = resolved.conversationId;
+        resolvedGroupId = resolved.groupId;
+        resolvedGroupName = resolved.groupName;
+        logger5.info("neural_relay scope resolved", {
+          agentId: deps.agentId,
+          rawScope: args.target_scope,
+          resolvedScope: resolvedToScope,
+          conversationId: resolvedConversationId,
+          groupId: resolvedGroupId,
+          groupName: resolvedGroupName
+        });
+      } else if (args.target_scope === "single") {
+        resolvedToScope = "single";
+      }
+      if (resolvedToScope === currentScope) {
+        logger5.warn("neural_relay: relay to self", { agentId: deps.agentId });
+        return {
+          content: [{ type: "text", text: "[\u795E\u7ECF\u4E2D\u7EE7] \u4E0D\u80FD\u5411\u81EA\u5DF1\u5F53\u524D\u7684\u5BF9\u8BDD\u53D1\u9001\u4E2D\u7EE7\u3002" }],
+          isError: true
+        };
+      }
+      const mode = args.mode;
+      const { relayId, promise } = bus.relay({
+        fromScope: currentScope,
+        toScope: resolvedToScope,
+        message: args.task.trim(),
+        mode,
+        conversationId: resolvedConversationId,
+        groupId: resolvedGroupId
+      });
+      deps.onRelayCreated(relayId, resolvedToScope, mode);
+      if (mode === "external") {
+        const scopeLabel = resolvedGroupName ? `\u7FA4\u300C${resolvedGroupName}\u300D` : formatScopeLabel(resolvedToScope);
+        logger5.info("neural_relay external relay dispatched", {
+          agentId: deps.agentId,
+          relayId,
+          targetScope: resolvedToScope,
+          groupName: resolvedGroupName,
+          conversationId: resolvedConversationId
+        });
+        return {
+          content: [{
+            type: "text",
+            text: `[\u795E\u7ECF\u4E2D\u7EE7] \u5DF2\u901A\u77E5\u4F60\u5728${scopeLabel}\u7684\u5206\u8EAB\u6267\u884C\u4EFB\u52A1\u3002
+\u4EFB\u52A1\uFF1A\u300C${args.task.trim().slice(0, 200)}\u300D`
+          }]
+        };
+      }
+      logger5.info("neural_relay internal awaiting response", {
+        agentId: deps.agentId,
+        relayId,
+        targetScope: args.target_scope
+      });
+      const response = await promise;
+      const isTimeout = response === RELAY_TIMEOUT_MESSAGE;
+      logger5.info("neural_relay internal response received", {
+        agentId: deps.agentId,
+        relayId,
+        targetScope: args.target_scope,
+        responseLen: response.length,
+        isTimeout
+      });
+      return {
+        content: [{ type: "text", text: response }],
+        isError: isTimeout
+      };
+    },
+    {}
+  );
+  const neuralServer = sdk.createSdkMcpServer({
+    name: "neural",
+    version: "1.0.0",
+    tools: [neuralRecall, neuralRelay]
+  });
+  logger5.info("Neural MCP server created", {
+    agentId: deps.agentId,
+    scope: currentScope,
+    tools: ["neural_recall", "neural_relay"]
+  });
+  return neuralServer;
+}
+
+// src/neuralBusManager.ts
+var logger6 = createModuleLogger("neural.busManager");
+var NeuralBusManager = class {
+  buses = /* @__PURE__ */ new Map();
+  maxEntriesPerAgent;
+  constructor(maxEntriesPerAgent = 200) {
+    this.maxEntriesPerAgent = maxEntriesPerAgent;
+  }
+  getOrCreate(agentId) {
+    let bus = this.buses.get(agentId);
+    if (!bus) {
+      bus = new AgentNeuralBus(agentId, this.maxEntriesPerAgent);
+      this.buses.set(agentId, bus);
+      logger6.info("NeuralBus created for agent", { agentId });
+    }
+    return bus;
+  }
+  get(agentId) {
+    return this.buses.get(agentId);
+  }
+  remove(agentId) {
+    const bus = this.buses.get(agentId);
+    if (bus) {
+      bus.cancelAll("agent_removed");
+      this.buses.delete(agentId);
+      logger6.info("NeuralBus removed for agent", { agentId });
+    }
+  }
+  getStats() {
+    let totalEvents = 0;
+    let totalPendingRelays = 0;
+    for (const bus of this.buses.values()) {
+      totalEvents += bus.journal.size;
+      totalPendingRelays += bus.pendingRelayCount;
+    }
+    return {
+      agentCount: this.buses.size,
+      totalEvents,
+      totalPendingRelays
+    };
+  }
+  clear() {
+    for (const bus of this.buses.values()) {
+      bus.cancelAll("manager_cleared");
+    }
+    this.buses.clear();
+  }
+};
+
+// src/sdkEventMapper.ts
+var logger7 = createModuleLogger("sdk.mapper");
+function getTaskBase(proc) {
+  const task = proc.currentTask;
+  if (!task) return null;
+  return {
+    agentId: proc.agentId,
+    conversationId: task.conversationId,
+    traceId: task.traceId,
+    replyMessageId: task.replyMessageId
+  };
+}
+function wireBase(base) {
+  return {
+    ackId: base.replyMessageId,
+    agentId: base.agentId,
+    conversationId: base.conversationId,
+    traceId: base.traceId
+  };
+}
+function extractUsage(message) {
+  const result = {};
+  if (message.usage) {
+    const u = message.usage;
+    if (typeof u.output_tokens === "number") result.tokenCount = u.output_tokens;
+    if (typeof u.input_tokens === "number") result.inputTokens = u.input_tokens;
+  }
+  if (typeof message.total_cost_usd === "number") {
+    result.costUsd = message.total_cost_usd;
+  }
+  if (message.modelUsage) {
+    const models = Object.keys(message.modelUsage);
+    if (models.length > 0) result.model = models[0];
+  }
+  return result;
+}
+function isGroupTask(proc) {
+  return proc.currentTask?.groupId != null;
+}
+function extractTodosFromInput(input) {
+  if (!input || typeof input !== "object") return null;
+  const raw = input.todos;
+  if (!Array.isArray(raw)) return null;
+  const out = [];
+  for (let i = 0; i < raw.length; i++) {
+    const item = raw[i];
+    if (!item || typeof item !== "object") continue;
+    const it = item;
+    if (typeof it.content !== "string") continue;
+    const id = typeof it.id === "string" ? it.id : `todo_${i}`;
+    const status = it.status === "in_progress" || it.status === "completed" || it.status === "cancelled" ? it.status : "pending";
+    out.push({ id, content: it.content, status });
+  }
+  return out;
+}
+function countByStatus(todos) {
+  const c = {
+    pending: 0,
+    in_progress: 0,
+    completed: 0,
+    cancelled: 0
+  };
+  for (const t of todos) {
+    c[t.status] = (c[t.status] ?? 0) + 1;
+  }
+  return c;
+}
+function emitGroupSegment(proc, emit, base, content, contentBlocks) {
+  const groupId = proc.currentTask?.groupId;
+  if (!groupId) return;
+  proc.segmentCount += 1;
+  logger7.info("Group segment emitted", {
+    agentId: base.agentId,
+    replyMessageId: base.replyMessageId,
+    groupId,
+    segmentIndex: proc.segmentCount,
+    contentLen: content.length,
+    blockCount: contentBlocks.length,
+    blockTypes: contentBlocks.map((b) => b.type),
+    contentSample: content.slice(0, 200),
+    traceId: base.traceId,
+    isAuditOnly: content.length === 0
+  });
+  emit({
+    type: "agent:segment",
+    payload: {
+      messageId: createMessageId(),
+      ...wireBase(base),
+      groupId,
+      content,
+      contentBlocks: [...contentBlocks]
+    }
+  });
+}
+function flushTextSegmentOnBlockStop(proc, emit, base) {
+  const trimmed = proc.segmentBuffer.trim();
+  if (trimmed.length > 0 && trimmed !== NO_REPLY_TOKEN) {
+    proc.contentBlocks.push({ type: "text", content: proc.segmentBuffer });
+    emitGroupSegment(proc, emit, base, proc.segmentBuffer, proc.contentBlocks);
+    proc.contentBlocks = [];
+  } else {
+    logger7.info("Group text block flushed but skipped (no segment emitted)", {
+      agentId: base.agentId,
+      replyMessageId: base.replyMessageId,
+      groupId: proc.currentTask?.groupId,
+      bufferLen: proc.segmentBuffer.length,
+      trimmedLen: trimmed.length,
+      reason: trimmed.length === 0 ? "empty" : "no_reply_token",
+      sample: proc.segmentBuffer.slice(0, 200),
+      traceId: base.traceId
+    });
+  }
+  proc.segmentBuffer = "";
+}
+function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
+  const emit = proc.internalRelayId ? (msg) => {
+    if (msg.type === "agent:status") rawEmit(msg);
+  } : rawEmit;
+  switch (message.type) {
+    case "system": {
+      if (message.subtype === "init") {
+        const initMsg = message;
+        proc.ccSessionId = initMsg.session_id;
+        sessionStore.set(proc.agentId, proc.scope, initMsg.session_id);
+        if (proc.status === "starting") {
+          proc.status = "ready";
+        }
+        logger7.info("Agent session initialized", {
+          agentId: proc.agentId,
+          scope: proc.scope.kind === "single" ? "single" : proc.scope.groupId,
+          sessionId: initMsg.session_id,
+          statusAfterInit: proc.status
+        });
+      }
+      break;
+    }
+    case "stream_event": {
+      const base = getTaskBase(proc);
+      if (!base) break;
+      const ev = message.event;
+      switch (ev.type) {
+        case "content_block_start": {
+          const block = ev.content_block;
+          if (!block) break;
+          if (block.type === "thinking") {
+            proc.currentBlockType = "thinking";
+            proc.accumulatedThinking = "";
+          } else if (block.type === "text") {
+            proc.currentBlockType = "text";
+            if (isGroupTask(proc)) {
+              proc.segmentBuffer = "";
+            }
+          } else if (block.type === "tool_use") {
+            proc.currentBlockType = "tool_use";
+            proc.currentToolName = block.name ?? "unknown";
+            proc.accumulatedToolInput = "";
+            const toolName = block.name ?? "unknown";
+            emit({
+              type: "agent:tool_use",
+              payload: {
+                ...wireBase(base),
+                toolName,
+                input: {}
+              }
+            });
+            proc.contentBlocks.push({
+              type: "tool_use",
+              toolName,
+              input: {},
+              status: "running"
+            });
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const delta = ev.delta;
+          if (!delta) break;
+          if (delta.type === "thinking_delta" && typeof delta.thinking === "string") {
+            proc.accumulatedThinking += delta.thinking;
+            emit({
+              type: "agent:thinking_chunk",
+              payload: { ...wireBase(base), chunk: delta.thinking }
+            });
+          } else if (delta.type === "input_json_delta") {
+            const partial = delta.partial_json;
+            if (typeof partial === "string") {
+              proc.accumulatedToolInput += partial;
+            }
+          } else if (delta.type === "text_delta" && typeof delta.text === "string") {
+            if (proc.accumulatedText.length === 0) {
+              logger7.info("Agent text stream started", {
+                agentId: proc.agentId,
+                replyMessageId: base.replyMessageId,
+                traceId: base.traceId,
+                groupMode: isGroupTask(proc)
+              });
+            }
+            proc.accumulatedText += delta.text;
+            if (isGroupTask(proc)) {
+              proc.segmentBuffer += delta.text;
+            } else {
+              emit({
+                type: "agent:text_chunk",
+                payload: { ...wireBase(base), chunk: delta.text }
+              });
+            }
+          }
+          break;
+        }
+        case "content_block_stop": {
+          if (proc.currentBlockType === "thinking") {
+            emit({
+              type: "agent:thinking_done",
+              payload: wireBase(getTaskBase(proc))
+            });
+            proc.contentBlocks.push({
+              type: "thinking",
+              content: proc.accumulatedThinking,
+              isComplete: true
+            });
+            proc.accumulatedThinking = "";
+          } else if (proc.currentBlockType === "text" && isGroupTask(proc)) {
+            flushTextSegmentOnBlockStop(proc, emit, base);
+          } else if (proc.currentBlockType === "tool_use") {
+            let parsedInput = {};
+            if (proc.accumulatedToolInput.length > 0) {
+              try {
+                parsedInput = JSON.parse(proc.accumulatedToolInput);
+              } catch {
+                logger7.warn("Failed to parse tool input JSON", {
+                  agentId: proc.agentId,
+                  toolName: proc.currentToolName,
+                  inputLen: proc.accumulatedToolInput.length,
+                  sample: proc.accumulatedToolInput.slice(0, 200)
+                });
+              }
+            }
+            const lastToolUse = [...proc.contentBlocks].reverse().find((bl) => bl.type === "tool_use");
+            if (lastToolUse && lastToolUse.type === "tool_use") {
+              lastToolUse.input = parsedInput;
+            }
+            if (proc.currentToolName === "TodoWrite") {
+              const todos = extractTodosFromInput(parsedInput);
+              if (todos) {
+                logger7.info("TodoWrite detected, emitting agent:todos_update", {
+                  agentId: proc.agentId,
+                  replyMessageId: base.replyMessageId,
+                  groupId: proc.currentTask?.groupId,
+                  todoCount: todos.length,
+                  statusBreakdown: countByStatus(todos),
+                  traceId: base.traceId
+                });
+                emit({
+                  type: "agent:todos_update",
+                  payload: {
+                    ...wireBase(base),
+                    groupId: proc.currentTask?.groupId,
+                    todos
+                  }
+                });
+              } else {
+                logger7.info("TodoWrite detected with empty/cancel todos", {
+                  agentId: proc.agentId,
+                  replyMessageId: base.replyMessageId,
+                  traceId: base.traceId
+                });
+                emit({
+                  type: "agent:todos_update",
+                  payload: {
+                    ...wireBase(base),
+                    groupId: proc.currentTask?.groupId,
+                    todos: []
+                  }
+                });
+              }
+            }
+            if (proc.currentToolName === "AskUserQuestion") {
+              const last = proc.contentBlocks[proc.contentBlocks.length - 1];
+              if (last?.type === "tool_use" && last.toolName === "AskUserQuestion") {
+                proc.contentBlocks.pop();
+              }
+            }
+            proc.accumulatedToolInput = "";
+          }
+          proc.currentBlockType = null;
+          break;
+        }
+        default:
+          break;
+      }
+      break;
+    }
+    case "user": {
+      const base = getTaskBase(proc);
+      if (!base) break;
+      const userMsg = message;
+      const content = userMsg.message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          const b = block;
+          if (b.type === "tool_result") {
+            const output = typeof b.content === "string" ? b.content : JSON.stringify(b.content);
+            emit({
+              type: "agent:tool_result",
+              payload: {
+                ...wireBase(base),
+                toolName: proc.currentToolName ?? "unknown",
+                output,
+                isError: !!b.is_error
+              }
+            });
+            proc.contentBlocks.push({
+              type: "tool_result",
+              toolName: proc.currentToolName ?? "unknown",
+              output,
+              isError: !!b.is_error
+            });
+            const lastToolUse = [...proc.contentBlocks].reverse().find((bl) => bl.type === "tool_use");
+            if (lastToolUse && lastToolUse.type === "tool_use") {
+              lastToolUse.status = b.is_error ? "error" : "done";
+            }
+          }
+        }
+      }
+      break;
+    }
+    case "result": {
+      const base = getTaskBase(proc);
+      if (!base) break;
+      const resultMsg = message;
+      let carrierMessageId;
+      if (resultMsg.subtype === "success") {
+        const successMsg = resultMsg;
+        const trimmed = proc.accumulatedText.trim();
+        const groupId = proc.currentTask?.groupId;
+        const groupMode = groupId != null;
+        const usage = extractUsage(successMsg);
+        if (trimmed === NO_REPLY_TOKEN) {
+          logger7.info("Agent chose not to reply", {
+            agentId: proc.agentId,
+            replyMessageId: base.replyMessageId,
+            traceId: base.traceId,
+            groupMode,
+            groupId,
+            fullTextLen: proc.accumulatedText.length,
+            fullTextSample: proc.accumulatedText.slice(0, 200),
+            accumulatedBlockCount: proc.contentBlocks.length,
+            accumulatedBlockTypes: proc.contentBlocks.map((b) => b.type)
+          });
+          emit({
+            type: "agent:no_reply",
+            payload: {
+              ...wireBase(base),
+              groupId,
+              reason: void 0
+            }
+          });
+          resetAccumulators(proc);
+          onCompleted();
+          break;
+        }
+        if (groupMode) {
+          if (usage.inputTokens && usage.inputTokens > 15e4) {
+            logger7.warn("Agent context window approaching limit", {
+              agentId: proc.agentId,
+              inputTokens: usage.inputTokens
+            });
+          }
+          if (proc.contentBlocks.length > 0) {
+            logger7.info("Group turn trailing audit segment", {
+              agentId: proc.agentId,
+              replyMessageId: base.replyMessageId,
+              blockCount: proc.contentBlocks.length,
+              traceId: base.traceId
+            });
+            emitGroupSegment(proc, emit, base, "", proc.contentBlocks);
+            proc.contentBlocks = [];
+          }
+          logger7.info("Group task turn complete", {
+            agentId: proc.agentId,
+            replyMessageId: base.replyMessageId,
+            groupId,
+            segmentCount: proc.segmentCount,
+            fullTextLen: proc.accumulatedText.length,
+            fullTextSample: proc.accumulatedText.slice(0, 200),
+            traceId: base.traceId
+          });
+          emit({
+            type: "agent:turn_complete",
+            payload: {
+              ...wireBase(base),
+              groupId,
+              segmentCount: proc.segmentCount
+            }
+          });
+          resetAccumulators(proc);
+          onCompleted();
+          break;
+        }
+        if (proc.accumulatedText) {
+          proc.contentBlocks.push({ type: "text", content: proc.accumulatedText });
+        }
+        if (usage.inputTokens && usage.inputTokens > 15e4) {
+          logger7.warn("Agent context window approaching limit", {
+            agentId: proc.agentId,
+            inputTokens: usage.inputTokens
+          });
+        }
+        carrierMessageId = createMessageId();
+        logger7.info("Agent task done, emitting agent:done", {
+          agentId: proc.agentId,
+          ackId: base.replyMessageId,
+          messageId: carrierMessageId,
+          textLen: proc.accumulatedText.length,
+          textSample: proc.accumulatedText.slice(0, 200),
+          tokenCount: usage.tokenCount,
+          traceId: base.traceId
+        });
+        emit({
+          type: "agent:done",
+          payload: {
+            ...wireBase(base),
+            messageId: carrierMessageId,
+            fullContent: proc.accumulatedText,
+            contentBlocks: proc.contentBlocks,
+            metadata: {
+              thinkingDuration: Date.now() - proc.currentTaskStartedAt,
+              toolCallCount: proc.contentBlocks.filter((b) => b.type === "tool_use").length,
+              tokenCount: usage.tokenCount,
+              model: usage.model
+            }
+          }
+        });
+      } else {
+        const errorMsg = resultMsg;
+        const errorText = errorMsg.errors?.join("; ") ?? `Agent error: ${resultMsg.subtype}`;
+        logger7.warn("Agent task error, emitting agent:error", {
+          agentId: proc.agentId,
+          replyMessageId: base.replyMessageId,
+          subtype: resultMsg.subtype,
+          errorText,
+          traceId: base.traceId
+        });
+        emit({
+          type: "agent:error",
+          payload: { ...wireBase(base), error: errorText }
+        });
+      }
+      resetAccumulators(proc);
+      onCompleted(carrierMessageId);
+      break;
+    }
+    case "assistant":
+      break;
+    default:
+      logger7.warn("Unhandled SDK message type", {
+        type: message.type,
+        agentId: proc.agentId
+      });
+      break;
+  }
+}
+function resetAccumulators(proc) {
+  proc.accumulatedText = "";
+  proc.accumulatedThinking = "";
+  proc.contentBlocks = [];
+  proc.currentBlockType = null;
+  proc.currentToolName = null;
+  proc.segmentBuffer = "";
+  proc.segmentCount = 0;
+  proc.accumulatedToolInput = "";
+}
+
+// src/agentManager.ts
+var logger8 = createModuleLogger("agent.manager");
+var BridgeBusyError = class extends Error {
+  constructor(message = "Bridge busy: cannot evict an idle Agent query; all slots are working") {
+    super(message);
+    this.name = "BridgeBusyError";
+  }
+};
+var AgentManager = class {
+  agents = /* @__PURE__ */ new Map();
+  lastUsedAt = /* @__PURE__ */ new Map();
+  sessionStore;
+  emit;
+  workspacesDir;
+  queryConfig;
+  askQuestionRegistry;
+  neuralBusManager;
+  groupRegistry;
+  evictionTimer = null;
+  // Lazy-loaded SDK query function. Injectable via constructor for tests.
+  queryFn = null;
+  constructor(sessionStore, emit, options) {
+    this.sessionStore = sessionStore;
+    this.emit = emit;
+    if (typeof options === "function") {
+      this.queryFn = options;
+      this.workspacesDir = path6.join(os4.homedir(), ".ahchat", "workspaces");
+      this.queryConfig = DEFAULT_QUERY_CONFIG;
+      this.askQuestionRegistry = new AskQuestionRegistry();
+      this.neuralBusManager = new NeuralBusManager();
+      this.groupRegistry = null;
+    } else {
+      this.queryFn = options?.queryFn ?? null;
+      this.workspacesDir = options?.workspacesDir ?? path6.join(os4.homedir(), ".ahchat", "workspaces");
+      this.queryConfig = options?.queryConfig ?? DEFAULT_QUERY_CONFIG;
+      this.askQuestionRegistry = options?.askQuestionRegistry ?? new AskQuestionRegistry();
+      this.neuralBusManager = options?.neuralBusManager ?? new NeuralBusManager();
+      this.groupRegistry = options?.groupRegistry ?? null;
+    }
+    this.evictionTimer = setInterval(() => {
+      void this.evictIdle();
+    }, this.queryConfig.evictionIntervalMs);
+  }
+  async getQueryFn() {
+    if (this.queryFn) return this.queryFn;
+    const sdk = await import("@anthropic-ai/claude-agent-sdk");
+    this.queryFn = sdk.query;
+    return this.queryFn;
+  }
+  /** Count live queries (anything not dead / removed). */
+  countActiveQueries() {
+    let n = 0;
+    for (const p of this.agents.values()) {
+      if (p.status !== "dead") n++;
+    }
+    return n;
+  }
+  asRuntime(proc) {
+    return proc;
+  }
+  async awaitQueryReturn(query, timeoutMs, agentId) {
+    const ret = query.return(void 0);
+    try {
+      await Promise.race([
+        ret,
+        new Promise((_, reject) => {
+          setTimeout(() => reject(new Error("query return timeout")), timeoutMs);
+        })
+      ]);
+    } catch (e) {
+      logger8.warn("awaitQueryReturn finished with error/timeout", { agentId, error: e });
+    }
+  }
+  /**
+   * Returns true when an agent process occupies a slot but is not actively doing work
+   * and can be safely evicted to free up capacity.
+   *
+   * Both 'ready' (warm, finished a task) and 'starting' (pre-warmed at recovery but
+   * never sent a message) qualify, as long as there are no injected tasks awaiting a turn.
+   */
+  isEvictable(proc) {
+    if (proc.status !== "ready" && proc.status !== "starting") return false;
+    const runtime = this.asRuntime(proc);
+    return runtime.injectedTasks.length === 0;
+  }
+  /**
+   * Close an idle/starting query: end generator and drop from map.
+   * Session id stays in SessionStore for resume (Phase 2 eviction).
+   */
+  async closeIdleQuery(key) {
+    const proc = this.agents.get(key);
+    if (!proc || proc.status === "dead") return;
+    if (!this.isEvictable(proc)) return;
+    logger8.info("Evicting idle Agent query", { agentId: proc.agentId, scope: scopeKey(proc.scope) });
+    const runtime = this.asRuntime(proc);
+    try {
+      runtime.inputController.close();
+      await this.awaitQueryReturn(runtime.query, 5e3, proc.agentId);
+    } catch (e) {
+      logger8.error("closeIdleQuery failed", { agentId: proc.agentId, error: e });
+    }
+    proc.status = "dead";
+    this.agents.delete(key);
+    this.lastUsedAt.delete(key);
+  }
+  /** Evict LRU among idle (ready/starting + no injected tasks) agents past the idle timeout. */
+  evictIdle() {
+    const now = Date.now();
+    const { idleTimeoutMs } = this.queryConfig;
+    for (const [key, proc] of this.agents) {
+      if (!this.isEvictable(proc)) continue;
+      const runtime = this.asRuntime(proc);
+      const last = this.lastUsedAt.get(key) ?? runtime.createdAt ?? 0;
+      if (now - last <= idleTimeoutMs) continue;
+      void this.closeIdleQuery(key);
+    }
+  }
+  /**
+   * Evict one LRU candidate to make room for a new query. Returns false if none evictable.
+   */
+  async evictOneLruReadyIdle() {
+    let bestKey = null;
+    let bestTs = Number.POSITIVE_INFINITY;
+    for (const [key, proc] of this.agents) {
+      if (!this.isEvictable(proc)) continue;
+      const runtime = this.asRuntime(proc);
+      const ts = this.lastUsedAt.get(key) ?? runtime.createdAt ?? 0;
+      if (ts < bestTs) {
+        bestTs = ts;
+        bestKey = key;
+      }
+    }
+    if (!bestKey) return false;
+    await this.closeIdleQuery(bestKey);
+    return true;
+  }
+  /**
+   * Ensure an Agent query exists (respecting maxActive via LRU eviction of idle queries).
+   */
+  async acquire(agentConfig, scope, cwd) {
+    const key = runtimeKey(agentConfig.id, scope);
+    const existing = this.agents.get(key);
+    if (existing && existing.status !== "dead") {
+      this.lastUsedAt.set(key, Date.now());
+      return existing;
+    }
+    while (this.countActiveQueries() >= this.queryConfig.maxActive) {
+      const evicted = await this.evictOneLruReadyIdle();
+      if (!evicted) {
+        throw new BridgeBusyError();
+      }
+    }
+    const proc = await this.getOrCreate(agentConfig, scope, cwd);
+    this.lastUsedAt.set(key, Date.now());
+    return proc;
+  }
+  async getOrCreate(agentConfig, scope, cwd) {
+    const key = runtimeKey(agentConfig.id, scope);
+    const existing = this.agents.get(key);
+    if (existing && existing.status !== "dead") {
+      return existing;
+    }
+    const savedSessionId = this.sessionStore.get(agentConfig.id, scope);
+    const inputController = new InputController();
+    const agentCwd = cwd;
+    await fs2.mkdir(agentCwd, { recursive: true });
+    const cfg = parseAgentConfig(agentConfig.config);
+    logger8.info("Creating Agent query", {
+      agentId: agentConfig.id,
+      scope: scopeKey(scope),
+      cwd: agentCwd,
+      resume: !!savedSessionId,
+      sessionId: savedSessionId,
+      model: cfg.model ?? "(default)"
+    });
+    const queryFn = await this.getQueryFn();
+    let procRef = null;
+    const cwdGuard = makeCwdPermissionGuard(agentCwd, agentConfig.id, scope, (msg, meta) => {
+      logger8.warn(msg, meta);
+    });
+    const askGuard = makeAskUserQuestionGuard({
+      agentId: agentConfig.id,
+      scope,
+      registry: this.askQuestionRegistry,
+      getCurrentTask: () => procRef?.currentTask ?? null,
+      emit: this.emit
+    });
+    const neuralServer = await createNeuralMcpServer({
+      agentId: agentConfig.id,
+      scope,
+      neuralBusManager: this.neuralBusManager,
+      groupRegistry: this.groupRegistry,
+      onRelayCreated: (relayId, toScope) => {
+        this.processRelayWakeup(agentConfig, toScope, relayId);
+      }
+    });
+    const options = {
+      cwd: agentCwd,
+      systemPrompt: {
+        type: "preset",
+        preset: "claude_code",
+        append: [PLATFORM_AGENT_RULES, agentConfig.systemPrompt].filter((s) => typeof s === "string" && s.trim().length > 0).join("\n\n")
+      },
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      allowedTools: [
+        "Read",
+        "Edit",
+        "Write",
+        "Bash",
+        "Glob",
+        "Grep",
+        "AskUserQuestion",
+        "mcp__neural__neural_recall",
+        "mcp__neural__neural_relay"
+      ],
+      mcpServers: { neural: neuralServer },
+      includePartialMessages: true,
+      canUseTool: async (toolName, input) => {
+        if (toolName === "AskUserQuestion") {
+          return askGuard(input);
+        }
+        return cwdGuard(toolName, input);
+      }
+    };
+    const userPromptTrimmed = (agentConfig.systemPrompt ?? "").trim();
+    const appendStr = options.systemPrompt.append;
+    logger8.info("Platform rules attached", {
+      agentId: agentConfig.id,
+      scope: scopeKey(scope),
+      platformRulesLen: PLATFORM_AGENT_RULES.length,
+      userPromptLen: userPromptTrimmed.length,
+      hasUserPrompt: userPromptTrimmed.length > 0,
+      appendLen: appendStr.length
+    });
+    if (cfg.model) {
+      options.model = cfg.model;
+    }
+    if (savedSessionId) {
+      options.resume = savedSessionId;
+    }
+    const agentQuery = queryFn({
+      prompt: inputController,
+      options
+    });
+    const proc = {
+      agentId: agentConfig.id,
+      scope,
+      cwd: agentCwd,
+      ccSessionId: savedSessionId,
+      status: "starting",
+      currentTask: null,
+      currentTaskStartedAt: 0,
+      accumulatedThinking: "",
+      accumulatedText: "",
+      contentBlocks: [],
+      currentBlockType: null,
+      currentToolName: null,
+      segmentBuffer: "",
+      segmentCount: 0,
+      accumulatedToolInput: ""
+    };
+    const runtime = Object.assign(proc, {
+      query: agentQuery,
+      inputController,
+      injectedTasks: [],
+      mergedTasks: [],
+      createdAt: Date.now()
+    });
+    procRef = proc;
+    this.agents.set(key, proc);
+    this.consumeOutput(runtime);
+    return proc;
+  }
+  async sendMessage(task) {
+    const key = runtimeKey(task.agentId, task.scope);
+    const proc = this.agents.get(key);
+    if (!proc || proc.status === "dead") {
+      throw new Error(`Agent ${task.agentId} process not available`);
+    }
+    const runtime = this.asRuntime(proc);
+    if (proc.status === "ready") {
+      this.dispatchToSDK(runtime, task);
+      return;
+    }
+    if (proc.status === "starting") {
+      logger8.info("Message dispatched to starting Agent (kickstart)", {
+        agentId: task.agentId,
+        replyMessageId: task.replyMessageId,
+        traceId: task.traceId
+      });
+      this.dispatchToSDK(runtime, task);
+      return;
+    }
+    const onYielded = () => {
+      const idx = runtime.injectedTasks.indexOf(task);
+      if (idx >= 0) {
+        runtime.injectedTasks.splice(idx, 1);
+        runtime.mergedTasks.push(task);
+        logger8.info("Injected task consumed by SDK (queued as merged until next result)", {
+          agentId: runtime.agentId,
+          replyMessageId: task.replyMessageId,
+          traceId: task.traceId,
+          mergedQueueSize: runtime.mergedTasks.length,
+          currentTaskReplyMessageId: runtime.currentTask?.replyMessageId
+        });
+      }
+    };
+    runtime.inputController.push(task.content, runtime.ccSessionId ?? "", onYielded);
+    runtime.injectedTasks.push(task);
+    logger8.info("Message injected while Agent working", {
+      agentId: task.agentId,
+      replyMessageId: task.replyMessageId,
+      currentStatus: proc.status,
+      injectedDepth: runtime.injectedTasks.length,
+      traceId: task.traceId
+    });
+  }
+  dispatchToSDK(runtime, task) {
+    runtime.status = "working";
+    runtime.currentTask = task;
+    runtime.currentTaskStartedAt = Date.now();
+    let content = task.content;
+    const bus = this.neuralBusManager.get(runtime.agentId);
+    if (bus) {
+      const digest = bus.queryDigest(scopeKey(runtime.scope), 30 * 6e4);
+      if (digest.length > 0) {
+        const prefix = formatDigestPrefix(digest);
+        content = prefix + "\n\n" + content;
+      }
+    }
+    runtime.inputController.push(content, runtime.ccSessionId ?? "");
+    logger8.info("Message pushed to Agent", {
+      agentId: runtime.agentId,
+      replyMessageId: task.replyMessageId,
+      traceId: task.traceId
+    });
+  }
+  resetProcAccumulators(proc) {
+    proc.accumulatedText = "";
+    proc.accumulatedThinking = "";
+    proc.contentBlocks = [];
+    proc.currentBlockType = null;
+    proc.currentToolName = null;
+    proc.segmentBuffer = "";
+    proc.segmentCount = 0;
+  }
+  onTaskCompleted(proc, carrierMessageId) {
+    const runtime = this.asRuntime(proc);
+    const completedTask = proc.currentTask;
+    if (completedTask && runtime.mergedTasks.length > 0) {
+      const mergedBatch = [...runtime.mergedTasks];
+      logger8.info("Flushing merged tasks after result", {
+        agentId: proc.agentId,
+        carrierReplyMessageId: completedTask.replyMessageId,
+        mergedCount: mergedBatch.length,
+        mergedReplyMessageIds: mergedBatch.map((t) => t.replyMessageId),
+        traceId: completedTask.traceId
+      });
+      for (const merged of mergedBatch) {
+        logger8.info("Emitting agent:merged for task consumed in same turn", {
+          agentId: proc.agentId,
+          ackId: merged.replyMessageId,
+          mergedIntoAckId: completedTask.replyMessageId,
+          mergedIntoMessageId: carrierMessageId,
+          traceId: merged.traceId
+        });
+        this.emit({
+          type: "agent:merged",
+          payload: {
+            agentId: proc.agentId,
+            conversationId: merged.conversationId,
+            ackId: merged.replyMessageId,
+            mergedIntoAckId: completedTask.replyMessageId,
+            mergedIntoMessageId: carrierMessageId,
+            groupId: merged.groupId,
+            traceId: merged.traceId
+          }
+        });
+      }
+      runtime.mergedTasks = [];
+    } else if (runtime.mergedTasks.length > 0) {
+      logger8.warn("mergedTasks non-empty but no currentTask; dropping", {
+        agentId: proc.agentId,
+        mergedCount: runtime.mergedTasks.length
+      });
+      runtime.mergedTasks = [];
+    }
+    if (runtime.injectedTasks.length > 0) {
+      const next = runtime.injectedTasks.shift();
+      this.resetProcAccumulators(proc);
+      proc.currentTask = next;
+      proc.status = "working";
+      proc.currentTaskStartedAt = Date.now();
+      logger8.info("Promoted next injected task after result", {
+        agentId: proc.agentId,
+        replyMessageId: next.replyMessageId,
+        remainingInjected: runtime.injectedTasks.length,
+        traceId: next.traceId
+      });
+      return;
+    }
+    proc.currentTask = null;
+    proc.status = "ready";
+    this.lastUsedAt.set(runtimeKey(proc.agentId, proc.scope), Date.now());
+    if (proc.internalRelayId) {
+      const bus = this.neuralBusManager.get(proc.agentId);
+      if (bus) {
+        const response = proc.accumulatedText || "[\u76EE\u6807\u5BF9\u8BDD\u672A\u4EA7\u51FA\u5185\u5BB9]";
+        const resolved = bus.resolveRelay(proc.internalRelayId, response);
+        if (resolved) {
+          logger8.info("Internal relay resolved on task completion", {
+            agentId: proc.agentId,
+            relayId: proc.internalRelayId,
+            scope: scopeKey(proc.scope),
+            responseLen: response.length
+          });
+        } else {
+          logger8.info("External relay task completed (output suppressed, published to journal)", {
+            agentId: proc.agentId,
+            relayId: proc.internalRelayId,
+            scope: scopeKey(proc.scope),
+            responseLen: response.length
+          });
+        }
+      }
+      proc.internalRelayId = void 0;
+    }
+    const summary = extractTurnSummary(proc.accumulatedText);
+    if (summary) {
+      const bus = this.neuralBusManager.getOrCreate(proc.agentId);
+      bus.publish(scopeKey(proc.scope), summary, proc.accumulatedText?.slice(0, 2e3));
+    }
+  }
+  getQueryStatus(bridgeId) {
+    const queries = [...this.agents.entries()].map(([key, proc]) => ({
+      agentId: proc.agentId,
+      status: proc.status,
+      ccSessionId: proc.ccSessionId,
+      lastActiveAt: new Date(this.lastUsedAt.get(key) ?? 0).toISOString()
+    }));
+    const activeCount = [...this.agents.values()].filter((p) => p.status !== "dead").length;
+    return {
+      type: "bridge:query_status",
+      payload: {
+        bridgeId,
+        queries,
+        activeCount,
+        maxActive: this.queryConfig.maxActive,
+        bridgeMemoryMB: Math.round(process.memoryUsage().rss / 1024 / 1024)
+      }
+    };
+  }
+  /**
+   * Process a relay wakeup: acquire or dispatch to the target scope.
+   * Called by the NeuralRelay MCP tool's onRelayCreated callback.
+   */
+  processRelayWakeup(agentConfig, toScopeKey, relayId) {
+    const bus = this.neuralBusManager.getOrCreate(agentConfig.id);
+    const relay = bus.consumeRelay(toScopeKey);
+    if (!relay) return;
+    const effectiveGroupId = relay.groupId || toScopeKey.replace("group:", "");
+    const scope = toScopeKey === "single" ? { kind: "single" } : { kind: "group", groupId: effectiveGroupId };
+    this.sessionStore.delete(agentConfig.id, scope);
+    const key = runtimeKey(agentConfig.id, scope);
+    const existingProc = this.agents.get(key);
+    const suppressEmit = relay.mode === "internal" ? relayId : void 0;
+    const task = {
+      content: `[\u795E\u7ECF\u4E2D\u7EE7\u6D88\u606F \u2014 \u6765\u81EA\u4F60\u7684${formatScopeLabel(relay.fromScope)}\u5206\u8EAB]
+${relay.message}`,
+      replyMessageId: `msg_relay_${relayId}`,
+      conversationId: relay.conversationId || "",
+      traceId: `tr_relay_${relayId}`,
+      groupId: relay.groupId
+    };
+    logger8.info("Relay wakeup processing", {
+      agentId: agentConfig.id,
+      toScope: toScopeKey,
+      relayId,
+      mode: relay.mode,
+      conversationId: relay.conversationId ?? "(none)",
+      groupId: relay.groupId ?? "(none)",
+      suppressEmit: !!suppressEmit
+    });
+    if (existingProc && existingProc.status !== "dead") {
+      if (suppressEmit) existingProc.internalRelayId = suppressEmit;
+      if (existingProc.status === "ready" || existingProc.status === "starting") {
+        const runtime = this.asRuntime(existingProc);
+        this.dispatchToSDK(runtime, task);
+      } else {
+        const runtime = this.asRuntime(existingProc);
+        runtime.inputController.push(task.content, runtime.ccSessionId ?? "");
+        runtime.injectedTasks.push(task);
+      }
+      logger8.info("Relay wakeup dispatched to existing runtime", {
+        agentId: agentConfig.id,
+        toScope: toScopeKey,
+        relayId,
+        mode: relay.mode,
+        status: existingProc.status
+      });
+    } else {
+      const cwd = agentConfig.workingDirectory || path6.join(this.workspacesDir, agentConfig.id);
+      void this.acquire(agentConfig, scope, cwd).then((proc) => {
+        if (suppressEmit) proc.internalRelayId = suppressEmit;
+        return this.sendMessage({ ...task, agentId: agentConfig.id, scope });
+      }).catch((err) => {
+        logger8.error("Relay wakeup acquire failed", {
+          agentId: agentConfig.id,
+          toScope: toScopeKey,
+          relayId,
+          error: err
+        });
+        if (relay.mode === "internal") {
+          bus.resolveRelay(relayId, `[\u4E2D\u7EE7\u6267\u884C\u5931\u8D25\uFF1A${err.message}]`);
+        }
+      });
+    }
+  }
+  /**
+   * Hard-remove all scoped runtimes for an Agent (agent:terminate on delete).
+   */
+  async terminate(agentId) {
+    const keys = [...this.agents.keys()].filter(
+      (k) => k === agentId || k.startsWith(`${agentId}::`)
+    );
+    if (keys.length === 0) {
+      logger8.warn("terminate: no process for agent", { agentId });
+      this.sessionStore.deleteAllForAgent(agentId);
+      return;
+    }
+    for (const key of keys) {
+      const proc = this.agents.get(key);
+      if (proc) {
+        await this.closeRuntime(proc, "terminate");
+      }
+    }
+    this.sessionStore.deleteAllForAgent(agentId);
+    this.neuralBusManager.remove(agentId);
+    logger8.info("terminate: all scoped queries removed", { agentId, count: keys.length });
+  }
+  /** Stop one scoped SDK runtime (workdir change). */
+  async terminateScope(agentId, scope) {
+    const key = runtimeKey(agentId, scope);
+    const proc = this.agents.get(key);
+    if (!proc) {
+      logger8.info("terminateScope: no active runtime", { agentId, scope: scopeKey(scope) });
+      return;
+    }
+    await this.closeRuntime(proc, "terminateScope");
+    this.sessionStore.delete(agentId, scope);
+    logger8.info("terminateScope: scoped query removed", { agentId, scope: scopeKey(scope) });
+  }
+  async closeRuntime(proc, reason) {
+    const key = runtimeKey(proc.agentId, proc.scope);
+    const runtime = this.asRuntime(proc);
+    const { agentId } = proc;
+    const emitInterrupted = (task) => {
+      this.emit({
+        type: "agent:error",
+        payload: {
+          agentId,
+          conversationId: task.conversationId,
+          replyMessageId: task.replyMessageId,
+          traceId: task.traceId,
+          error: "\u5BF9\u8BDD\u88AB\u4E2D\u65AD"
+        }
+      });
+    };
+    if (runtime.status === "working" && runtime.currentTask) {
+      emitInterrupted(runtime.currentTask);
+    }
+    const queued = [...runtime.injectedTasks];
+    runtime.injectedTasks = [];
+    for (const t of queued) {
+      emitInterrupted(t);
+    }
+    const mergedAtClose = [...runtime.mergedTasks];
+    runtime.mergedTasks = [];
+    for (const t of mergedAtClose) {
+      if (runtime.currentTask) {
+        logger8.info("Emitting agent:merged on runtime close", {
+          agentId: runtime.agentId,
+          replyMessageId: t.replyMessageId,
+          mergedInto: runtime.currentTask.replyMessageId,
+          reason,
+          traceId: t.traceId
+        });
+        this.emit({
+          type: "agent:merged",
+          payload: {
+            agentId: runtime.agentId,
+            conversationId: t.conversationId,
+            ackId: t.replyMessageId,
+            mergedIntoAckId: runtime.currentTask.replyMessageId,
+            groupId: t.groupId,
+            traceId: t.traceId
+          }
+        });
+      } else {
+        emitInterrupted(t);
+      }
+    }
+    runtime.currentTask = null;
+    try {
+      runtime.inputController.close();
+      await this.awaitQueryReturn(runtime.query, 5e3, agentId);
+    } catch (e) {
+      logger8.error(`${reason}: close query failed`, { agentId, scope: scopeKey(proc.scope), error: e });
+    }
+    proc.status = "dead";
+    this.agents.delete(key);
+    this.lastUsedAt.delete(key);
+    logger8.info(`${reason}: keeping workspace dir intact (per project policy)`, {
+      agentId,
+      scope: scopeKey(proc.scope),
+      cwd: proc.cwd
+    });
+  }
+  async recoverFromRestart(agents) {
+    logger8.info("Recovering Agent sessions after restart", { count: agents.length });
+    const agentsWithSession = agents.filter((a) => {
+      const sessionId = this.sessionStore.get(a.id, { kind: "single" });
+      return !!sessionId;
+    });
+    if (agentsWithSession.length === 0) {
+      logger8.info("No Agent sessions to recover");
+      return;
+    }
+    let warmed = 0;
+    const cap = this.queryConfig.maxActive;
+    for (const agent of agentsWithSession) {
+      if (warmed >= cap) {
+        logger8.info("Recovery warm cap reached", { cap, skipped: agentsWithSession.length - warmed });
+        break;
+      }
+      try {
+        const cwd = agent.workingDirectory || path6.join(this.workspacesDir, agent.id);
+        await this.acquire(agent, { kind: "single" }, cwd);
+        warmed++;
+        logger8.info("Agent process pre-created for recovery", { agentId: agent.id });
+      } catch (err) {
+        if (err instanceof BridgeBusyError) {
+          logger8.warn("Recovery stopped: bridge busy", { agentId: agent.id });
+          break;
+        }
+        logger8.warn("Failed to pre-create Agent for recovery, clearing session", {
+          agentId: agent.id,
+          error: err
+        });
+        this.sessionStore.delete(agent.id, { kind: "single" });
+      }
+    }
+  }
+  async consumeOutput(runtime) {
+    try {
+      for await (const message of runtime.query) {
+        const t = typeof message.type === "string" ? message.type : "unknown";
+        wsMetrics.incSdkOut(t);
+        mapSDKMessage(
+          runtime,
+          message,
+          this.emit,
+          this.sessionStore,
+          (doneMessageId) => this.onTaskCompleted(runtime, doneMessageId)
+        );
+      }
+    } catch (err) {
+      const errMsg = err.message ?? String(err);
+      const isResumeFail = /session|conversation.*not found/i.test(errMsg);
+      logger8.error("Agent query stream ended with error", {
+        agentId: runtime.agentId,
+        scope: scopeKey(runtime.scope),
+        isResumeFail,
+        staleSessionId: runtime.ccSessionId,
+        error: err
+      });
+      this.sessionStore.delete(runtime.agentId, runtime.scope);
+      logger8.info("Cleared stale session after query crash", {
+        agentId: runtime.agentId,
+        scope: scopeKey(runtime.scope)
+      });
+      runtime.status = "dead";
+      const key = runtimeKey(runtime.agentId, runtime.scope);
+      this.agents.delete(key);
+      this.lastUsedAt.delete(key);
+      const errorText = isResumeFail ? `\u4F1A\u8BDD\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u53D1\u9001\u6D88\u606F\uFF08${errMsg}\uFF09` : `Agent query crashed: ${errMsg}`;
+      if (runtime.currentTask) {
+        this.emit({
+          type: "agent:error",
+          payload: {
+            agentId: runtime.agentId,
+            conversationId: runtime.currentTask.conversationId,
+            ackId: runtime.currentTask.replyMessageId,
+            traceId: runtime.currentTask.traceId,
+            error: errorText
+          }
+        });
+        runtime.currentTask = null;
+      }
+      for (const task of runtime.injectedTasks) {
+        this.emit({
+          type: "agent:error",
+          payload: {
+            agentId: runtime.agentId,
+            conversationId: task.conversationId,
+            ackId: task.replyMessageId,
+            traceId: task.traceId,
+            error: errorText
+          }
+        });
+      }
+      runtime.injectedTasks = [];
+      for (const task of runtime.mergedTasks) {
+        this.emit({
+          type: "agent:error",
+          payload: {
+            agentId: runtime.agentId,
+            conversationId: task.conversationId,
+            ackId: task.replyMessageId,
+            traceId: task.traceId,
+            error: errorText
+          }
+        });
+      }
+      runtime.mergedTasks = [];
+    }
+  }
+  getStatus(agentId, scope = { kind: "single" }) {
+    return this.agents.get(runtimeKey(agentId, scope))?.status ?? null;
+  }
+  getManagedAgentIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (const key of this.agents.keys()) {
+      const agentId = key.includes("::") ? key.split("::")[0] : key;
+      ids.add(agentId);
+    }
+    return [...ids];
+  }
+  async shutdownAll() {
+    logger8.info("Shutting down all Agent processes", { count: this.agents.size });
+    this.askQuestionRegistry.cancelAll("agent_aborted");
+    if (this.evictionTimer) {
+      clearInterval(this.evictionTimer);
+      this.evictionTimer = null;
+    }
+    for (const [key, proc] of this.agents) {
+      try {
+        const runtime = this.asRuntime(proc);
+        runtime.inputController?.close();
+        runtime.query?.return(void 0);
+        proc.status = "dead";
+        logger8.info("Agent process shut down", { agentId: proc.agentId, scope: scopeKey(proc.scope), key });
+      } catch (err) {
+        logger8.error("Error shutting down Agent", { agentId: proc.agentId, error: err });
+      }
+    }
+    this.agents.clear();
+    this.lastUsedAt.clear();
+  }
+  async cancelReply(payload) {
+    const { agentId, replyMessageId, traceId, conversationId } = payload;
+    let proc;
+    for (const p of this.agents.values()) {
+      if (p.agentId !== agentId || p.status === "dead") continue;
+      if (p.currentTask?.replyMessageId === replyMessageId) {
+        proc = p;
+        break;
+      }
+    }
+    if (!proc) {
+      logger8.warn("cancelReply: no active process for reply", { agentId, replyMessageId });
+      return;
+    }
+    const runtime = this.asRuntime(proc);
+    const key = runtimeKey(agentId, proc.scope);
+    if (!runtime.currentTask || runtime.currentTask.replyMessageId !== replyMessageId) {
+      logger8.warn("cancelReply: replyMessageId mismatch", {
+        agentId,
+        replyMessageId,
+        expected: runtime.currentTask?.replyMessageId
+      });
+      return;
+    }
+    const emitCancelled = (task) => {
+      this.emit({
+        type: "agent:error",
+        payload: {
+          agentId,
+          conversationId: task.conversationId,
+          ackId: task.replyMessageId,
+          traceId: task.traceId,
+          error: "\u5DF2\u53D6\u6D88"
+        }
+      });
+    };
+    emitCancelled(runtime.currentTask);
+    const queued = [...runtime.injectedTasks];
+    runtime.injectedTasks = [];
+    for (const t of queued) {
+      emitCancelled(t);
+    }
+    runtime.currentTask = null;
+    proc.status = "dead";
+    this.agents.delete(key);
+    this.lastUsedAt.delete(key);
+    logger8.info("cancelReply: process torn down", {
+      agentId,
+      scope: scopeKey(proc.scope),
+      conversationId,
+      traceId
+    });
+    try {
+      runtime.inputController.close();
+    } catch (err) {
+      logger8.error("cancelReply: inputController.close failed", { agentId, error: err });
+    }
+    runtime.query.return(void 0).catch((err) => {
+      logger8.warn("cancelReply: query.return threw", { agentId, error: err });
+    });
+  }
+};
+
+// src/agentRegistry.ts
+var logger9 = createModuleLogger("agent.registry");
+var HttpAgentRegistry = class {
+  constructor(serverApiUrl) {
+    this.serverApiUrl = serverApiUrl;
+  }
+  serverApiUrl;
+  agents = /* @__PURE__ */ new Map();
+  apiUrl(suffix) {
+    const base = this.serverApiUrl.replace(/\/$/, "");
+    const path10 = suffix.startsWith("/") ? suffix : `/${suffix}`;
+    return `${base}${path10}`;
+  }
+  async refresh() {
+    try {
+      const res = await fetch(this.apiUrl("/api/agents"));
+      if (!res.ok) {
+        logger9.warn("Agent registry refresh failed", { status: res.status });
+        return;
+      }
+      const body = await res.json();
+      if (!Array.isArray(body)) {
+        logger9.warn("Agent registry refresh: expected array");
+        return;
+      }
+      this.agents.clear();
+      for (const item of body) {
+        const a = item;
+        if (a && typeof a.id === "string") {
+          this.agents.set(a.id, a);
+        }
+      }
+      logger9.info("Agent registry refreshed", { count: this.agents.size });
+    } catch (e) {
+      logger9.warn("Agent registry refresh unreachable, keeping cache", { error: e });
+    }
+  }
+  getById(id) {
+    return this.agents.get(id) ?? null;
+  }
+  /**
+   * Fetch a single agent directly from the server and upsert into cache.
+   * Used as a fallback when task:dispatch arrives before agent:created WS push.
+   */
+  async fetchById(id) {
+    try {
+      const res = await fetch(this.apiUrl(`/api/agents/${encodeURIComponent(id)}`));
+      if (!res.ok) {
+        logger9.warn("fetchById failed", { agentId: id, status: res.status });
+        return null;
+      }
+      const agent = await res.json();
+      if (agent && typeof agent.id === "string") {
+        this.agents.set(agent.id, agent);
+        logger9.info("Agent registry fetchById upserted", { agentId: id });
+      }
+      return agent;
+    } catch (e) {
+      logger9.warn("fetchById unreachable", { agentId: id, error: e });
+      return null;
+    }
+  }
+  getAll() {
+    return [...this.agents.values()];
+  }
+  upsert(agent) {
+    this.agents.set(agent.id, agent);
+    logger9.debug("Agent registry upsert", { agentId: agent.id });
+  }
+  remove(agentId) {
+    this.agents.delete(agentId);
+    logger9.debug("Agent registry remove", { agentId });
+  }
+};
+
+// src/groupRegistry.ts
+var logger10 = createModuleLogger("neural.groupRegistry");
+var GroupRegistry = class {
+  groups = /* @__PURE__ */ new Map();
+  serverApiUrl;
+  constructor(serverApiUrl) {
+    this.serverApiUrl = serverApiUrl.replace(/\/$/, "");
+  }
+  async refresh() {
+    try {
+      const res = await fetch(`${this.serverApiUrl}/api/groups`);
+      if (!res.ok) {
+        logger10.warn("GroupRegistry refresh failed", { status: res.status });
+        return;
+      }
+      const body = await res.json();
+      if (!Array.isArray(body)) {
+        logger10.warn("GroupRegistry refresh: expected array");
+        return;
+      }
+      this.groups.clear();
+      for (const item of body) {
+        const g = item;
+        if (g && typeof g.id === "string") {
+          this.groups.set(g.id, {
+            groupId: g.id,
+            name: g.name ?? "",
+            conversationId: null,
+            members: (g.members ?? []).filter((m) => typeof m.agentId === "string").map((m) => m.agentId)
+          });
+        }
+      }
+      logger10.info("GroupRegistry refreshed", { count: this.groups.size });
+    } catch (e) {
+      logger10.warn("GroupRegistry refresh unreachable", { error: e });
+    }
+  }
+  getById(groupId) {
+    return this.groups.get(groupId) ?? null;
+  }
+  /**
+   * Fuzzy match by name (case-insensitive substring).
+   * Returns the first match.
+   */
+  resolveByName(name) {
+    const lower = name.toLowerCase().trim();
+    if (!lower) return null;
+    for (const g of this.groups.values()) {
+      if (g.name.toLowerCase().includes(lower)) return g;
+    }
+    return null;
+  }
+  /**
+   * Resolve a target_scope string to a proper scope with groupId and conversationId.
+   *
+   * Accepts:
+   * - "group:grp_xxx" — direct ID lookup
+   * - "group:方圆宝产品讨论组" — fuzzy name match
+   * - "single" — returns null (not a group)
+   *
+   * Fetches conversationId from Server if not cached.
+   */
+  async resolveScope(rawScope) {
+    if (!rawScope.startsWith("group:")) {
+      return null;
+    }
+    const suffix = rawScope.slice(6);
+    if (suffix.startsWith("grp_")) {
+      const info2 = this.groups.get(suffix);
+      if (!info2) {
+        logger10.info("GroupRegistry resolveScope: ID not found in cache", { rawScope, suffix });
+        return null;
+      }
+      const conversationId2 = await this.fetchConversationId(info2.groupId);
+      if (!conversationId2) return null;
+      return {
+        groupId: info2.groupId,
+        scopeKey: `group:${info2.groupId}`,
+        conversationId: conversationId2,
+        groupName: info2.name
+      };
+    }
+    const info = this.resolveByName(suffix);
+    if (!info) {
+      logger10.info("GroupRegistry resolveScope: name not found", { rawScope, searchName: suffix });
+      return null;
+    }
+    const conversationId = await this.fetchConversationId(info.groupId);
+    if (!conversationId) return null;
+    logger10.info("GroupRegistry resolved scope", {
+      rawScope,
+      resolvedGroupId: info.groupId,
+      resolvedName: info.name,
+      conversationId
+    });
+    return {
+      groupId: info.groupId,
+      scopeKey: `group:${info.groupId}`,
+      conversationId,
+      groupName: info.name
+    };
+  }
+  async fetchConversationId(groupId) {
+    try {
+      const res = await fetch(`${this.serverApiUrl}/api/groups/resolve?name=${encodeURIComponent(groupId)}&byId=1`);
+      if (!res.ok) {
+        logger10.warn("GroupRegistry fetchConversationId failed", { groupId, status: res.status });
+        return null;
+      }
+      const data = await res.json();
+      if (!data.conversationId) {
+        logger10.warn("GroupRegistry fetchConversationId: no conversationId", { groupId });
+        return null;
+      }
+      return data.conversationId;
+    } catch (e) {
+      logger10.error("GroupRegistry fetchConversationId error", { groupId, error: e });
+      return null;
+    }
+  }
+  getAll() {
+    return [...this.groups.values()];
+  }
+};
+
+// src/connector.ts
+import WebSocket from "ws";
+var logger11 = createModuleLogger("ws.connector");
+var ServerConnector = class {
+  ws = null;
+  reconnectAttempts = 0;
+  delays = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+  reconnectTimer = null;
+  closing = false;
+  config;
+  agentIds;
+  onTaskDispatch;
+  onGroupTaskDispatch;
+  onStopGeneration;
+  onConnected;
+  onServerPush;
+  constructor(params) {
+    this.config = params.config;
+    this.agentIds = params.agentIds;
+    this.onTaskDispatch = params.onTaskDispatch;
+    this.onGroupTaskDispatch = params.onGroupTaskDispatch;
+    this.onStopGeneration = params.onStopGeneration;
+    this.onConnected = params.onConnected;
+    this.onServerPush = params.onServerPush;
+  }
+  connect() {
+    if (this.closing) return;
+    logger11.info("Connecting to server", { url: this.config.serverUrl });
+    const ws = new WebSocket(this.config.serverUrl);
+    ws.on("open", () => {
+      this.ws = ws;
+      this.reconnectAttempts = 0;
+      logger11.info("Connected to server", { url: this.config.serverUrl });
+      void this.handleOpen();
+    });
+    ws.on("message", (data) => {
+      this.handleMessage(data);
+    });
+    ws.on("close", (code, reason) => {
+      logger11.warn("Disconnected from server", {
+        code,
+        reason: reason.toString()
+      });
+      this.ws = null;
+      if (!this.closing) {
+        this.scheduleReconnect();
+      }
+    });
+    ws.on("error", (err) => {
+      logger11.error("WebSocket error", { error: err });
+    });
+  }
+  async handleOpen() {
+    try {
+      await this.onConnected();
+      logger11.info("Recovery complete, sending bridge:register");
+    } catch (err) {
+      logger11.error("Recovery failed, registering with degraded state", { error: err });
+    }
+    this.register();
+  }
+  register() {
+    const ids = this.agentIds();
+    const qc = this.config.queryConfig ?? DEFAULT_QUERY_CONFIG;
+    this.send({
+      type: "bridge:register",
+      payload: {
+        bridgeId: this.config.bridgeId,
+        agents: ids,
+        queryConfig: {
+          maxActive: qc.maxActive,
+          idleTimeoutMs: qc.idleTimeoutMs
+        }
+      }
+    });
+    logger11.info("Sent bridge:register", {
+      bridgeId: this.config.bridgeId,
+      agents: ids
+    });
+  }
+  handleMessage(data) {
+    let msg;
+    try {
+      const raw = typeof data === "string" ? data : data.toString("utf8");
+      msg = parseWSMessage(raw);
+    } catch (e) {
+      logger11.error("Invalid WS message from server", { error: e });
+      return;
+    }
+    wsMetrics.incRecv(msg.type);
+    switch (msg.type) {
+      case "heartbeat": {
+        this.send(msg);
+        return;
+      }
+      case "task:dispatch": {
+        void this.onTaskDispatch(msg.payload).catch((err) => {
+          logger11.error("Failed to handle task:dispatch", {
+            error: err,
+            traceId: msg.payload.traceId
+          });
+        });
+        return;
+      }
+      case "task:group_dispatch": {
+        if (this.onGroupTaskDispatch) {
+          void this.onGroupTaskDispatch(msg.payload).catch((err) => {
+            logger11.error("Failed to handle task:group_dispatch", {
+              error: err,
+              traceId: msg.payload.traceId
+            });
+          });
+        } else {
+          logger11.warn("Received task:group_dispatch but no handler registered");
+        }
+        return;
+      }
+      case "user:stop_generation": {
+        void this.onStopGeneration(msg.payload).catch((err) => {
+          logger11.error("Failed to handle user:stop_generation", {
+            error: err,
+            traceId: msg.payload.traceId
+          });
+        });
+        return;
+      }
+      case "bridge:list_models_request":
+      case "agent:terminate":
+      case "agent:terminate_scope":
+      case "agent:created":
+      case "agent:updated":
+      case "agent:deleted":
+      case "group:member_changed":
+      case "user:answer_question": {
+        if (this.onServerPush) {
+          void Promise.resolve(this.onServerPush(msg)).catch((err) => {
+            logger11.error("onServerPush handler failed", { error: err, type: msg.type });
+          });
+        }
+        return;
+      }
+      default: {
+        logger11.warn("Unhandled server message type", {
+          type: msg.type
+        });
+      }
+    }
+  }
+  send(msg) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      logger11.warn("Cannot send: WebSocket not open", {
+        type: msg.type
+      });
+      return;
+    }
+    try {
+      this.ws.send(JSON.stringify(msg));
+      wsMetrics.incSend(msg.type);
+    } catch (e) {
+      logger11.error("Failed to send WS message", { error: e, type: msg.type });
+    }
+  }
+  scheduleReconnect() {
+    if (this.closing) return;
+    const delay = this.delays[Math.min(this.reconnectAttempts, this.delays.length - 1)];
+    this.reconnectAttempts++;
+    logger11.info("Scheduling reconnect", {
+      attempt: this.reconnectAttempts,
+      delayMs: delay
+    });
+    this.reconnectTimer = setTimeout(() => this.connect(), delay);
+  }
+  close() {
+    this.closing = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.close(1e3, "Bridge shutting down");
+      } catch (e) {
+        logger11.error("Error closing WebSocket", { error: e });
+      }
+      this.ws = null;
+    }
+    logger11.info("Connector closed");
+  }
+  get isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+};
+
+// src/modelQuerier.ts
+import fs3 from "fs/promises";
+import os5 from "os";
+import path7 from "path";
+var logger12 = createModuleLogger("bridge.modelQuerier");
+async function listModels(queryFn, opts = {}) {
+  const t0 = Date.now();
+  const cwd = opts.cwd ?? path7.join(os5.homedir(), ".ahchat", "workspaces", "_list_models");
+  await fs3.mkdir(cwd, { recursive: true });
+  const fn = queryFn ?? (await import("@anthropic-ai/claude-agent-sdk")).query;
+  const ic = new InputController();
+  ic.push("Reply with exactly: PING", "");
+  const q = fn({
+    prompt: ic,
+    options: {
+      cwd,
+      systemPrompt: { type: "preset", preset: "claude_code", append: "" },
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      allowedTools: []
+    }
+  });
+  const initTimeoutMs = opts.initTimeoutMs ?? 3e4;
+  let initialized = false;
+  const initPromise = (async () => {
+    for await (const msg of q) {
+      const t = String(msg.type ?? "");
+      const sub = String(msg.subtype ?? "");
+      if (t === "system" && sub === "init") {
+        initialized = true;
+        return;
+      }
+    }
+  })();
+  try {
+    await Promise.race([
+      initPromise,
+      new Promise((_, rej) => {
+        setTimeout(() => rej(new Error(`init timeout after ${initTimeoutMs}ms`)), initTimeoutMs);
+      })
+    ]);
+    if (!initialized) {
+      throw new Error("generator ended before init");
+    }
+    const init = await q.initializationResult();
+    const models = init.models.map((m) => ({
+      value: m.value,
+      displayName: m.displayName,
+      description: m.description
+    }));
+    logger12.info("listModels done", { count: models.length, ms: Date.now() - t0 });
+    return models;
+  } finally {
+    try {
+      ic.close();
+    } catch {
+    }
+    try {
+      await q.return?.(void 0);
+    } catch {
+    }
+  }
+}
+
+// src/lockfile.ts
+import fs4 from "fs";
+import path8 from "path";
+var logger13 = createModuleLogger("bridge.lockfile");
+var lockPath = null;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    const err = e;
+    if (err.code === "ESRCH") return false;
+    throw e;
+  }
+}
+function acquireLock(dataDir) {
+  const file = path8.join(dataDir, "bridge.lock");
+  lockPath = file;
+  if (fs4.existsSync(file)) {
+    const raw = fs4.readFileSync(file, "utf-8").trim();
+    const pid = Number.parseInt(raw, 10);
+    if (Number.isFinite(pid) && pid > 0) {
+      if (isProcessAlive(pid)) {
+        throw new Error(`Bridge already running (PID: ${pid})`);
+      }
+      logger13.warn("Removing stale bridge.lock (process not found)", { pid, path: file });
+    }
+  }
+  fs4.mkdirSync(path8.dirname(file), { recursive: true });
+  fs4.writeFileSync(file, String(process.pid), "utf-8");
+  logger13.info("Acquired bridge lock", { path: file, pid: process.pid });
+  const release = () => {
+    try {
+      if (lockPath && fs4.existsSync(lockPath)) {
+        const current = fs4.readFileSync(lockPath, "utf-8").trim();
+        if (current === String(process.pid)) {
+          fs4.unlinkSync(lockPath);
+          logger13.info("Released bridge lock", { path: lockPath });
+        }
+      }
+    } catch (e) {
+      logger13.error("Failed to release bridge lock", { error: e, path: lockPath });
+    } finally {
+      lockPath = null;
+    }
+  };
+  process.on("exit", release);
+  process.once("SIGINT", () => {
+    release();
+    process.exit(0);
+  });
+  process.once("SIGTERM", () => {
+    release();
+    process.exit(0);
+  });
+}
+
+// src/groupPromptBuilder.ts
+function decideRole(p) {
+  if (p.isMentioned) return "mentioned";
+  if (p.mentions.length > 0) return "overhearer";
+  return "open_floor";
+}
+function senderKindOf(p) {
+  return p.sender.kind;
+}
+var HEADER_BY_SENDER_ROLE = {
+  user: {
+    mentioned: () => [
+      "You were @mentioned in this message.",
+      "You SHOULD reply, but you retain the right to stay silent.",
+      `If you genuinely have nothing to add, reply with exactly the token \`${NO_REPLY_TOKEN}\` (and only that token).`
+    ],
+    overhearer: () => [
+      "You are an OVERHEARER \u2014 you received this message but someone else was @mentioned.",
+      `Default behavior: reply with exactly the token \`${NO_REPLY_TOKEN}\` and only that token.`,
+      "ONLY chime in if ONE of the following is true:",
+      "  (a) your role/expertise is uniquely required for this question;",
+      "  (b) your personality (see your system prompt) compels you to interject;",
+      "  (c) there is a factual error you must correct.",
+      `Otherwise reply \`${NO_REPLY_TOKEN}\`.`
+    ],
+    open_floor: () => [
+      "This message is addressed to the whole group (no one was @mentioned).",
+      "Treat it like a real IM group: reply if your role, expertise, or personality has something to add.",
+      `If you have nothing meaningful to contribute, reply with exactly the token \`${NO_REPLY_TOKEN}\` (and only that token) to stay silent.`
+    ]
+  },
+  agent: {
+    mentioned: ({ senderName }) => [
+      `A fellow agent (${senderName}) @mentioned you in the group.`,
+      "You SHOULD reply, but you may stay silent.",
+      `Per your platform rules, if you have nothing to add, reply \`${NO_REPLY_TOKEN}\`.`
+    ],
+    overhearer: ({ senderName }) => [
+      `A fellow agent (${senderName}) spoke and @mentioned someone else.`,
+      `Per your platform rules, default \`${NO_REPLY_TOKEN}\` unless your expertise is uniquely required or there is a factual error.`
+    ],
+    open_floor: ({ senderName }) => [
+      `A fellow agent (${senderName}) addressed the group.`,
+      `Per your platform rules, default \`${NO_REPLY_TOKEN}\` unless your expertise is uniquely needed or there is a factual error.`
+    ]
+  }
+};
+function buildGroupPrompt(payload) {
+  const lines = [];
+  const kind = senderKindOf(payload);
+  const role = decideRole(payload);
+  const senderName = payload.sender.kind === "agent" ? payload.sender.agentName : "user";
+  lines.push(`[Group: ${payload.groupName}] \xB7 ${payload.groupMemberCount}-person group`);
+  lines.push(`Members: ${payload.groupMemberNames.join(", ")}`);
+  lines.push(`You are: ${payload.agentName}`);
+  for (const line of HEADER_BY_SENDER_ROLE[kind][role]({ senderName })) {
+    lines.push(line);
+  }
+  lines.push("");
+  lines.push("--- chat history ---");
+  if (payload.context.length === 0) {
+    lines.push("(no history)");
+  } else {
+    for (const msg of payload.context) {
+      const s = msg.role === "user" ? "user" : msg.senderAgentName ?? `agent:${msg.senderAgentId ?? "unknown"}`;
+      lines.push(`[${s}]: ${msg.content}`);
+    }
+  }
+  lines.push("--- end history ---");
+  lines.push("");
+  if (payload.replyToMessage) {
+    const rts = payload.replyToMessage.role === "user" ? "user" : payload.replyToMessage.senderAgentName ?? `agent:${payload.replyToMessage.senderAgentId ?? "unknown"}`;
+    lines.push(`> Reply to [${rts}]: ${payload.replyToMessage.content}`);
+    lines.push("");
+  }
+  const speakerLabel = payload.sender.kind === "user" ? "user" : payload.sender.agentName;
+  lines.push("------- group task -------");
+  lines.push(`[${speakerLabel}]: ${payload.content}`);
+  lines.push("------- end task -------");
+  lines.push("");
+  lines.push(
+    "If you choose to speak, reply from your professional perspective. Your text will appear in the group chat verbatim."
+  );
+  return lines.join("\n");
+}
+
+// src/messageHandler.ts
+var logger14 = createModuleLogger("msg.handler");
+function emitTaskAck(emit, ackId, agentId, traceId) {
+  logger14.info("Emitting task:ack", { ackId, agentId, traceId });
+  emit({
+    type: "task:ack",
+    payload: {
+      ackId,
+      agentId,
+      traceId,
+      receivedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
+}
+function createTaskDispatchHandler(agentManager, agentRegistry, emit) {
+  return async (payload) => {
+    logger14.info("Handling task:dispatch", {
+      agentId: payload.agentId,
+      messageId: payload.messageId,
+      ackId: payload.ackId,
+      traceId: payload.traceId
+    });
+    emitTaskAck(emit, payload.ackId, payload.agentId, payload.traceId);
+    let agentConfig = agentRegistry.getById(payload.agentId);
+    if (!agentConfig) {
+      logger14.warn("Agent not in registry, attempting live fetch", {
+        agentId: payload.agentId,
+        traceId: payload.traceId
+      });
+      agentConfig = await agentRegistry.fetchById(payload.agentId);
+    }
+    if (!agentConfig) {
+      logger14.error("Agent not found for task:dispatch (after live fetch)", {
+        agentId: payload.agentId,
+        traceId: payload.traceId
+      });
+      emit({
+        type: "agent:error",
+        payload: {
+          agentId: payload.agentId,
+          conversationId: payload.conversationId,
+          ackId: payload.ackId,
+          traceId: payload.traceId,
+          error: "Agent not found"
+        }
+      });
+      return;
+    }
+    try {
+      await agentManager.acquire(agentConfig, { kind: "single" }, payload.cwd);
+      await agentManager.sendMessage({
+        agentId: payload.agentId,
+        scope: { kind: "single" },
+        conversationId: payload.conversationId,
+        content: payload.content,
+        replyMessageId: payload.ackId,
+        traceId: payload.traceId
+      });
+    } catch (err) {
+      logger14.error("Failed to dispatch message to Agent", {
+        error: err,
+        agentId: payload.agentId,
+        traceId: payload.traceId
+      });
+      emit({
+        type: "agent:error",
+        payload: {
+          agentId: payload.agentId,
+          conversationId: payload.conversationId,
+          ackId: payload.ackId,
+          traceId: payload.traceId,
+          error: `Bridge dispatch error: ${err.message}`
+        }
+      });
+    }
+  };
+}
+function createGroupTaskDispatchHandler(agentManager, agentRegistry, emit) {
+  return async (payload) => {
+    logger14.info("Handling task:group_dispatch", {
+      agentId: payload.agentId,
+      groupId: payload.groupId,
+      ackId: payload.ackId,
+      isMentioned: payload.isMentioned,
+      senderKind: payload.sender.kind,
+      chainDepth: payload.chainDepth,
+      traceId: payload.traceId
+    });
+    emitTaskAck(emit, payload.ackId, payload.agentId, payload.traceId);
+    let agentConfig = agentRegistry.getById(payload.agentId);
+    if (!agentConfig) {
+      logger14.warn("Agent not in registry for group dispatch, attempting live fetch", {
+        agentId: payload.agentId,
+        traceId: payload.traceId
+      });
+      agentConfig = await agentRegistry.fetchById(payload.agentId);
+    }
+    if (!agentConfig) {
+      logger14.error("Agent not found for task:group_dispatch (after live fetch)", {
+        agentId: payload.agentId,
+        traceId: payload.traceId
+      });
+      emit({
+        type: "agent:error",
+        payload: {
+          agentId: payload.agentId,
+          conversationId: payload.conversationId,
+          ackId: payload.ackId,
+          traceId: payload.traceId,
+          error: "Agent not found"
+        }
+      });
+      return;
+    }
+    const groupPrompt = buildGroupPrompt(payload);
+    try {
+      await agentManager.acquire(
+        agentConfig,
+        { kind: "group", groupId: payload.groupId },
+        payload.cwd
+      );
+      await agentManager.sendMessage({
+        agentId: payload.agentId,
+        scope: { kind: "group", groupId: payload.groupId },
+        conversationId: payload.conversationId,
+        content: groupPrompt,
+        replyMessageId: payload.ackId,
+        traceId: payload.traceId,
+        groupId: payload.groupId
+      });
+    } catch (err) {
+      logger14.error("Failed to dispatch group message to Agent", {
+        error: err,
+        agentId: payload.agentId,
+        groupId: payload.groupId,
+        traceId: payload.traceId
+      });
+      emit({
+        type: "agent:error",
+        payload: {
+          agentId: payload.agentId,
+          conversationId: payload.conversationId,
+          ackId: payload.ackId,
+          traceId: payload.traceId,
+          error: `Bridge group dispatch error: ${err.message}`
+        }
+      });
+    }
+  };
+}
+
+// src/sessionStore.ts
+import fs5 from "fs";
+import path9 from "path";
+var logger15 = createModuleLogger("session.store");
+var SessionStore = class {
+  filePath;
+  cache;
+  constructor(dataDir) {
+    this.filePath = path9.join(dataDir, "sessions.json");
+    this.cache = this.loadFromDisk();
+  }
+  cacheKey(agentId, scope) {
+    return runtimeKey(agentId, scope);
+  }
+  get(agentId, scope) {
+    return this.cache[this.cacheKey(agentId, scope)] ?? null;
+  }
+  set(agentId, scope, sessionId) {
+    this.cache[this.cacheKey(agentId, scope)] = sessionId;
+    this.saveToDisk();
+  }
+  delete(agentId, scope) {
+    delete this.cache[this.cacheKey(agentId, scope)];
+    this.saveToDisk();
+  }
+  deleteAllForAgent(agentId) {
+    const prefix = `${agentId}::`;
+    let changed = false;
+    for (const key of Object.keys(this.cache)) {
+      if (key === agentId || key.startsWith(prefix)) {
+        delete this.cache[key];
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.saveToDisk();
+    }
+  }
+  getAll() {
+    return new Map(Object.entries(this.cache));
+  }
+  loadFromDisk() {
+    try {
+      if (!fs5.existsSync(this.filePath)) return {};
+      const raw = fs5.readFileSync(this.filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+      const map = parsed;
+      const migrated = {};
+      for (const [key, sessionId] of Object.entries(map)) {
+        if (key.includes("::")) {
+          migrated[key] = sessionId;
+        } else {
+          migrated[`${key}::single`] = sessionId;
+          logger15.info("Migrated legacy session key to scoped key", {
+            legacyKey: key,
+            newKey: `${key}::single`
+          });
+        }
+      }
+      return migrated;
+    } catch (e) {
+      logger15.warn("Failed to load sessions file, starting fresh", { error: e, path: this.filePath });
+      return {};
+    }
+  }
+  saveToDisk() {
+    try {
+      const dir = path9.dirname(this.filePath);
+      fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2), "utf-8");
+    } catch (e) {
+      logger15.error("Failed to save sessions file", { error: e, path: this.filePath });
+    }
+  }
+};
+
+export {
+  loadBridgeConfig,
+  ensureDir,
+  createModuleLogger,
+  AskQuestionRegistry,
+  formatAnswerForSDK,
+  wsMetrics,
+  AgentManager,
+  HttpAgentRegistry,
+  GroupRegistry,
+  ServerConnector,
+  listModels,
+  acquireLock,
+  createTaskDispatchHandler,
+  createGroupTaskDispatchHandler,
+  SessionStore
+};