@fangyb/ahchat-bridge 0.1.8 → 0.1.10

package/dist/chunk-7SODRWIG.js

@@ -1,4525 +0,0 @@
-// 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
-};