@andyqiu/teamkit 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1773 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  teamkitServer: () => teamkitServer,
+  teamkitDevServer: () => teamkitDevServer,
+  createTeamkitServer: () => createTeamkitServer
+});
+module.exports = __toCommonJS(exports_src);
+
+// lib/dev-isolation.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+function shouldYieldToLocalPlugin() {
+  try {
+    const env = process.env.TEAMKIT_DEV;
+    if (env === "1" || env === "true" || env === "yes")
+      return true;
+    let dir = process.cwd();
+    for (let i = 0;i < 20; i++) {
+      const marker = path.join(dir, ".teamkit", ".dev-marker");
+      if (fs.existsSync(marker))
+        return true;
+      const parent = path.dirname(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function logLifecycle(msg) {
+  try {
+    const logDir = path.join(os.homedir(), ".cache", "teamkit");
+    fs.mkdirSync(logDir, { recursive: true });
+    const logFile = path.join(logDir, "plugins.log");
+    const timestamp = new Date().toISOString();
+    fs.appendFileSync(logFile, `[${timestamp}] [teamkit] ${msg}
+`, "utf-8");
+  } catch {}
+}
+
+// plugins/compaction-guard.ts
+var KH_INSTRUCTIONS = `# KH 行为约束（teamkit M2 注入）
+
+当对话出现以下触发词时，请优先调用 smart_search 查询团队知识库：
+- 以前、之前、历史、为什么、怎么部署、怎么配置
+- 架构、设计、决策、规范、约定
+
+## KH 工具使用规范
+- smart_search：查询团队历史经验（bug、架构决策、踩坑记录）
+- save_chat_insight：当前对话有 bug 修复/架构决策/踩坑时自动沉淀
+`;
+async function handleCompaction(ctx) {
+  let snapshot = "";
+  try {
+    snapshot = await ctx.workingMemory?.get?.("teamkit:kh-context") ?? "";
+  } catch {}
+  const khInstructions = KH_INSTRUCTIONS;
+  ctx.output.context.push({
+    type: "text",
+    text: `<!-- teamkit:kh-context -->
+${khInstructions}
+
+## 当前 KH 上下文快照
+${snapshot}`.trim()
+  });
+  try {
+    await ctx.workingMemory?.set?.("teamkit:compaction-guard", JSON.stringify({
+      compacted: true,
+      timestamp: new Date().toISOString()
+    }));
+  } catch {}
+}
+function handler() {
+  return {
+    hooks: {
+      "experimental.session.compacting": async (ctx) => {
+        try {
+          await handleCompaction(ctx);
+        } catch (err) {
+          console.error("[teamkit:compaction-guard] hook error:", err);
+        }
+      }
+    }
+  };
+}
+
+// lib/opencode-plugin-helpers.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_os = require("node:os");
+var LOG_DIR = process.env["TEAMKIT_LOG_DIR"] ?? import_node_path.join(import_node_os.homedir(), ".cache", "teamkit");
+var LOG_FILE = import_node_path.join(LOG_DIR, "plugins.log");
+function safeWriteLog(plugin, payload) {
+  try {
+    import_node_fs.mkdirSync(LOG_DIR, { recursive: true });
+    const line = JSON.stringify({
+      ts: new Date().toISOString(),
+      plugin,
+      ...payload
+    });
+    import_node_fs.appendFileSync(LOG_FILE, line + `
+`, "utf8");
+  } catch {}
+}
+function makePluginLogger(plugin) {
+  return {
+    info: (msg, data) => safeWriteLog(plugin, { level: "info", msg, data }),
+    warn: (msg, data) => safeWriteLog(plugin, { level: "warn", msg, data }),
+    error: (msg, data) => safeWriteLog(plugin, { level: "error", msg, data }),
+    debug: (msg, data) => safeWriteLog(plugin, { level: "debug", msg, data })
+  };
+}
+function extractUserText(output) {
+  if (!output || typeof output !== "object")
+    return "";
+  const parts = output.parts;
+  if (!Array.isArray(parts))
+    return "";
+  const chunks = [];
+  for (const p of parts) {
+    if (p && typeof p === "object") {
+      const part = p;
+      if (part.type === "text" && typeof part.text === "string") {
+        chunks.push(part.text);
+      }
+    }
+  }
+  return chunks.join(`
+`).trim();
+}
+async function safeAsync(plugin, hook, fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    safeWriteLog(plugin, {
+      level: "error",
+      hook,
+      msg: "hook 异常（已隔离）",
+      error: err instanceof Error ? err.message : String(err),
+      stack: err instanceof Error ? err.stack?.split(`
+`).slice(0, 5) : undefined
+    });
+    return;
+  }
+}
+function logLifecycle2(plugin, phase, extra) {
+  safeWriteLog(plugin, {
+    lifecycle: phase,
+    pid: typeof process !== "undefined" ? process.pid : -1,
+    bun: typeof process !== "undefined" && process.versions ? process.versions["bun"] ?? null : null,
+    node: typeof process !== "undefined" && process.versions ? process.versions.node : null,
+    ...extra
+  });
+}
+
+// lib/condenser.ts
+var DEFAULT_CONDENSE = {
+  budget: 128000,
+  threshold: 0.7,
+  target: 0.4,
+  keepRecent: 6,
+  keepSystem: true,
+  charsPerToken: 4
+};
+function estimateTokens(text, charsPerToken = 4) {
+  if (!text)
+    return 0;
+  return Math.max(1, Math.ceil(text.length / charsPerToken));
+}
+
+// lib/trigger-words.ts
+var KH_TRIGGER_WORDS_ZH = [
+  "怎么",
+  "怎样",
+  "如何",
+  "为什么",
+  "为啥",
+  "之前",
+  "历史",
+  "以前",
+  "部署",
+  "上线",
+  "发布",
+  "发版",
+  "环境",
+  "测试服",
+  "正式服",
+  "配置",
+  "地址",
+  "端口",
+  "凭证",
+  "接入",
+  "集成",
+  "谁负责",
+  "谁写的",
+  "报错",
+  "报什么错",
+  "跑不起来",
+  "起不来",
+  "挂了",
+  "崩了",
+  "规范",
+  "约定",
+  "风格"
+];
+var KH_TRIGGER_WORDS_EN = [
+  "how to",
+  "how do",
+  "how does",
+  "why",
+  "previously",
+  "historically",
+  "deploy",
+  "release",
+  "config",
+  "URL",
+  "credential",
+  "token",
+  "API key",
+  "api[_-]?key",
+  "integrate",
+  "integration",
+  "who owns",
+  "error",
+  "failed",
+  "convention",
+  "standard",
+  "style guide"
+];
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildKhTriggerRegex() {
+  const escapedZh = KH_TRIGGER_WORDS_ZH.map(escapeRegex).join("|");
+  const enParts = [];
+  for (const w of KH_TRIGGER_WORDS_EN) {
+    if (w === "api[_-]?key") {
+      enParts.push(w);
+    } else {
+      enParts.push(escapeRegex(w));
+    }
+  }
+  const escapedEn = enParts.join("|");
+  const pattern = `(${escapedZh})|\\b(${escapedEn})\\b`;
+  return new RegExp(pattern, "i");
+}
+var KH_TRIGGER_REGEX = buildKhTriggerRegex();
+
+// plugins/kh-reminder.ts
+var PLUGIN_NAME = "kh-reminder";
+logLifecycle2(PLUGIN_NAME, "import", {});
+var COOLDOWN_MS = 5 * 60 * 1000;
+var lastTriggerAt = new Map;
+var DEFAULT_THRESHOLD = 0.5;
+var DEFAULT_RECENT_ROUNDS = 5;
+function computeUsageRatio(messages) {
+  const cpt = DEFAULT_CONDENSE.charsPerToken;
+  const budget = DEFAULT_CONDENSE.budget;
+  if (budget <= 0)
+    return 0;
+  let total = 0;
+  for (const m of messages) {
+    total += m.tokens ?? estimateTokens(m.content, cpt);
+  }
+  return total / budget;
+}
+function findTriggerWord(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const m = messages[i];
+    if (!m || m.role !== "user")
+      continue;
+    const text = m.content ?? "";
+    const match = KH_TRIGGER_REGEX.exec(text);
+    if (match)
+      return match[0] ?? null;
+    return null;
+  }
+  return null;
+}
+function hasRecentSmartSearch(messages, recentRounds) {
+  const slice = messages.slice(-recentRounds);
+  for (const m of slice) {
+    const c = m.content ?? "";
+    if (/smart_search/i.test(c))
+      return true;
+    if (m.tag && /smart_search/i.test(m.tag))
+      return true;
+  }
+  return false;
+}
+function evaluate(input) {
+  const messages = Array.isArray(input.messages) ? input.messages : [];
+  const sessionId = input.sessionId ?? "unknown";
+  const threshold = input.threshold ?? DEFAULT_THRESHOLD;
+  const recentRounds = input.recentRounds ?? DEFAULT_RECENT_ROUNDS;
+  const now = (input.nowFn ?? Date.now)();
+  if (messages.length === 0) {
+    return { triggered: false, sessionId };
+  }
+  let reason = null;
+  const ratio = computeUsageRatio(messages);
+  if (ratio >= threshold) {
+    reason = { kind: "token-usage", ratio, threshold };
+  }
+  if (!reason) {
+    const word = findTriggerWord(messages);
+    if (word) {
+      reason = { kind: "trigger-word", word };
+    }
+  }
+  if (!reason) {
+    if (messages.length >= 6 && !hasRecentSmartSearch(messages, recentRounds)) {
+      reason = { kind: "no-search-in-recent-rounds", rounds: recentRounds };
+    }
+  }
+  if (!reason) {
+    return { triggered: false, sessionId };
+  }
+  const last = lastTriggerAt.get(sessionId);
+  if (last !== undefined && now - last < COOLDOWN_MS) {
+    return { triggered: false, cooldown_skipped: true, reason, sessionId };
+  }
+  lastTriggerAt.set(sessionId, now);
+  return { triggered: true, reason, sessionId };
+}
+function handleObserve(raw, log) {
+  const ctx = raw ?? {};
+  if (!Array.isArray(ctx.messages))
+    return null;
+  try {
+    const result = evaluate(ctx);
+    if (result.triggered && result.reason) {
+      const reasonStr = formatReason(result.reason);
+      log?.info(`[${PLUGIN_NAME}] ⚡ KH 提醒（observe-only） · session=${result.sessionId} · ${reasonStr}`, {
+        sessionId: result.sessionId,
+        reason: result.reason,
+        suggestion: "调用 smart_search 查项目历史；完成后用 save_chat_insight 沉淀"
+      });
+    }
+    return result;
+  } catch (err) {
+    log?.warn(`[${PLUGIN_NAME}] evaluate 异常（已隔离）`, {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+function formatReason(r) {
+  switch (r.kind) {
+    case "token-usage":
+      return `token-usage ${(r.ratio * 100).toFixed(1)}% ≥ ${(r.threshold * 100).toFixed(0)}%`;
+    case "trigger-word":
+      return `trigger-word: "${r.word}"`;
+    case "no-search-in-recent-rounds":
+      return `no-search-in-recent-rounds (last ${r.rounds})`;
+  }
+}
+var log = makePluginLogger(PLUGIN_NAME);
+var khReminderServer = async (ctx) => {
+  logLifecycle2(PLUGIN_NAME, "activate", {
+    directory: ctx.directory,
+    threshold: DEFAULT_THRESHOLD,
+    cooldown_ms: COOLDOWN_MS
+  });
+  return {
+    "experimental.chat.messages.transform": async (_input, output) => {
+      await safeAsync(PLUGIN_NAME, "experimental.chat.messages.transform", async () => {
+        const list = output.messages;
+        if (!Array.isArray(list) || list.length === 0)
+          return;
+        let sessionId = "unknown";
+        const flat = list.map((m) => {
+          const info = m.info;
+          if (info && typeof info.sessionID === "string" && sessionId === "unknown") {
+            sessionId = info.sessionID;
+          }
+          const role = info?.role ?? "user";
+          const parts = m.parts ?? [];
+          const content = parts.filter((p) => p.type === "text").map((p) => p.text ?? "").join(`
+`);
+          return { role, content };
+        });
+        const result = handleObserve({ messages: flat, sessionId }, log);
+        if (!result)
+          return;
+        safeWriteLog(PLUGIN_NAME, {
+          hook: "experimental.chat.messages.transform",
+          mode: "observe-only",
+          sessionId: result.sessionId,
+          triggered: result.triggered,
+          cooldown_skipped: result.cooldown_skipped ?? false,
+          reason: result.reason ?? null,
+          msgs: flat.length
+        });
+      });
+    }
+  };
+};
+var handler2 = khReminderServer;
+
+// lib/global-config.ts
+var import_node_fs2 = require("node:fs");
+var path2 = __toESM(require("node:path"));
+var os2 = __toESM(require("node:os"));
+var DEFAULT_KH_URL = "http://10.5.60.26:8900/mcp";
+var DEFAULT_KH_TIMEOUT_MS = 5000;
+var DEFAULT_KH_MAX_RETRIES = 1;
+var CACHE_TTL_MS = 5000;
+var cache = new Map;
+var warnedTokenInFile = new Set;
+function cacheGet(key) {
+  const entry = cache.get(key);
+  if (!entry)
+    return;
+  if (Date.now() > entry.expireAt) {
+    cache.delete(key);
+    return;
+  }
+  return entry.value;
+}
+function cacheSet(key, value) {
+  cache.set(key, { expireAt: Date.now() + CACHE_TTL_MS, value });
+}
+function loadJsonIfExists(filePath) {
+  const cacheKey = `file:${filePath}`;
+  const cached = cacheGet(cacheKey);
+  if (cached !== undefined)
+    return cached;
+  if (!import_node_fs2.existsSync(filePath)) {
+    cacheSet(cacheKey, null);
+    return null;
+  }
+  let raw;
+  try {
+    raw = import_node_fs2.readFileSync(filePath, "utf8");
+  } catch (err) {
+    warnOnce(`load-fail:${filePath}`, `[teamkit] 读取 ${filePath} 失败：${errorMessage(err)}（已忽略）`);
+    cacheSet(cacheKey, null);
+    return null;
+  }
+  if (raw.charCodeAt(0) === 65279)
+    raw = raw.slice(1);
+  try {
+    const parsed = JSON.parse(raw);
+    cacheSet(cacheKey, parsed);
+    return parsed;
+  } catch (err) {
+    warnOnce(`parse-fail:${filePath}`, `[teamkit] JSON 解析失败 ${filePath}：${errorMessage(err)}（已忽略）`);
+    cacheSet(cacheKey, null);
+    return null;
+  }
+}
+function globalConfigDir(env = process.env) {
+  const xdg = env["XDG_CONFIG_HOME"];
+  const base = xdg && xdg.length > 0 ? xdg : path2.join(os2.homedir(), ".config");
+  return path2.join(base, "teamkit");
+}
+function projectConfigDir(root = process.cwd()) {
+  return path2.join(root, ".teamkit");
+}
+function getKhConfig(opts = {}) {
+  const root = opts.root ?? process.cwd();
+  const env = opts.env ?? process.env;
+  const cacheKey = `kh:${root}:${env["KNOWLEDGE_HUB_URL"] ?? ""}:${env["KNOWLEDGE_API_KEY"] ? "1" : "0"}`;
+  const cached = cacheGet(cacheKey);
+  if (cached !== undefined)
+    return cached;
+  const globalKh = readJsonObject(path2.join(globalConfigDir(env), "kh.json"));
+  const projectKh = readJsonObject(path2.join(projectConfigDir(root), "kh.json"));
+  for (const [label, src] of [
+    ["全局 kh.json", globalKh],
+    ["项目 kh.json", projectKh]
+  ]) {
+    if (containsTokenField(src)) {
+      warnOnce(`token-in-file:${label}`, `[teamkit] 检测到 ${label} 写了 token / apiKey / secret 等敏感字段，已忽略。` + ` API key 必须通过环境变量 KNOWLEDGE_API_KEY 提供。`);
+    }
+  }
+  const url = pickString(env["KNOWLEDGE_HUB_URL"]) ?? pickString(projectKh?.["url"]) ?? pickString(globalKh?.["url"]) ?? DEFAULT_KH_URL;
+  const timeoutMs = pickPositiveInt(projectKh?.["timeoutMs"]) ?? pickPositiveInt(globalKh?.["timeoutMs"]) ?? DEFAULT_KH_TIMEOUT_MS;
+  const maxRetries = pickNonNegativeInt(projectKh?.["maxRetries"]) ?? pickNonNegativeInt(globalKh?.["maxRetries"]) ?? DEFAULT_KH_MAX_RETRIES;
+  const apiKey = pickString(env["KNOWLEDGE_API_KEY"]);
+  const cfg = apiKey ? { url, apiKey, timeoutMs, maxRetries } : { url, timeoutMs, maxRetries };
+  cacheSet(cacheKey, cfg);
+  return cfg;
+}
+function readJsonObject(filePath) {
+  const raw = loadJsonIfExists(filePath);
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return null;
+  return raw;
+}
+function containsTokenField(obj) {
+  if (!obj)
+    return false;
+  const banned = [
+    "token",
+    "apikey",
+    "api_key",
+    "apiKey",
+    "authorization",
+    "auth",
+    "bearer",
+    "secret",
+    "access_token",
+    "refresh_token",
+    "client_secret",
+    "password",
+    "passwd",
+    "credential",
+    "credentials"
+  ];
+  const bannedLower = new Set(banned.map((b) => b.toLowerCase()));
+  for (const key of Object.keys(obj)) {
+    if (bannedLower.has(key.toLowerCase()))
+      return true;
+  }
+  return false;
+}
+function pickString(v) {
+  if (typeof v !== "string")
+    return;
+  const s = v.trim();
+  return s.length > 0 ? s : undefined;
+}
+function pickPositiveInt(v) {
+  if (typeof v !== "number" || !Number.isFinite(v))
+    return;
+  const n = Math.floor(v);
+  return n > 0 ? n : undefined;
+}
+function pickNonNegativeInt(v) {
+  if (typeof v !== "number" || !Number.isFinite(v))
+    return;
+  const n = Math.floor(v);
+  return n >= 0 ? n : undefined;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function warnOnce(key, msg) {
+  if (warnedTokenInFile.has(key))
+    return;
+  warnedTokenInFile.add(key);
+  console.warn(msg);
+}
+
+// lib/kh-client-stdio.ts
+var DEFAULT_TIMEOUT_MS = 5000;
+var DEFAULT_MAX_RETRIES = 1;
+var RETRY_BASE_DELAY_MS = 200;
+var nextRpcId = 1;
+function makeRpcId() {
+  const n = nextRpcId++;
+  const r = Math.floor(Math.random() * 65535).toString(16);
+  return `tk-${n}-${r}`;
+}
+function createHttpMcpTransport(opts) {
+  const apiKey = opts.apiKey?.trim();
+  if (!apiKey)
+    return null;
+  const fetchImpl = opts.fetchImpl ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : null);
+  if (!fetchImpl)
+    return null;
+  const url = opts.url;
+  if (!url || typeof url !== "string")
+    return null;
+  const timeoutMs = opts.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : DEFAULT_TIMEOUT_MS;
+  const maxRetries = typeof opts.maxRetries === "number" && opts.maxRetries >= 0 ? Math.floor(opts.maxRetries) : DEFAULT_MAX_RETRIES;
+  const sleep = opts.sleep ?? defaultSleep;
+  return async (call) => {
+    const body = JSON.stringify({
+      jsonrpc: "2.0",
+      id: makeRpcId(),
+      method: "tools/call",
+      params: {
+        name: call.tool,
+        arguments: call.args
+      }
+    });
+    let lastErr;
+    for (let attempt = 0;attempt <= maxRetries; attempt++) {
+      try {
+        const result = await sendOnce({ url, apiKey, body, timeoutMs, fetchImpl });
+        return result;
+      } catch (err) {
+        lastErr = err;
+        if (err instanceof HttpStatusError && err.status >= 400 && err.status < 500) {
+          throw err;
+        }
+        if (attempt < maxRetries) {
+          const delay = RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+          await sleep(delay);
+        }
+      }
+    }
+    throw lastErr ?? new Error("teamkit kh transport: unknown failure");
+  };
+}
+async function sendOnce(ctx) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), ctx.timeoutMs);
+  let resp;
+  try {
+    resp = await ctx.fetchImpl(ctx.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        Authorization: `Bearer ${ctx.apiKey}`
+      },
+      body: ctx.body,
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (isAbortError(err)) {
+      throw new Error(`teamkit kh transport: request timeout after ${ctx.timeoutMs}ms`);
+    }
+    throw err instanceof Error ? err : new Error(String(err));
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!resp.ok) {
+    throw new HttpStatusError(resp.status, `teamkit kh transport: HTTP ${resp.status}`);
+  }
+  let raw;
+  try {
+    raw = await resp.text();
+  } catch (err) {
+    throw new Error(`teamkit kh transport: read body failed — ${errorMessage2(err)}`);
+  }
+  let unwrapped;
+  try {
+    unwrapped = unwrapSseIfNeeded(raw, resp.headers.get("content-type"));
+  } catch (err) {
+    throw err instanceof Error ? err : new Error(String(err));
+  }
+  let json;
+  try {
+    json = JSON.parse(unwrapped);
+  } catch (err) {
+    throw new Error(`teamkit kh transport: invalid JSON response — ${errorMessage2(err)}`);
+  }
+  return parseRpcEnvelope(json);
+}
+function unwrapSseIfNeeded(rawBody, contentType) {
+  const ct = (contentType ?? "").toLowerCase();
+  if (!ct.includes("text/event-stream")) {
+    return rawBody;
+  }
+  const normalized = rawBody.replace(/\r\n/g, `
+`);
+  const firstBlankLine = normalized.indexOf(`
+
+`);
+  const firstEvent = firstBlankLine >= 0 ? normalized.slice(0, firstBlankLine) : normalized;
+  const dataLines = [];
+  for (const line of firstEvent.split(`
+`)) {
+    if (line.startsWith("data:")) {
+      const value = line.slice(5).startsWith(" ") ? line.slice(6) : line.slice(5);
+      dataLines.push(value);
+    }
+  }
+  if (dataLines.length === 0) {
+    throw new Error("teamkit kh transport: SSE response missing data");
+  }
+  return dataLines.join(`
+`);
+}
+function parseRpcEnvelope(json) {
+  if (!json || typeof json !== "object") {
+    throw new Error("teamkit kh transport: response is not an object");
+  }
+  const obj = json;
+  if (obj["error"]) {
+    const e = obj["error"];
+    throw new Error(`teamkit kh transport: rpc error ${e.code ?? "?"} — ${e.message ?? "unknown"}`);
+  }
+  const result = obj["result"];
+  if (result === undefined || result === null) {
+    throw new Error("teamkit kh transport: response missing result");
+  }
+  if (typeof result === "object") {
+    const r = result;
+    const content = r["content"];
+    if (Array.isArray(content) && content.length > 0) {
+      const first = content[0];
+      if (first && typeof first["text"] === "string") {
+        const text = first["text"];
+        try {
+          return JSON.parse(text);
+        } catch {
+          return text;
+        }
+      }
+    }
+  }
+  return result;
+}
+
+class HttpStatusError extends Error {
+  status;
+  constructor(status, msg) {
+    super(msg);
+    this.status = status;
+    this.name = "HttpStatusError";
+  }
+}
+function isAbortError(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  const name = err.name;
+  return name === "AbortError" || name === "TimeoutError";
+}
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function errorMessage2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// lib/kh-client.ts
+var KH_CATEGORIES = new Set([
+  "convention",
+  "anti_pattern",
+  "architecture",
+  "reference",
+  "workflow",
+  "gotcha",
+  "tooling",
+  "decision"
+]);
+function defaultTransport() {
+  const g = globalThis;
+  if (typeof g.__teamkitMcpCall === "function")
+    return g.__teamkitMcpCall;
+  return resolveStdioTransport();
+}
+function resolveStdioTransport() {
+  try {
+    const cfg = getKhConfig();
+    return createHttpMcpTransport({
+      url: cfg.url,
+      apiKey: cfg.apiKey,
+      timeoutMs: cfg.timeoutMs,
+      maxRetries: cfg.maxRetries
+    });
+  } catch (err) {
+    warnOnce2(`stdio-transport-init`, `[teamkit] KH HTTP transport 初始化失败：${errorMessage3(err)}（已降级）`);
+    return null;
+  }
+}
+function detectProjectContext() {
+  return {
+    projectName: process.env["TEAMKIT_PROJECT"] ?? guessProjectName(),
+    currentTask: process.env["TEAMKIT_TASK"],
+    caller: process.env["TEAMKIT_CALLER"] ?? "tool"
+  };
+}
+function guessProjectName() {
+  try {
+    const cwd = process.cwd();
+    return cwd.split(/[\\/]/).pop() ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+class KhClient {
+  server;
+  transport;
+  context;
+  maxRetries;
+  constructor(opts = {}) {
+    this.server = opts.serverIdentifier ?? process.env["TEAMKIT_KH_SERVER"] ?? "knowledge-hub";
+    this.transport = opts.transport ?? defaultTransport();
+    this.context = opts.context ?? detectProjectContext();
+    this.maxRetries = opts.maxRetries ?? 0;
+  }
+  async search(input) {
+    const query = (input.query ?? "").trim();
+    if (!query) {
+      return { ok: false, reason: "invalid_input", message: "query 不能为空" };
+    }
+    if (!this.transport) {
+      return {
+        ok: false,
+        reason: "transport_unavailable",
+        message: "MCP transport 未注入；KH 调用降级（不阻塞主流程）"
+      };
+    }
+    const args = {
+      query,
+      limit: input.limit ?? 5,
+      _context: {
+        project: this.context.projectName,
+        caller: this.context.caller,
+        prefer: input.prefer ?? ["bugfix", "architecture", "convention"]
+      }
+    };
+    try {
+      const raw = await this.callWithRetry({ server: this.server, tool: "smart_search", args });
+      return normalizeSearchResult(raw, query);
+    } catch (err) {
+      return {
+        ok: false,
+        reason: "kh_returned_error",
+        message: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async save(input) {
+    const insight = (input.insight ?? "").trim();
+    if (!insight) {
+      return { ok: false, reason: "invalid_input", message: "insight 不能为空" };
+    }
+    if (insight.length > 5000) {
+      return {
+        ok: false,
+        reason: "invalid_input",
+        message: `insight 过长 (${insight.length} > 5000 字)，建议分多条沉淀`
+      };
+    }
+    const category = input.category;
+    if (!this.transport) {
+      return {
+        ok: false,
+        reason: "transport_unavailable",
+        message: "MCP transport 未注入；KH 沉淀降级（不阻塞主流程）"
+      };
+    }
+    const tags = uniq([
+      ...input.tags ?? [],
+      `project:${this.context.projectName}`,
+      `caller:${this.context.caller}`
+    ]);
+    try {
+      const raw = await this.callWithRetry({
+        server: this.server,
+        tool: "save_chat_insight",
+        args: { insight, category, tags }
+      });
+      return normalizeSaveResult(raw);
+    } catch (err) {
+      return {
+        ok: false,
+        reason: "kh_returned_error",
+        message: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async callWithRetry(call) {
+    if (!this.transport)
+      throw new Error("transport not available");
+    const full = {
+      server: "server" in call && call.server || this.server,
+      tool: call.tool,
+      args: call.args
+    };
+    let lastErr;
+    for (let attempt = 0;attempt <= this.maxRetries; attempt++) {
+      try {
+        return await this.transport(full);
+      } catch (err) {
+        lastErr = err;
+      }
+    }
+    throw lastErr;
+  }
+  hasTransport() {
+    return this.transport !== null;
+  }
+  async addKnowledge(args) {
+    return this.callKhTool("add_knowledge", args);
+  }
+  async uploadDocument(args) {
+    return this.callKhTool("upload_document", args);
+  }
+  async uploadDocumentFromUrl(args) {
+    return this.callKhTool("upload_document_from_url", args);
+  }
+  async updateKnowledge(args) {
+    return this.callKhTool("update_knowledge", args);
+  }
+  async flagOutdated(args) {
+    return this.callKhTool("flag_outdated", args);
+  }
+  async deleteKnowledge(args) {
+    return this.callKhTool("delete_knowledge", args);
+  }
+  async listRecent(args = {}) {
+    return this.callKhTool("list_recent", args);
+  }
+  async updateWorkingMemory(args) {
+    return this.callKhTool("update_working_memory", args);
+  }
+  async getWorkingMemory(args = {}) {
+    return this.callKhTool("get_working_memory", args);
+  }
+  async updateUserPreference(args) {
+    return this.callKhTool("update_user_preference", args);
+  }
+  async webSearch(args) {
+    return this.callKhTool("web_search", args);
+  }
+  async generateImage(args) {
+    return this.callKhTool("generate_image", args);
+  }
+  async callKhTool(tool, args) {
+    if (!this.transport) {
+      return {
+        ok: false,
+        reason: "transport_unavailable",
+        message: `MCP transport 未注入；KH ${tool} 调用降级（不阻塞主流程）`
+      };
+    }
+    try {
+      return await this.callWithRetry({ tool, args });
+    } catch (err) {
+      return {
+        ok: false,
+        reason: "kh_returned_error",
+        message: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+}
+function normalizeSearchResult(raw, query) {
+  const obj = raw ?? {};
+  const list = obj["insights"] ?? obj["matches"] ?? obj["results"] ?? [];
+  const insights = list.map((item) => normalizeInsight(item)).filter((x) => x !== null);
+  return {
+    ok: true,
+    query,
+    insights,
+    hint: typeof obj["hint"] === "string" ? obj["hint"] : undefined
+  };
+}
+function normalizeInsight(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const r = raw;
+  const id = pickString2(r, ["id", "_id", "uuid"]);
+  const title = pickString2(r, ["title", "name"]) ?? "(untitled)";
+  const content = pickString2(r, ["content", "body", "text"]) ?? "";
+  if (!id)
+    return null;
+  return {
+    id,
+    title,
+    content,
+    category: pickString2(r, ["category", "type"]) ?? "reference",
+    scope: pickString2(r, ["scope", "namespace"]) ?? "unknown",
+    confidence: typeof r["confidence"] === "number" ? r["confidence"] : 0,
+    tags: Array.isArray(r["tags"]) ? r["tags"] : undefined,
+    source: pickString2(r, ["source", "origin"])
+  };
+}
+function normalizeSaveResult(raw) {
+  const r = raw ?? {};
+  return {
+    ok: true,
+    id: pickString2(r, ["id", "_id"]) ?? "unknown",
+    title: pickString2(r, ["title"]) ?? "(no title)",
+    category: pickString2(r, ["category"]) ?? "unknown",
+    scope: pickString2(r, ["scope"]) ?? "unknown"
+  };
+}
+function pickString2(obj, keys) {
+  for (const k of keys) {
+    const v = obj[k];
+    if (typeof v === "string" && v.length > 0)
+      return v;
+  }
+  return;
+}
+function uniq(arr) {
+  return Array.from(new Set(arr));
+}
+function errorMessage3(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var _warnedKeys = new Set;
+function warnOnce2(key, msg) {
+  if (_warnedKeys.has(key))
+    return;
+  _warnedKeys.add(key);
+  console.warn(msg);
+}
+
+// lib/kh-shared-context.ts
+var DEFAULT_MAX_PER_SESSION = 20;
+var DEFAULT_TTL_MS = 5 * 60 * 1000;
+
+class SessionScopedCache {
+  cache = new Map;
+  inflight = new Map;
+  generation = new Map;
+  ttlMs;
+  maxPerSession;
+  now;
+  constructor(opts = {}) {
+    this.ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+    this.maxPerSession = opts.maxPerSession ?? DEFAULT_MAX_PER_SESSION;
+    this.now = opts.now ?? (() => Date.now());
+  }
+  async searchOrGet(args) {
+    const { client, sessionId, query, limit, timeoutMs } = args;
+    const queryHash = this.hashQuery(sessionId, query);
+    const inflightKey = `${sessionId}::${queryHash}`;
+    const sessionMap = this.cache.get(sessionId);
+    if (sessionMap) {
+      const entry = sessionMap.get(queryHash);
+      if (entry && this.now() - entry.cachedAt < this.ttlMs) {
+        sessionMap.delete(queryHash);
+        sessionMap.set(queryHash, entry);
+        return entry.result;
+      }
+      if (entry)
+        sessionMap.delete(queryHash);
+    }
+    const pending = this.inflight.get(inflightKey);
+    if (pending)
+      return pending;
+    const startGen = this.generation.get(sessionId) ?? 0;
+    const promise = this.doSearchAndMaybeCache(client, sessionId, queryHash, query, limit, timeoutMs, startGen).finally(() => {
+      this.inflight.delete(inflightKey);
+    });
+    this.inflight.set(inflightKey, promise);
+    return promise;
+  }
+  onSessionEnd(sessionId) {
+    this.generation.set(sessionId, (this.generation.get(sessionId) ?? 0) + 1);
+    this.cache.delete(sessionId);
+    const prefix = `${sessionId}::`;
+    for (const key of this.inflight.keys()) {
+      if (key.startsWith(prefix))
+        this.inflight.delete(key);
+    }
+  }
+  _snapshot() {
+    const perSession = {};
+    let total = 0;
+    for (const [sid, map] of this.cache.entries()) {
+      perSession[sid] = map.size;
+      total += map.size;
+    }
+    const generations = {};
+    for (const [sid, g] of this.generation.entries()) {
+      generations[sid] = g;
+    }
+    return {
+      cacheSize: total,
+      inflightSize: this.inflight.size,
+      sessions: Array.from(this.cache.keys()),
+      perSession,
+      generations
+    };
+  }
+  _reset() {
+    this.cache.clear();
+    this.inflight.clear();
+    this.generation.clear();
+  }
+  hashQuery(sessionId, query) {
+    return `${sessionId}::${query}`;
+  }
+  async doSearchAndMaybeCache(client, sessionId, queryHash, query, limit, timeoutMs, startGen) {
+    const result = await this.doSearch(client, query, limit, timeoutMs);
+    const currentGen = this.generation.get(sessionId) ?? 0;
+    if (currentGen === startGen && result.ok) {
+      this.writeCache(sessionId, queryHash, query, result);
+    }
+    return result;
+  }
+  async doSearch(client, query, limit, timeoutMs) {
+    const callPromise = (async () => {
+      try {
+        return await client.search({ query, limit });
+      } catch (err) {
+        return {
+          ok: false,
+          reason: "kh_returned_error",
+          message: err instanceof Error ? err.message : String(err)
+        };
+      }
+    })();
+    if (timeoutMs === undefined || timeoutMs <= 0) {
+      return callPromise;
+    }
+    let timer = null;
+    try {
+      const racer = new Promise((res) => {
+        timer = setTimeout(() => res({
+          ok: false,
+          reason: "kh_returned_error",
+          message: `kh search timeout after ${timeoutMs}ms`
+        }), timeoutMs);
+      });
+      return await Promise.race([callPromise, racer]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  writeCache(sessionId, queryHash, query, result) {
+    let sessionMap = this.cache.get(sessionId);
+    if (!sessionMap) {
+      sessionMap = new Map;
+      this.cache.set(sessionId, sessionMap);
+    }
+    sessionMap.delete(queryHash);
+    sessionMap.set(queryHash, { query, result, cachedAt: this.now() });
+    while (sessionMap.size > this.maxPerSession) {
+      const oldest = sessionMap.keys().next().value;
+      if (oldest === undefined)
+        break;
+      sessionMap.delete(oldest);
+    }
+  }
+}
+var sharedKhCache = new SessionScopedCache;
+
+// plugins/kh-auto-context.ts
+var PLUGIN_NAME2 = "kh-auto-context";
+var INJECTION_MODE = "observe-only";
+function resolveInjectionMode(client) {
+  return client.hasTransport() ? "system-injected" : "observe-only";
+}
+var DEFAULT_CONFIG = {
+  minConfidence: 0.55,
+  limit: 3,
+  minTextLength: 8,
+  cacheTtlMs: 5 * 60 * 1000,
+  timeoutMs: 1000,
+  skipPrefixes: ["/", "!", "@"],
+  skipKeywords: ["你好", "hello", "hi", "thanks", "谢谢"]
+};
+
+class QueryCache {
+  ttlMs;
+  now;
+  map = new Map;
+  constructor(ttlMs, now = () => Date.now()) {
+    this.ttlMs = ttlMs;
+    this.now = now;
+  }
+  shouldSkip(query) {
+    const entry = this.map.get(query);
+    if (!entry)
+      return false;
+    return this.now() - entry.injectedAt < this.ttlMs;
+  }
+  record(query, insights) {
+    this.map.set(query, { query, injectedAt: this.now(), insights });
+  }
+  size() {
+    return this.map.size;
+  }
+  clear() {
+    this.map.clear();
+  }
+}
+function extractQuery(text) {
+  if (!text)
+    return "";
+  const norm = text.trim().replace(/\s+/g, " ");
+  const m = /^[^.。?!？！；;\n]+/.exec(norm);
+  let head = (m ? m[0] : norm).trim();
+  const fillerRe = /^(请|帮我|麻烦|我想|你能|你可以|看一?下|查一?下|how (do|can) (i|you)|can you|could you|please|help me)\s*/i;
+  let prev = "";
+  while (prev !== head) {
+    prev = head;
+    head = head.replace(fillerRe, "").trim();
+  }
+  return head.slice(0, 80);
+}
+function shouldInject(text, cfg = DEFAULT_CONFIG) {
+  if (!text)
+    return false;
+  const t = text.trim();
+  if (t.length < cfg.minTextLength)
+    return false;
+  for (const p of cfg.skipPrefixes) {
+    if (t.startsWith(p))
+      return false;
+  }
+  const lower = t.toLowerCase();
+  for (const kw of cfg.skipKeywords) {
+    if (lower.includes(kw.toLowerCase()) && t.length <= kw.length + 5)
+      return false;
+  }
+  return true;
+}
+function formatInjection(query, insights, mode = INJECTION_MODE) {
+  const lines = [];
+  lines.push(`> \uD83E\uDDE0 [${mode}] 候选 ${insights.length} 条团队经验（query: "${query}"）`);
+  lines.push("");
+  for (const ins of insights) {
+    lines.push(`**${ins.title}** \`${ins.category}\` _(${(ins.confidence * 100).toFixed(0)}%)_`);
+    const content = ins.content.length > 240 ? ins.content.slice(0, 240) + "…" : ins.content;
+    lines.push(content.replace(/\n+/g, " "));
+    lines.push("");
+  }
+  return { query, insights, markdown: lines.join(`
+`), mode };
+}
+var TEAMKIT_CONSTRAINTS = [
+  {
+    content: "本会话安装了 teamkit：触发词命中（部署/怎么/为什么/之前/历史等）必须先 smart_search；" + "对话结束后用 save_chat_insight 沉淀经验",
+    priority: 9
+  },
+  {
+    content: "API key 仅读环境变量 KNOWLEDGE_API_KEY，禁止写入任何配置文件",
+    priority: 9
+  },
+  {
+    content: "沉淀经验优先用 save_chat_insight（自动分类、去重、合并），不要直接 add_knowledge",
+    priority: 8
+  }
+];
+async function seedConstraints(client, log2) {
+  if (!client.hasTransport()) {
+    log2?.debug?.(`[${PLUGIN_NAME2}] seedConstraints: transport 不可用，跳过`, {});
+    return { ok: false, reason: "transport_unavailable" };
+  }
+  try {
+    const result = await client.updateWorkingMemory({
+      section: "constraints",
+      replace: false,
+      items: TEAMKIT_CONSTRAINTS.map((c) => ({
+        content: `teamkit: ${c.content}`,
+        priority: c.priority
+      }))
+    });
+    if (result && typeof result === "object" && "ok" in result && result.ok === false) {
+      const r = result;
+      log2?.warn(`[${PLUGIN_NAME2}] seedConstraints 降级`, { reason: r.reason, message: r.message });
+      return {
+        ok: false,
+        reason: r.reason === "transport_unavailable" ? "transport_unavailable" : "kh_call_failed",
+        message: r.message
+      };
+    }
+    log2?.info(`[${PLUGIN_NAME2}] seedConstraints: 已写入 ${TEAMKIT_CONSTRAINTS.length} 条 constraints`, {
+      count: TEAMKIT_CONSTRAINTS.length
+    });
+    return { ok: true, itemsWritten: TEAMKIT_CONSTRAINTS.length };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log2?.warn(`[${PLUGIN_NAME2}] seedConstraints 失败（已静默）`, { error: message });
+    return { ok: false, reason: "exception", message };
+  }
+}
+function createSystemInjectedHook(client, sessionId, log2) {
+  const section = `teamkit:auto-context-${sessionId ?? "global"}`;
+  return async (markdown) => {
+    try {
+      const result = await client.updateWorkingMemory({
+        section,
+        replace: true,
+        items: [{ content: markdown, priority: 7 }]
+      });
+      if (result && typeof result === "object" && "ok" in result && result.ok === false) {
+        const r = result;
+        log2?.warn(`[${PLUGIN_NAME2}] system-injected 降级到 observe-only：${r.reason ?? "unknown"}`, {
+          sessionId,
+          section,
+          preview: markdown.slice(0, 200),
+          reason: r.reason,
+          message: r.message
+        });
+        return;
+      }
+      log2?.info(`[${PLUGIN_NAME2}] system-injected: 写入 KH working_memory 成功 (${markdown.length} chars)`, {
+        sessionId,
+        section
+      });
+    } catch (err) {
+      log2?.warn(`[${PLUGIN_NAME2}] system-injected 抛异常，降级到 observe-only`, {
+        sessionId,
+        section,
+        preview: markdown.slice(0, 200),
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  };
+}
+var inflight = new Set;
+var INFLIGHT_CAP = 5;
+function inflightKey(sessionId, query) {
+  return `${sessionId ?? "global"}:${Date.now()}:${Math.random().toString(36).slice(2, 10)}`;
+}
+async function runKhSearchAndInject(args) {
+  const { query, ctx, opts, mode } = args;
+  const cfg = opts.config ?? DEFAULT_CONFIG;
+  const log2 = ctx.log;
+  const startedAt = Date.now();
+  const racer = opts.scheduler?.raceTimeout ?? (async (p, ms) => {
+    let timer = null;
+    try {
+      return await Promise.race([
+        p,
+        new Promise((res) => {
+          timer = setTimeout(() => res("__timeout__"), ms);
+        })
+      ]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  });
+  let result;
+  try {
+    const searchPromise = sharedKhCache.searchOrGet({
+      client: opts.client,
+      sessionId: ctx.sessionId ?? "global",
+      query,
+      limit: cfg.limit
+    });
+    result = await racer(searchPromise, cfg.timeoutMs);
+  } catch (err) {
+    log2?.warn(`[${PLUGIN_NAME2}] client.search threw`, {
+      query,
+      elapsedMs: Date.now() - startedAt,
+      sessionId: ctx.sessionId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    opts.cache.record(query, []);
+    return null;
+  }
+  if (result === "__timeout__") {
+    log2?.warn(`[${PLUGIN_NAME2}] timeout`, { query, ms: cfg.timeoutMs, elapsedMs: Date.now() - startedAt, sessionId: ctx.sessionId });
+    opts.cache.record(query, []);
+    return null;
+  }
+  if (!result.ok) {
+    log2?.warn(`[${PLUGIN_NAME2}] kh degraded`, { reason: result.reason, query, elapsedMs: Date.now() - startedAt, sessionId: ctx.sessionId });
+    opts.cache.record(query, []);
+    return null;
+  }
+  const filtered = result.insights.filter((i) => (i.confidence ?? 0) >= cfg.minConfidence);
+  if (filtered.length === 0) {
+    opts.cache.record(query, []);
+    return null;
+  }
+  const payload = formatInjection(query, filtered, mode);
+  if (typeof ctx.injectContext === "function") {
+    try {
+      await ctx.injectContext(payload.markdown);
+    } catch (err) {
+      log2?.warn(`[${PLUGIN_NAME2}] injectContext threw`, {
+        error: err instanceof Error ? err.message : String(err),
+        query,
+        sessionId: ctx.sessionId
+      });
+    }
+  }
+  opts.cache.record(query, filtered);
+  log2?.info(`[${PLUGIN_NAME2}] inject complete (${mode})`, {
+    query,
+    mode,
+    candidateCount: filtered.length,
+    elapsedMs: Date.now() - startedAt,
+    sessionId: ctx.sessionId
+  });
+  return payload;
+}
+async function handleMessage(raw, opts) {
+  const cfg = opts.config ?? DEFAULT_CONFIG;
+  const mode = opts.mode ?? INJECTION_MODE;
+  const ctx = raw ?? {};
+  const log2 = ctx.log;
+  const text = (ctx.content ?? "").trim();
+  if (!shouldInject(text, cfg)) {
+    log2?.debug?.(`[${PLUGIN_NAME2}] skip (filter)`, { textLen: text.length });
+    return;
+  }
+  const query = extractQuery(text);
+  if (!query)
+    return;
+  if (opts.cache.shouldSkip(query)) {
+    log2?.debug?.(`[${PLUGIN_NAME2}] cache hit, skip`, { query });
+    return;
+  }
+  if (inflight.size >= INFLIGHT_CAP) {
+    log2?.warn(`[${PLUGIN_NAME2}] inflight cap reached, skip`, { query, inflightSize: inflight.size, cap: INFLIGHT_CAP, sessionId: ctx.sessionId });
+    return;
+  }
+  const key = inflightKey(ctx.sessionId, query);
+  inflight.add(key);
+  runKhSearchAndInject({ query, ctx, opts, mode }).catch((err) => {
+    log2?.warn(`[${PLUGIN_NAME2}] runKhSearchAndInject 顶层兜底捕获`, {
+      error: err instanceof Error ? err.message : String(err),
+      query,
+      sessionId: ctx.sessionId
+    });
+  }).finally(() => {
+    inflight.delete(key);
+  });
+}
+logLifecycle2(PLUGIN_NAME2, "import");
+var sharedClient = new KhClient;
+var sharedCache = new QueryCache(DEFAULT_CONFIG.cacheTtlMs);
+var khAutoContextServer = async (ctx) => {
+  const log2 = makePluginLogger(PLUGIN_NAME2);
+  const runtimeMode = resolveInjectionMode(sharedClient);
+  logLifecycle2(PLUGIN_NAME2, "activate", {
+    directory: ctx.directory,
+    minConfidence: DEFAULT_CONFIG.minConfidence,
+    timeoutMs: DEFAULT_CONFIG.timeoutMs,
+    mode: runtimeMode,
+    transport_available: sharedClient.hasTransport()
+  });
+  seedConstraints(sharedClient, log2).catch((err) => {
+    log2.warn("seedConstraints 顶层兜底捕获", { error: err instanceof Error ? err.message : String(err) });
+  });
+  return {
+    "chat.message": async (input, output) => {
+      await safeAsync(PLUGIN_NAME2, "chat.message", async () => {
+        const text = extractUserText(output);
+        if (!text)
+          return;
+        const injectContext = runtimeMode === "system-injected" ? createSystemInjectedHook(sharedClient, input.sessionID, log2) : async (markdown) => {
+          log2.info(`KH context candidate (${markdown.length} chars)`, {
+            sessionID: input.sessionID,
+            mode: runtimeMode,
+            preview: markdown.slice(0, 200)
+          });
+        };
+        await handleMessage({ content: text, sessionId: input.sessionID, injectContext, log: log2 }, { client: sharedClient, cache: sharedCache, mode: runtimeMode });
+      });
+    },
+    event: async ({ event }) => {
+      await safeAsync(PLUGIN_NAME2, "event", async () => {
+        const e = event;
+        if (e.type !== "session.idle")
+          return;
+        const props = e.properties;
+        const sid = props?.sessionID;
+        if (typeof sid !== "string" || !sid)
+          return;
+        sharedKhCache.onSessionEnd(sid);
+        log2.debug?.(`[${PLUGIN_NAME2}] session.idle: cleared shared cache`, { sessionID: sid });
+      });
+    }
+  };
+};
+var handler3 = khAutoContextServer;
+
+// plugins/auto-learning.ts
+var crypto = __toESM(require("node:crypto"));
+var PLUGIN_NAME3 = "auto-learning";
+var DEFAULT_CONFIG2 = {
+  minScore: 0.5,
+  cooldownMs: 24 * 60 * 60 * 1000,
+  fingerprintLimit: 256,
+  events: ["bug.fixed", "workflow.completed", "session.ended"]
+};
+var NOISE_TITLE_RE = /^\s*(test|wip|tmp|fix typo|update|chore|debug|todo|hello)\b/i;
+var TRIVIAL_KEYWORDS = ["typo", "格式化", "format", "rename", "重命名"];
+function extractInsights(ctx) {
+  if (!ctx || typeof ctx !== "object")
+    return [];
+  const out = [];
+  if (ctx.bug && ctx.bug.symptom && ctx.bug.fix) {
+    const rootCause = ctx.bug.rootCause?.trim() ?? "";
+    const baseScore = rootCause ? 0.85 : 0.55;
+    const score = adjustScore(baseScore, ctx);
+    const title = clip(`Bug 修复：${ctx.bug.symptom}`, 80);
+    if (!isTrivial(title)) {
+      out.push({
+        title,
+        content: clip([
+          `**症状**：${ctx.bug.symptom}`,
+          rootCause ? `**根因**：${rootCause}` : "",
+          `**修复**：${ctx.bug.fix}`,
+          ctx.bug.files?.length ? `**涉及**：${ctx.bug.files.slice(0, 5).join(", ")}` : ""
+        ].filter(Boolean).join(`
+
+`), 500),
+        kind: "bug-fix",
+        category: "踩坑记录",
+        tags: ctx.bug.files?.slice(0, 5),
+        score
+      });
+    }
+  }
+  if (ctx.workflow?.learnings?.length) {
+    for (const lesson of ctx.workflow.learnings) {
+      const text = lesson.trim();
+      if (!text || isTrivial(text))
+        continue;
+      const score = adjustScore(0.7, ctx);
+      out.push({
+        title: clip(`${ctx.workflow.name ?? "workflow"}：${text}`, 80),
+        content: clip(text, 500),
+        kind: "decision",
+        category: "操作指南",
+        tags: ctx.workflow.name ? [ctx.workflow.name] : undefined,
+        score
+      });
+    }
+  }
+  if (ctx.summary && ctx.positiveFeedback && !ctx.rolledBack) {
+    const text = ctx.summary.trim();
+    if (text && !isTrivial(text)) {
+      out.push({
+        title: clip(text.split(/[。.\n]/)[0] || "会话洞察", 80),
+        content: clip(text, 500),
+        kind: "decision",
+        category: "其它",
+        score: adjustScore(0.55, ctx)
+      });
+    }
+  }
+  for (const i of out)
+    i.fingerprint = fingerprint(i);
+  return out.filter((i) => i.score > 0);
+}
+function adjustScore(base, ctx) {
+  let s = base;
+  if (ctx.positiveFeedback)
+    s += 0.1;
+  if (ctx.rolledBack)
+    s -= 0.5;
+  return Math.max(-1, Math.min(1, s));
+}
+function isTrivial(text) {
+  if (!text)
+    return true;
+  if (NOISE_TITLE_RE.test(text))
+    return true;
+  const lower = text.toLowerCase();
+  return TRIVIAL_KEYWORDS.some((k) => lower.includes(k));
+}
+function clip(s, max) {
+  if (!s)
+    return "";
+  if (s.length <= max)
+    return s;
+  return s.slice(0, max - 1) + "…";
+}
+function fingerprint(i) {
+  const seed = `${i.kind}|${i.title}|${i.content}`;
+  return crypto.createHash("sha1").update(seed).digest("hex").slice(0, 16);
+}
+
+class FingerprintLRU {
+  limit;
+  list = [];
+  constructor(limit = 256) {
+    this.limit = limit;
+  }
+  has(fp, withinMs, now = Date.now()) {
+    const e = this.list.find((x) => x.fp === fp);
+    if (!e)
+      return false;
+    return now - e.ts < withinMs;
+  }
+  add(fp, now = Date.now()) {
+    this.list = this.list.filter((x) => x.fp !== fp);
+    this.list.unshift({ fp, ts: now });
+    if (this.list.length > this.limit)
+      this.list.length = this.limit;
+  }
+  size() {
+    return this.list.length;
+  }
+}
+function shouldSave(insight, lru, cfg, now = Date.now()) {
+  if (insight.score < cfg.minScore) {
+    return { decision: "skip", reason: `score ${insight.score.toFixed(2)} < ${cfg.minScore}`, insight };
+  }
+  if (insight.fingerprint && lru.has(insight.fingerprint, cfg.cooldownMs, now)) {
+    return { decision: "skip", reason: "duplicate within cooldown", insight };
+  }
+  return { decision: "save", reason: "ok", insight };
+}
+var moduleLRU = new FingerprintLRU(DEFAULT_CONFIG2.fingerprintLimit);
+async function processEvent(raw, opts = {}) {
+  const cfg = opts.config ?? DEFAULT_CONFIG2;
+  const lru = opts.lru ?? moduleLRU;
+  const now = opts.now ?? Date.now();
+  const ctx = raw ?? {};
+  const insights = extractInsights(ctx);
+  const decisions = insights.map((i) => shouldSave(i, lru, cfg, now));
+  let saved = 0;
+  let skipped = 0;
+  for (const d of decisions) {
+    if (d.decision === "skip") {
+      skipped++;
+      continue;
+    }
+    if (typeof opts.saveInsight !== "function") {
+      if (d.insight.fingerprint)
+        lru.add(d.insight.fingerprint, now);
+      skipped++;
+      continue;
+    }
+    try {
+      const res = await opts.saveInsight({
+        title: d.insight.title,
+        content: d.insight.content,
+        category: d.insight.category,
+        tags: d.insight.tags
+      });
+      if (res?.ok) {
+        if (d.insight.fingerprint)
+          lru.add(d.insight.fingerprint, now);
+        saved++;
+        opts.log?.info(`[${PLUGIN_NAME3}] saved insight: ${d.insight.title}`, { id: res.id });
+        if (typeof opts.onSaved === "function") {
+          try {
+            await opts.onSaved(d.insight, { id: res.id });
+          } catch (err) {
+            opts.log?.warn(`[${PLUGIN_NAME3}] onSaved hook 抛错（已隔离）`, { error: err instanceof Error ? err.message : String(err) });
+          }
+        }
+      } else {
+        skipped++;
+        opts.log?.warn(`[${PLUGIN_NAME3}] save failed: ${res?.error ?? "unknown"}`);
+      }
+    } catch (err) {
+      skipped++;
+      opts.log?.warn(`[${PLUGIN_NAME3}] save threw（已隔离）`, { error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { saved, skipped, decisions };
+}
+function createKhSaveInsightHook(client, log2) {
+  if (!client.hasTransport()) {
+    log2?.debug?.(`[${PLUGIN_NAME3}] createKhSaveInsightHook: transport 不可用，返 undefined（走 noop）`, {});
+    return;
+  }
+  return async ({ title, content, category, tags }) => {
+    const insight = `**${title}**
+
+${content}`;
+    try {
+      const r = await client.save({ insight, category, tags });
+      if (r.ok)
+        return { ok: true, id: r.id };
+      return { ok: false, error: `${r.reason}: ${r.message}` };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log2?.warn(`[${PLUGIN_NAME3}] saveInsight hook 抛异常（已隔离）`, { error: message });
+      return { ok: false, error: message };
+    }
+  };
+}
+logLifecycle2(PLUGIN_NAME3, "import");
+var TRIGGER_EVENT_TYPES = new Set(["session.idle", "session.error"]);
+var sharedClient2 = new KhClient;
+var autoLearningServer = async (ctx) => {
+  const log2 = makePluginLogger(PLUGIN_NAME3);
+  const saveInsight = createKhSaveInsightHook(sharedClient2, log2);
+  logLifecycle2(PLUGIN_NAME3, "activate", {
+    directory: ctx.directory,
+    triggerEventTypes: [...TRIGGER_EVENT_TYPES],
+    minScore: DEFAULT_CONFIG2.minScore,
+    transport_available: sharedClient2.hasTransport(),
+    save_insight_wired: typeof saveInsight === "function"
+  });
+  return {
+    event: async ({ event }) => {
+      await safeAsync(PLUGIN_NAME3, "event", async () => {
+        const e = event;
+        if (!e.type || !TRIGGER_EVENT_TYPES.has(e.type))
+          return;
+        const r = await processEvent({
+          type: e.type,
+          ...e.properties && typeof e.properties === "object" ? e.properties : {}
+        }, { log: log2, saveInsight });
+        if (r.saved > 0 || r.skipped > 0) {
+          log2.info(`event ${e.type}: saved=${r.saved} skipped=${r.skipped}`);
+        }
+      });
+    }
+  };
+};
+var handler4 = autoLearningServer;
+
+// src/index.ts
+function createTeamkitServer(opts) {
+  if (opts.enableDevIsolation && shouldYieldToLocalPlugin()) {
+    logLifecycle("yield_to_local: true, handlers_active: 0");
+    return {};
+  }
+  logLifecycle("handlers_active: 4 (kh-reminder + kh-auto-context + auto-learning + compaction-guard)");
+  const compactionPlugin = handler();
+  return async (ctx) => {
+    const [khReminderHooks, khAutoContextHooks, autoLearningHooks] = await Promise.all([
+      handler2(ctx),
+      handler3(ctx),
+      handler4(ctx)
+    ]);
+    return {
+      ...compactionPlugin,
+      ...khReminderHooks ?? {},
+      ...khAutoContextHooks ?? {},
+      ...autoLearningHooks ?? {}
+    };
+  };
+}
+var teamkitServer = createTeamkitServer({ enableDevIsolation: true });
+var teamkitDevServer = createTeamkitServer({ enableDevIsolation: false });