teamai-cli 0.17.0 → 0.17.1

package/dist/index.js

@@ -10,6 +10,16 @@ var __export = (target, all) => {
 };
 
 // src/utils/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  MAX_LOG_BYTES: () => MAX_LOG_BYTES,
+  _resetState: () => _resetState,
+  _setLogFilePath: () => _setLogFilePath,
+  log: () => log,
+  setSilent: () => setSilent,
+  setVerbose: () => setVerbose,
+  spinner: () => spinner
+});
 import fs from "fs";
 import path from "path";
 import chalk from "chalk";
@@ -52,6 +62,15 @@ function writeToFile(level, msg) {
     _writing = false;
   }
 }
+function _setLogFilePath(p) {
+  _logFilePath = p;
+  _dirEnsured = false;
+}
+function _resetState() {
+  _logFilePath = null;
+  _dirEnsured = false;
+  _writing = false;
+}
 function setVerbose(v) {
   verboseEnabled = v;
 }
@@ -105,6 +124,85 @@ var init_logger = __esm({
 });
 
 // src/types.ts
+var types_exports = {};
+__export(types_exports, {
+  CONTRIBUTE_BASE_THRESHOLD: () => CONTRIBUTE_BASE_THRESHOLD,
+  CONTRIBUTE_GIT_COMMIT_DOWNWEIGHT: () => CONTRIBUTE_GIT_COMMIT_DOWNWEIGHT,
+  CONTRIBUTE_KNOWLEDGE_GAP_BONUS: () => CONTRIBUTE_KNOWLEDGE_GAP_BONUS,
+  CONTRIBUTE_LOW_QUALITY_BONUS: () => CONTRIBUTE_LOW_QUALITY_BONUS,
+  CONTRIBUTE_LOW_QUALITY_THRESHOLD: () => CONTRIBUTE_LOW_QUALITY_THRESHOLD,
+  CONTRIBUTE_SCORE_CACHE_MS: () => CONTRIBUTE_SCORE_CACHE_MS,
+  CONTRIBUTE_SESSIONS_DIR: () => CONTRIBUTE_SESSIONS_DIR,
+  CONTRIBUTE_SMART_THRESHOLD: () => CONTRIBUTE_SMART_THRESHOLD,
+  CORRECTION_KEYWORDS: () => CORRECTION_KEYWORDS,
+  CORRECTION_WINDOW_MS: () => CORRECTION_WINDOW_MS,
+  CultureCompanySchema: () => CultureCompanySchema,
+  CultureFrontmatterSchema: () => CultureFrontmatterSchema,
+  CultureTeamSchema: () => CultureTeamSchema,
+  DASHBOARD_COMPACTION_THRESHOLD: () => DASHBOARD_COMPACTION_THRESHOLD,
+  DASHBOARD_DEFAULT_PORT: () => DASHBOARD_DEFAULT_PORT,
+  DASHBOARD_EVENTS_DIR: () => DASHBOARD_EVENTS_DIR,
+  DASHBOARD_EVENTS_PATH: () => DASHBOARD_EVENTS_PATH,
+  DASHBOARD_IDLE_TIMEOUT_MS: () => DASHBOARD_IDLE_TIMEOUT_MS,
+  DASHBOARD_PID_CHECK_INTERVAL_MS: () => DASHBOARD_PID_CHECK_INTERVAL_MS,
+  DASHBOARD_STALE_TIMEOUT_MS: () => DASHBOARD_STALE_TIMEOUT_MS,
+  DASHBOARD_STOPPED_DISPLAY_MS: () => DASHBOARD_STOPPED_DISPLAY_MS,
+  INTERVENTION_SCAN_MAX_BYTES: () => INTERVENTION_SCAN_MAX_BYTES,
+  LEARNINGS_LOCAL_DIR: () => LEARNINGS_LOCAL_DIR,
+  LocalConfigSchema: () => LocalConfigSchema,
+  MemberConfigSchema: () => MemberConfigSchema,
+  RESOURCE_TYPES: () => RESOURCE_TYPES,
+  SEARCH_INDEX_PATH: () => SEARCH_INDEX_PATH,
+  SEARCH_INDEX_VERSION: () => SEARCH_INDEX_VERSION,
+  SKILL_NAME_REGEX: () => SKILL_NAME_REGEX,
+  SOURCE_PULL_TTL_MS: () => SOURCE_PULL_TTL_MS,
+  ScopeEnum: () => ScopeEnum,
+  SharingConfigSchema: () => SharingConfigSchema,
+  SourceConfigSchema: () => SourceConfigSchema,
+  StateSchema: () => StateSchema,
+  TEAMAI_CLAUDEMD_END: () => TEAMAI_CLAUDEMD_END,
+  TEAMAI_CLAUDEMD_START: () => TEAMAI_CLAUDEMD_START,
+  TEAMAI_CONFIG_PATH: () => TEAMAI_CONFIG_PATH,
+  TEAMAI_CULTURE_END: () => TEAMAI_CULTURE_END,
+  TEAMAI_CULTURE_START: () => TEAMAI_CULTURE_START,
+  TEAMAI_CUSTOM_HOOK_PREFIX: () => TEAMAI_CUSTOM_HOOK_PREFIX,
+  TEAMAI_ENV_END: () => TEAMAI_ENV_END,
+  TEAMAI_ENV_START: () => TEAMAI_ENV_START,
+  TEAMAI_HOME: () => TEAMAI_HOME,
+  TEAMAI_HOOK_DESCRIPTION_PREFIX: () => TEAMAI_HOOK_DESCRIPTION_PREFIX,
+  TEAMAI_KNOWN_SKILLS_PATH: () => TEAMAI_KNOWN_SKILLS_PATH,
+  TEAMAI_PUSHIGNORE_PATH: () => TEAMAI_PUSHIGNORE_PATH,
+  TEAMAI_RECALL_RULES_END: () => TEAMAI_RECALL_RULES_END,
+  TEAMAI_RECALL_RULES_START: () => TEAMAI_RECALL_RULES_START,
+  TEAMAI_RULES_END: () => TEAMAI_RULES_END,
+  TEAMAI_RULES_START: () => TEAMAI_RULES_START,
+  TEAMAI_SESSIONS_DIR: () => TEAMAI_SESSIONS_DIR,
+  TEAMAI_SOURCES_DIR: () => TEAMAI_SOURCES_DIR,
+  TEAMAI_STATE_PATH: () => TEAMAI_STATE_PATH,
+  TEAMAI_TOKEN_PATH: () => TEAMAI_TOKEN_PATH,
+  TEAMAI_UPDATE_LOCK_PATH: () => TEAMAI_UPDATE_LOCK_PATH,
+  TEAMAI_USAGE_PATH: () => TEAMAI_USAGE_PATH,
+  TRANSCRIPT_INTERRUPT_PREFIX: () => TRANSCRIPT_INTERRUPT_PREFIX,
+  TRANSCRIPT_REJECT_MARKERS: () => TRANSCRIPT_REJECT_MARKERS,
+  TRANSCRIPT_SYSTEM_PREFIXES: () => TRANSCRIPT_SYSTEM_PREFIXES,
+  TeamaiConfigSchema: () => TeamaiConfigSchema,
+  ToolPathsSchema: () => ToolPathsSchema,
+  UsageEventSchema: () => UsageEventSchema,
+  VOTES_LOCAL_DIR: () => VOTES_LOCAL_DIR,
+  addTokenUsage: () => addTokenUsage,
+  areTeamHooksDisabled: () => areTeamHooksDisabled,
+  emptyTokenUsage: () => emptyTokenUsage,
+  getConfigPath: () => getConfigPath,
+  getHooksSharing: () => getHooksSharing,
+  getManagedHooksPath: () => getManagedHooksPath,
+  getPushignorePath: () => getPushignorePath,
+  getRecallSharing: () => getRecallSharing,
+  getStatePath: () => getStatePath,
+  getTeamaiHome: () => getTeamaiHome,
+  isRecallEnabled: () => isRecallEnabled,
+  resolveBaseDir: () => resolveBaseDir,
+  totalTokens: () => totalTokens
+});
 import { z } from "zod";
 import path2 from "path";
 function getHooksSharing(config) {
@@ -173,7 +271,7 @@ function getPushignorePath() {
 function areTeamHooksDisabled() {
   return process.env.TEAMAI_HOOKS_DISABLED === "1" || process.env.TEAMAI_HOOKS_DISABLED === "true";
 }
-var ToolPathsSchema, ScopeEnum, SharingConfigSchema, SourceConfigSchema, SOURCE_PULL_TTL_MS, TEAMAI_SOURCES_DIR, TeamaiConfigSchema, MemberConfigSchema, LocalConfigSchema, StateSchema, TEAMAI_HOME, TEAMAI_CONFIG_PATH, TEAMAI_STATE_PATH, TEAMAI_TOKEN_PATH, TEAMAI_UPDATE_LOCK_PATH, TEAMAI_RULES_START, TEAMAI_RULES_END, TEAMAI_HOOK_DESCRIPTION_PREFIX, TEAMAI_CUSTOM_HOOK_PREFIX, TEAMAI_ENV_START, TEAMAI_ENV_END, TEAMAI_CULTURE_START, TEAMAI_CULTURE_END, TEAMAI_CLAUDEMD_START, TEAMAI_CLAUDEMD_END, TEAMAI_RECALL_RULES_START, TEAMAI_RECALL_RULES_END, SKILL_NAME_REGEX, TEAMAI_USAGE_PATH, TEAMAI_KNOWN_SKILLS_PATH, TEAMAI_PUSHIGNORE_PATH, TEAMAI_SESSIONS_DIR, UsageEventSchema, DASHBOARD_EVENTS_DIR, DASHBOARD_EVENTS_PATH, DASHBOARD_DEFAULT_PORT, DASHBOARD_IDLE_TIMEOUT_MS, DASHBOARD_STALE_TIMEOUT_MS, DASHBOARD_COMPACTION_THRESHOLD, DASHBOARD_STOPPED_DISPLAY_MS, DASHBOARD_PID_CHECK_INTERVAL_MS, CORRECTION_WINDOW_MS, CORRECTION_KEYWORDS, INTERVENTION_SCAN_MAX_BYTES, TRANSCRIPT_INTERRUPT_PREFIX, TRANSCRIPT_SYSTEM_PREFIXES, TRANSCRIPT_REJECT_MARKERS, CONTRIBUTE_BASE_THRESHOLD, CONTRIBUTE_SMART_THRESHOLD, CONTRIBUTE_SCORE_CACHE_MS, CONTRIBUTE_KNOWLEDGE_GAP_BONUS, CONTRIBUTE_LOW_QUALITY_BONUS, CONTRIBUTE_LOW_QUALITY_THRESHOLD, CONTRIBUTE_GIT_COMMIT_DOWNWEIGHT, CONTRIBUTE_SESSIONS_DIR, SEARCH_INDEX_VERSION, LEARNINGS_LOCAL_DIR, SEARCH_INDEX_PATH, VOTES_LOCAL_DIR, CultureCompanySchema, CultureTeamSchema, CultureFrontmatterSchema;
+var ToolPathsSchema, ScopeEnum, SharingConfigSchema, SourceConfigSchema, SOURCE_PULL_TTL_MS, TEAMAI_SOURCES_DIR, TeamaiConfigSchema, MemberConfigSchema, LocalConfigSchema, StateSchema, TEAMAI_HOME, TEAMAI_CONFIG_PATH, TEAMAI_STATE_PATH, TEAMAI_TOKEN_PATH, TEAMAI_UPDATE_LOCK_PATH, RESOURCE_TYPES, TEAMAI_RULES_START, TEAMAI_RULES_END, TEAMAI_HOOK_DESCRIPTION_PREFIX, TEAMAI_CUSTOM_HOOK_PREFIX, TEAMAI_ENV_START, TEAMAI_ENV_END, TEAMAI_CULTURE_START, TEAMAI_CULTURE_END, TEAMAI_CLAUDEMD_START, TEAMAI_CLAUDEMD_END, TEAMAI_RECALL_RULES_START, TEAMAI_RECALL_RULES_END, SKILL_NAME_REGEX, TEAMAI_USAGE_PATH, TEAMAI_KNOWN_SKILLS_PATH, TEAMAI_PUSHIGNORE_PATH, TEAMAI_SESSIONS_DIR, UsageEventSchema, DASHBOARD_EVENTS_DIR, DASHBOARD_EVENTS_PATH, DASHBOARD_DEFAULT_PORT, DASHBOARD_IDLE_TIMEOUT_MS, DASHBOARD_STALE_TIMEOUT_MS, DASHBOARD_COMPACTION_THRESHOLD, DASHBOARD_STOPPED_DISPLAY_MS, DASHBOARD_PID_CHECK_INTERVAL_MS, CORRECTION_WINDOW_MS, CORRECTION_KEYWORDS, INTERVENTION_SCAN_MAX_BYTES, TRANSCRIPT_INTERRUPT_PREFIX, TRANSCRIPT_SYSTEM_PREFIXES, TRANSCRIPT_REJECT_MARKERS, CONTRIBUTE_BASE_THRESHOLD, CONTRIBUTE_SMART_THRESHOLD, CONTRIBUTE_SCORE_CACHE_MS, CONTRIBUTE_KNOWLEDGE_GAP_BONUS, CONTRIBUTE_LOW_QUALITY_BONUS, CONTRIBUTE_LOW_QUALITY_THRESHOLD, CONTRIBUTE_GIT_COMMIT_DOWNWEIGHT, CONTRIBUTE_SESSIONS_DIR, SEARCH_INDEX_VERSION, LEARNINGS_LOCAL_DIR, SEARCH_INDEX_PATH, VOTES_LOCAL_DIR, CultureCompanySchema, CultureTeamSchema, CultureFrontmatterSchema;
 var init_types = __esm({
   "src/types.ts"() {
     "use strict";
@@ -281,7 +379,9 @@ var init_types = __esm({
       /** Tags the user has subscribed to. If empty/undefined, pull all resources. */
       subscribedTags: z.array(z.string()).optional(),
       /** User-level override for recall feature. When set, takes precedence over team config. */
-      recallEnabled: z.boolean().optional()
+      recallEnabled: z.boolean().optional(),
+      /** When set, only inject hooks into these agents. Additive across multiple init --agent runs. */
+      enabledAgents: z.array(z.string()).optional()
     });
     StateSchema = z.object({
       lastPush: z.string().nullable().default(null),
@@ -299,6 +399,7 @@ var init_types = __esm({
     TEAMAI_STATE_PATH = `${TEAMAI_HOME}/state.json`;
     TEAMAI_TOKEN_PATH = `${TEAMAI_HOME}/token`;
     TEAMAI_UPDATE_LOCK_PATH = `${TEAMAI_HOME}/.update-lock`;
+    RESOURCE_TYPES = ["skills", "rules", "docs", "env", "agents", "hooks"];
     TEAMAI_RULES_START = "<!-- [teamai:rules:start] -->";
     TEAMAI_RULES_END = "<!-- [teamai:rules:end] -->";
     TEAMAI_HOOK_DESCRIPTION_PREFIX = "[teamai]";
@@ -368,7 +469,7 @@ var init_types = __esm({
     CONTRIBUTE_LOW_QUALITY_THRESHOLD = 5;
     CONTRIBUTE_GIT_COMMIT_DOWNWEIGHT = 0;
     CONTRIBUTE_SESSIONS_DIR = `${TEAMAI_HOME}/sessions`;
-    SEARCH_INDEX_VERSION = 5;
+    SEARCH_INDEX_VERSION = 6;
     LEARNINGS_LOCAL_DIR = `${TEAMAI_HOME}/learnings`;
     SEARCH_INDEX_PATH = `${TEAMAI_HOME}/search-index.json`;
     VOTES_LOCAL_DIR = `${TEAMAI_HOME}/votes`;
@@ -1503,9 +1604,10 @@ async function getHookStatus(settingsPath, tool) {
   });
   return present ? "installed" : "missing";
 }
-async function injectHooksToAllTools(toolPaths, baseDir) {
+async function injectHooksToAllTools(toolPaths, baseDir, filterAgents2) {
   const resolvedBaseDir = baseDir ?? (process.env.HOME ?? "");
   for (const [tool, paths] of Object.entries(toolPaths)) {
+    if (filterAgents2 && !filterAgents2.includes(tool)) continue;
     if (paths.settings) {
       const toolRoot = path9.join(resolvedBaseDir, paths.settings.split("/")[0]);
       if (!await pathExists(toolRoot)) continue;
@@ -1530,6 +1632,7 @@ async function injectHooksToAllTools(toolPaths, baseDir) {
 }
 async function reconcileHooksToAllTools(toolPaths, baseDir, teamDefs, manifestPath, opts = {}) {
   for (const [tool, paths] of Object.entries(toolPaths)) {
+    if (opts.filterAgents && !opts.filterAgents.includes(tool)) continue;
     if (!paths.settings) continue;
     if (!opts.force) {
       const toolRoot = path9.join(baseDir, paths.settings.split("/")[0]);
@@ -1551,9 +1654,11 @@ async function reconcileTeamHooksForConfig(teamConfig, localConfig, opts = {}) {
   const { defs: teamDefs, builtin } = opts.removeAll ? { defs: [], builtin: void 0 } : await resolveTeamHooks(teamConfig, localConfig.repo.localPath, { auto: opts.auto, silent: opts.silent });
   const baseDir = resolveBaseDir(localConfig);
   const manifestPath = getManagedHooksPath(localConfig.scope, localConfig.projectRoot);
+  const filterAgents2 = opts.filterAgents ?? localConfig.enabledAgents;
   await reconcileHooksToAllTools(teamConfig.toolPaths, baseDir, teamDefs, manifestPath, {
     removeAll: opts.removeAll,
-    builtinOverride: builtin
+    builtinOverride: builtin,
+    filterAgents: filterAgents2
   });
   return teamDefs;
 }
@@ -3056,7 +3161,7 @@ var init_builtin_skills = __esm({
     init_types();
     init_base();
     init_skills();
-    BUILTIN_SKILL_NAMES = /* @__PURE__ */ new Set(["teamai-share-learnings", "team-wiki-codebase"]);
+    BUILTIN_SKILL_NAMES = /* @__PURE__ */ new Set(["teamai-share-learnings", "team-wiki-codebase", "teamai-workflow", "teamai-import"]);
     RECALL_DEPENDENT_SKILLS = /* @__PURE__ */ new Set(["teamai-share-learnings", "team-wiki-codebase"]);
   }
 });
@@ -6283,6 +6388,11 @@ async function initHttp(url, options) {
       log.debug(`Role selection skipped: ${msg}`);
     }
   }
+  if (options.agent) {
+    const existing = await loadLocalConfigForScope(scope, projectRoot);
+    const prev = existing?.enabledAgents ?? [];
+    localConfig.enabledAgents = [.../* @__PURE__ */ new Set([...prev, options.agent])];
+  }
   await ensureDir(teamaiHome);
   if (scope === "project") {
     await saveLocalConfigForScope(localConfig, scope, projectRoot);
@@ -6297,7 +6407,8 @@ async function initHttp(url, options) {
     await saveStateForScope(state, scope, projectRoot);
   } catch {
   }
-  await reconcileTeamHooksForConfig(teamConfig, localConfig);
+  const filterAgents2 = options.agent ? [options.agent] : void 0;
+  await reconcileTeamHooksForConfig(teamConfig, localConfig, { filterAgents: filterAgents2 });
   if (reportingOnly) {
     log.success("teamai initialized (HTTP, reporting-only \u2014 /repo not live yet)!");
     log.info("Status reporting is active now; skills/rules will sync automatically once /repo is available.");
@@ -6544,6 +6655,11 @@ async function init(options) {
       process.exit(1);
     }
   }
+  if (options.agent) {
+    const existing = await loadLocalConfigForScope(scope, projectRoot);
+    const prev = existing?.enabledAgents ?? [];
+    localConfig.enabledAgents = [.../* @__PURE__ */ new Set([...prev, options.agent])];
+  }
   await ensureDir(teamaiHome);
   if (scope === "project") {
     await saveLocalConfigForScope(localConfig, scope, projectRoot);
@@ -6583,7 +6699,8 @@ async function init(options) {
   }
   const reloadedTeamConfig = await loadTeamConfig(localPath);
   if (reloadedTeamConfig) {
-    await reconcileTeamHooksForConfig(reloadedTeamConfig, localConfig);
+    const filterAgents2 = options.agent ? [options.agent] : void 0;
+    await reconcileTeamHooksForConfig(reloadedTeamConfig, localConfig, { filterAgents: filterAgents2 });
   }
   log.success("teamai initialized successfully!");
   log.info("Skills, rules, env and docs will auto-sync on each session start (via hooks).");
@@ -6782,6 +6899,300 @@ var init_tokenizer = __esm({
   }
 });
 
+// src/votes.ts
+var votes_exports = {};
+__export(votes_exports, {
+  incrementRecalled: () => incrementRecalled,
+  incrementUpvoted: () => incrementUpvoted,
+  loadUserVotes: () => loadUserVotes,
+  mergeDeltas: () => mergeDeltas,
+  migrateV1ToV2: () => migrateV1ToV2,
+  recallFeedback: () => recallFeedback,
+  saveUserVotes: () => saveUserVotes,
+  syncVotesToTeam: () => syncVotesToTeam
+});
+import path30 from "path";
+import YAML9 from "yaml";
+function migrateV1ToV2(v1) {
+  const votes = {};
+  for (const [docId, entry] of Object.entries(v1.votes)) {
+    votes[docId] = {
+      recalled_count: 1,
+      upvoted_count: 0,
+      last_recalled_at: entry.at
+    };
+  }
+  return { version: 2, votes, deltas: {} };
+}
+async function loadUserVotes(votePath) {
+  const content = await readFileSafe(votePath);
+  if (!content) return { version: 2, votes: {}, deltas: {} };
+  let parsed;
+  try {
+    parsed = YAML9.parse(content);
+  } catch {
+    return { version: 2, votes: {}, deltas: {} };
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return { version: 2, votes: {}, deltas: {} };
+  }
+  const obj = parsed;
+  if (obj["version"] === 2) {
+    const v2 = obj;
+    if (!v2.deltas) v2.deltas = {};
+    return v2;
+  }
+  if (obj["votes"] !== void 0) {
+    const migrated = migrateV1ToV2(obj);
+    await saveUserVotes(votePath, migrated);
+    return migrated;
+  }
+  return { version: 2, votes: {}, deltas: {} };
+}
+async function saveUserVotes(votePath, votes) {
+  await ensureDir(path30.dirname(votePath));
+  await writeFile(votePath, YAML9.stringify(votes));
+}
+async function incrementRecalled(votePath, docIds) {
+  if (docIds.length === 0) return;
+  const data = await loadUserVotes(votePath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const docId of docIds) {
+    if (!data.votes[docId]) {
+      data.votes[docId] = { recalled_count: 0, upvoted_count: 0, last_recalled_at: "" };
+    }
+    data.votes[docId].recalled_count++;
+    data.votes[docId].last_recalled_at = now;
+    if (!data.deltas[docId]) {
+      data.deltas[docId] = { recalled_delta: 0, upvoted_delta: 0 };
+    }
+    data.deltas[docId].recalled_delta++;
+  }
+  await saveUserVotes(votePath, data);
+}
+async function incrementUpvoted(votePath, docIds) {
+  if (docIds.length === 0) return;
+  const data = await loadUserVotes(votePath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const docId of docIds) {
+    if (!data.votes[docId]) {
+      data.votes[docId] = { recalled_count: 0, upvoted_count: 0, last_recalled_at: "" };
+    }
+    data.votes[docId].upvoted_count++;
+    data.votes[docId].last_upvoted_at = now;
+    if (!data.deltas[docId]) {
+      data.deltas[docId] = { recalled_delta: 0, upvoted_delta: 0 };
+    }
+    data.deltas[docId].upvoted_delta++;
+  }
+  await saveUserVotes(votePath, data);
+}
+function mergeDeltas(local, remote) {
+  const votes = {};
+  for (const [docId, entry] of Object.entries(remote.votes)) {
+    votes[docId] = { ...entry };
+  }
+  for (const [docId, delta] of Object.entries(local.deltas)) {
+    if (!votes[docId]) {
+      votes[docId] = { recalled_count: 0, upvoted_count: 0, last_recalled_at: "" };
+    }
+    votes[docId].recalled_count = Math.max(0, votes[docId].recalled_count + delta.recalled_delta);
+    votes[docId].upvoted_count = Math.max(0, votes[docId].upvoted_count + delta.upvoted_delta);
+    const localEntry = local.votes[docId];
+    if (localEntry) {
+      if (localEntry.last_recalled_at > (votes[docId].last_recalled_at ?? "")) {
+        votes[docId].last_recalled_at = localEntry.last_recalled_at;
+      }
+      if (localEntry.last_upvoted_at !== void 0 && localEntry.last_upvoted_at > (votes[docId].last_upvoted_at ?? "")) {
+        votes[docId].last_upvoted_at = localEntry.last_upvoted_at;
+      }
+    }
+  }
+  return { version: 2, votes, deltas: {} };
+}
+async function syncVotesToTeam(repoPath, username, localVotesDir) {
+  const localVotePath = path30.join(localVotesDir, `${username}.yaml`);
+  const remoteVotePath = path30.join(repoPath, "votes", `${username}.yaml`);
+  const local = await loadUserVotes(localVotePath);
+  if (Object.keys(local.deltas).length === 0) {
+    return false;
+  }
+  const remote = await loadUserVotes(remoteVotePath);
+  const merged = mergeDeltas(local, remote);
+  await saveUserVotes(remoteVotePath, merged);
+  await saveUserVotes(localVotePath, { ...local, votes: merged.votes, deltas: {} });
+  return true;
+}
+async function recallFeedback(opts) {
+  const { requireInit: requireInit3 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { localConfig } = await requireInit3();
+  const { username } = localConfig;
+  const { VOTES_LOCAL_DIR: VOTES_LOCAL_DIR2 } = await Promise.resolve().then(() => (init_types(), types_exports));
+  const votePath = path30.join(VOTES_LOCAL_DIR2, `${username}.yaml`);
+  if (opts.positive) {
+    await incrementUpvoted(votePath, [opts.positive]);
+    log.success(`Upvoted: ${opts.positive}`);
+    return;
+  }
+  if (opts.negative) {
+    const data = await loadUserVotes(votePath);
+    if (!data.votes[opts.negative]) {
+      log.warn(`Document not found in votes: ${opts.negative}`);
+      return;
+    }
+    const entry = data.votes[opts.negative];
+    if (entry.upvoted_count <= 0) {
+      log.warn(`No upvotes to decrement for: ${opts.negative}`);
+      return;
+    }
+    const existingDelta = data.deltas[opts.negative] ?? { recalled_delta: 0, upvoted_delta: 0 };
+    const updated = {
+      ...data,
+      votes: {
+        ...data.votes,
+        [opts.negative]: { ...entry, upvoted_count: entry.upvoted_count - 1 }
+      },
+      deltas: {
+        ...data.deltas,
+        [opts.negative]: { ...existingDelta, upvoted_delta: existingDelta.upvoted_delta - 1 }
+      }
+    };
+    await saveUserVotes(votePath, updated);
+    log.success(`Negative signal recorded for: ${opts.negative}`);
+    return;
+  }
+  log.error("Usage: teamai recall feedback --positive <docId> | --negative <docId>");
+}
+var init_votes = __esm({
+  "src/votes.ts"() {
+    "use strict";
+    init_fs();
+    init_logger();
+  }
+});
+
+// src/maintenance/confidence.ts
+var confidence_exports = {};
+__export(confidence_exports, {
+  computeAllConfidence: () => computeAllConfidence,
+  computeConfidence: () => computeConfidence,
+  writeBackConfidence: () => writeBackConfidence
+});
+import path31 from "path";
+import matter2 from "gray-matter";
+function computeConfidence(factors) {
+  const { recalledCount, upvotedCount, lastRecalledAt } = factors;
+  const base = Math.min(1, recalledCount * 0.1 + upvotedCount * 0.3);
+  let daysSinceRecall = 180;
+  if (lastRecalledAt) {
+    const elapsed = Date.now() - new Date(lastRecalledAt).getTime();
+    daysSinceRecall = Math.max(0, elapsed / (1e3 * 60 * 60 * 24));
+  }
+  const recency = Math.max(0, 1 - daysSinceRecall / 180);
+  const ratio = upvotedCount / Math.max(1, recalledCount);
+  const score = base * 0.4 + recency * 0.3 + ratio * 0.3;
+  return Math.round(score * 100) / 100;
+}
+async function computeAllConfidence(votesDir) {
+  const result = /* @__PURE__ */ new Map();
+  const { loadUserVotes: loadUserVotes2 } = await Promise.resolve().then(() => (init_votes(), votes_exports));
+  const files = await listFiles(votesDir);
+  const aggregated = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
+    try {
+      const data = await loadUserVotes2(path31.join(votesDir, file));
+      for (const [docId, entry] of Object.entries(data.votes)) {
+        const existing = aggregated.get(docId) ?? { recalled: 0, upvoted: 0, lastRecalled: "" };
+        existing.recalled += entry.recalled_count ?? 0;
+        existing.upvoted += entry.upvoted_count ?? 0;
+        if (entry.last_recalled_at > existing.lastRecalled) {
+          existing.lastRecalled = entry.last_recalled_at;
+        }
+        if (entry.last_upvoted_at && (!existing.lastUpvoted || entry.last_upvoted_at > existing.lastUpvoted)) {
+          existing.lastUpvoted = entry.last_upvoted_at;
+        }
+        aggregated.set(docId, existing);
+      }
+    } catch {
+      log.debug(`confidence: failed to parse votes file: ${file}`);
+    }
+  }
+  for (const [docId, data] of aggregated) {
+    const factors = {
+      recalledCount: data.recalled,
+      upvotedCount: data.upvoted,
+      lastRecalledAt: data.lastRecalled,
+      lastUpvotedAt: data.lastUpvoted
+    };
+    result.set(docId, computeConfidence(factors));
+  }
+  return result;
+}
+async function writeBackConfidence(learningsDir, confidenceMap) {
+  let updated = 0;
+  const files = await listFiles(learningsDir);
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const docId = file.replace(/\.md$/i, "");
+    const newConf = confidenceMap.get(docId);
+    if (newConf === void 0) continue;
+    const absPath = path31.join(learningsDir, file);
+    const content = await readFileSafe(absPath);
+    if (!content) continue;
+    try {
+      const { data, content: body } = matter2(content);
+      const existingConf = typeof data.confidence === "number" ? data.confidence : void 0;
+      if (existingConf !== void 0 && Math.abs(existingConf - newConf) <= 0.05) continue;
+      data.confidence = newConf;
+      const newContent = matter2.stringify(body, data);
+      await writeFile(absPath, newContent);
+      updated++;
+    } catch {
+      log.debug(`confidence: failed to update frontmatter for: ${file}`);
+    }
+  }
+  if (updated > 0) {
+    log.info(`Updated confidence scores for ${updated} learning(s)`);
+  }
+  return updated;
+}
+var init_confidence = __esm({
+  "src/maintenance/confidence.ts"() {
+    "use strict";
+    init_fs();
+    init_logger();
+  }
+});
+
+// src/maintenance/hot-cold.ts
+var hot_cold_exports = {};
+__export(hot_cold_exports, {
+  COLD_PENALTY: () => COLD_PENALTY,
+  HOT_THRESHOLD: () => HOT_THRESHOLD,
+  annotateHotness: () => annotateHotness
+});
+function annotateHotness(entries, confidenceMap) {
+  for (const entry of entries) {
+    const docId = entry.filename.replace(/\.md$/i, "");
+    const confidence = confidenceMap.get(docId);
+    entry.confidence = confidence;
+    if (confidence === void 0) {
+      entry.hotness = 1;
+    } else {
+      entry.hotness = confidence >= HOT_THRESHOLD ? 1 : COLD_PENALTY;
+    }
+  }
+}
+var HOT_THRESHOLD, COLD_PENALTY;
+var init_hot_cold = __esm({
+  "src/maintenance/hot-cold.ts"() {
+    "use strict";
+    HOT_THRESHOLD = 0.5;
+    COLD_PENALTY = 0.3;
+  }
+});
+
 // src/utils/search-index.ts
 var search_index_exports = {};
 __export(search_index_exports, {
@@ -6795,8 +7206,8 @@ __export(search_index_exports, {
   titleFromFilename: () => titleFromFilename,
   tokenize: () => tokenize
 });
-import path30 from "path";
-import matter2 from "gray-matter";
+import path32 from "path";
+import matter3 from "gray-matter";
 function getSearchIndexPath() {
   return `${process.env.HOME ?? ""}/.teamai/search-index.json`;
 }
@@ -6850,7 +7261,7 @@ function inferDomain(frontmatterDomain, tags, filePath, type) {
 function parseLearningDoc(content, filename) {
   if (!content.trim()) return null;
   try {
-    const { data, content: body } = matter2(content);
+    const { data, content: body } = matter3(content);
     const meta = {
       title: typeof data.title === "string" ? data.title : void 0,
       author: typeof data.author === "string" ? data.author : void 0,
@@ -6871,31 +7282,61 @@ function titleFromFilename(filename) {
   return filename.replace(/\.md$/i, "").replace(/-\d{4}-\d{2}-\d{2}.*$/, "").replace(/[-_]/g, " ").trim();
 }
 async function aggregateVotes(votesDir) {
-  const counts = /* @__PURE__ */ new Map();
+  const scores = /* @__PURE__ */ new Map();
+  const agg = /* @__PURE__ */ new Map();
   const files = await listFiles(votesDir);
   for (const file of files) {
     if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
-    const content = await readFileSafe(path30.join(votesDir, file));
+    const content = await readFileSafe(path32.join(votesDir, file));
     if (!content) continue;
     try {
       const YAML18 = (await import("yaml")).default;
       const parsed = YAML18.parse(content);
-      if (parsed?.votes) {
-        for (const docId of Object.keys(parsed.votes)) {
-          counts.set(docId, (counts.get(docId) ?? 0) + 1);
+      if (!parsed?.votes) continue;
+      if (parsed.version === 2) {
+        const votes = parsed.votes;
+        for (const [docId, entry] of Object.entries(votes)) {
+          const recalled = entry.recalled_count ?? 0;
+          const upvoted = entry.upvoted_count ?? 0;
+          scores.set(docId, (scores.get(docId) ?? 0) + recalled * 0.3 + upvoted * 1);
+          const existing = agg.get(docId) ?? { recalled: 0, upvoted: 0, lastRecalled: "" };
+          existing.recalled += recalled;
+          existing.upvoted += upvoted;
+          if (entry.last_recalled_at > existing.lastRecalled) {
+            existing.lastRecalled = entry.last_recalled_at;
+          }
+          agg.set(docId, existing);
+        }
+      } else {
+        const votes = parsed.votes;
+        for (const [docId, entry] of Object.entries(votes)) {
+          scores.set(docId, (scores.get(docId) ?? 0) + 1);
+          const existing = agg.get(docId) ?? { recalled: 0, upvoted: 0, lastRecalled: "" };
+          existing.recalled += 1;
+          if (entry.at > existing.lastRecalled) existing.lastRecalled = entry.at;
+          agg.set(docId, existing);
         }
       }
     } catch {
       log.error(`Failed to parse votes file: ${file}`);
     }
   }
-  return counts;
+  const { computeConfidence: computeConfidence2 } = await Promise.resolve().then(() => (init_confidence(), confidence_exports));
+  const confidenceMap = /* @__PURE__ */ new Map();
+  for (const [docId, data] of agg) {
+    confidenceMap.set(docId, computeConfidence2({
+      recalledCount: data.recalled,
+      upvotedCount: data.upvoted,
+      lastRecalledAt: data.lastRecalled
+    }));
+  }
+  return { scores, confidenceMap };
 }
 async function entryFromMdFile(absPath, filenameForId, type, voteCounts) {
-  const basename = path30.basename(absPath);
+  const basename = path32.basename(absPath);
   if (basename === CODEBASE_FULL_FILENAME) {
-    const dir = path30.dirname(absPath);
-    const indexPath = path30.join(dir, CODEBASE_INDEX_FILENAME);
+    const dir = path32.dirname(absPath);
+    const indexPath = path32.join(dir, CODEBASE_INDEX_FILENAME);
     if (await pathExists(indexPath)) {
       log.debug(`Skipping ${absPath}: codebase-index.md exists in same directory`);
       return null;
@@ -6914,7 +7355,7 @@ async function entryFromMdFile(absPath, filenameForId, type, voteCounts) {
   const tags = meta.tags ?? [];
   const rawFrontmatterDomain = (() => {
     try {
-      return matter2(content).data["domain"];
+      return matter3(content).data["domain"];
     } catch {
       return void 0;
     }
@@ -6952,7 +7393,7 @@ async function collectFlatMdEntries(dir, type, voteCounts) {
   const out = [];
   for (const filename of files) {
     if (!filename.endsWith(".md")) continue;
-    const e = await entryFromMdFile(path30.join(dir, filename), filename, type, voteCounts);
+    const e = await entryFromMdFile(path32.join(dir, filename), filename, type, voteCounts);
     if (e) out.push(e);
   }
   return out;
@@ -6963,7 +7404,7 @@ async function collectRecursiveMdEntries(dir, type, voteCounts) {
   const out = [];
   for (const rel of files) {
     if (!rel.endsWith(".md")) continue;
-    const e = await entryFromMdFile(path30.join(dir, rel), rel, type, voteCounts);
+    const e = await entryFromMdFile(path32.join(dir, rel), rel, type, voteCounts);
     if (e) out.push(e);
   }
   return out;
@@ -6975,8 +7416,8 @@ async function collectSkillEntries(dir, voteCounts) {
     const subdirs = await listDirs(current);
     for (const sub of subdirs) {
       if (sub.startsWith(".")) continue;
-      const subPath = path30.join(current, sub);
-      const skillMd = path30.join(subPath, "SKILL.md");
+      const subPath = path32.join(current, sub);
+      const skillMd = path32.join(subPath, "SKILL.md");
       if (await pathExists(skillMd)) {
         const e = await entryFromMdFile(skillMd, `${sub}.md`, "skills", voteCounts);
         if (e) out.push(e);
@@ -6991,7 +7432,8 @@ async function collectSkillEntries(dir, voteCounts) {
 async function buildIndex(optionsOrLearningsDir, votesDir, indexPath) {
   const start = Date.now();
   const opts = typeof optionsOrLearningsDir === "string" ? { learningsDir: optionsOrLearningsDir, votesDir, indexPath } : optionsOrLearningsDir;
-  const voteCounts = opts.votesDir ? await aggregateVotes(opts.votesDir) : /* @__PURE__ */ new Map();
+  const voteAgg = opts.votesDir ? await aggregateVotes(opts.votesDir) : { scores: /* @__PURE__ */ new Map(), confidenceMap: /* @__PURE__ */ new Map() };
+  const voteCounts = voteAgg.scores;
   const entries = [];
   if (opts.learningsDir) {
     entries.push(...await collectFlatMdEntries(opts.learningsDir, "learnings", voteCounts));
@@ -7008,6 +7450,13 @@ async function buildIndex(optionsOrLearningsDir, votesDir, indexPath) {
   if (opts.codebaseDir) {
     entries.push(...await collectRecursiveMdEntries(opts.codebaseDir, "docs", voteCounts));
   }
+  if (voteAgg.confidenceMap.size > 0) {
+    try {
+      const { annotateHotness: annotateHotness2 } = await Promise.resolve().then(() => (init_hot_cold(), hot_cold_exports));
+      annotateHotness2(entries, voteAgg.confidenceMap);
+    } catch {
+    }
+  }
   const df = {};
   for (const entry of entries) {
     for (const token of new Set(entry.tokens)) {
@@ -7085,9 +7534,12 @@ function search(query, index, limit = 5) {
       const domainMultiplier = domainWeightRow[entry.domain ?? "neutral"];
       const typeMultiplier = TYPE_BONUS[entry.type];
       score *= domainMultiplier * typeMultiplier;
-      if (path30.basename(entry.path ?? "") === CODEBASE_INDEX_FILENAME) {
+      if (path32.basename(entry.path ?? "") === CODEBASE_INDEX_FILENAME) {
         score *= CODEBASE_INDEX_WEIGHT_BOOST;
       }
+      if (entry.hotness !== void 0 && entry.hotness < 1) {
+        score *= entry.hotness;
+      }
       results.push({ entry, score });
     }
   }
@@ -7278,12 +7730,12 @@ __export(usage_tracker_exports, {
   updateKnownSkills: () => updateKnownSkills
 });
 import fs10 from "fs";
-import path31 from "path";
+import path33 from "path";
 function getUsagePath() {
-  return path31.join(process.env.HOME ?? "", ".teamai", "usage.jsonl");
+  return path33.join(process.env.HOME ?? "", ".teamai", "usage.jsonl");
 }
 function getKnownSkillsPath() {
-  return path31.join(process.env.HOME ?? "", ".teamai", "known-skills.json");
+  return path33.join(process.env.HOME ?? "", ".teamai", "known-skills.json");
 }
 function extractSkillName(toolInput) {
   try {
@@ -7309,13 +7761,13 @@ function isValidSkillName(name) {
 async function skillExistsOnDisk(skillName) {
   const home = process.env.HOME ?? "";
   for (const dir of SKILL_DIRS) {
-    const skillMd = path31.join(home, dir, skillName, "SKILL.md");
+    const skillMd = path33.join(home, dir, skillName, "SKILL.md");
     if (await pathExists(skillMd)) return true;
   }
   const cwd = process.cwd();
-  if (path31.resolve(cwd) !== path31.resolve(home)) {
+  if (path33.resolve(cwd) !== path33.resolve(home)) {
     for (const dir of SKILL_DIRS) {
-      const skillMd = path31.join(cwd, dir, skillName, "SKILL.md");
+      const skillMd = path33.join(cwd, dir, skillName, "SKILL.md");
       if (await pathExists(skillMd)) return true;
     }
   }
@@ -7323,7 +7775,7 @@ async function skillExistsOnDisk(skillName) {
 }
 async function appendUsageEvent(event) {
   try {
-    await ensureDir(path31.dirname(getUsagePath()));
+    await ensureDir(path33.dirname(getUsagePath()));
     const line = JSON.stringify(event) + "\n";
     await fs10.promises.appendFile(getUsagePath(), line, "utf-8");
     log.debug(`Tracked skill: ${event.skill}`);
@@ -7717,7 +8169,7 @@ __export(dashboard_collector_exports, {
   scanTranscriptStop: () => scanTranscriptStop
 });
 import fs12 from "fs";
-import path32 from "path";
+import path34 from "path";
 import readline2 from "readline";
 async function readStdin2() {
   if (process.stdin.isTTY) return "";
@@ -7768,7 +8220,7 @@ async function scanTranscriptStop(transcriptPath) {
   let prompts = 0;
   const tokens = emptyTokenUsage();
   const countedUsageKeys = /* @__PURE__ */ new Set();
-  if (path32.basename(transcriptPath) === "index.json") {
+  if (path34.basename(transcriptPath) === "index.json") {
     const cb = await scanCodebuddyIndex(transcriptPath);
     if (cb) return cb;
   }
@@ -7967,12 +8419,12 @@ async function parseHookEvent(raw, tool) {
   return event;
 }
 function getEventsPath() {
-  return path32.join(process.env.HOME ?? "", ".teamai", "dashboard", "events.jsonl");
+  return path34.join(process.env.HOME ?? "", ".teamai", "dashboard", "events.jsonl");
 }
 async function appendEvent(event) {
   try {
     const eventsPath = getEventsPath();
-    await ensureDir(path32.dirname(eventsPath));
+    await ensureDir(path34.dirname(eventsPath));
     const line = JSON.stringify(event) + "\n";
     await fs12.promises.appendFile(eventsPath, line, "utf-8");
     const detail = event.toolName ? ` [tool=${event.toolName}]` : event.promptSummary ? ` [prompt=${event.promptSummary.slice(0, 60)}]` : "";
@@ -8254,20 +8706,20 @@ __export(digest_exports, {
   summarizeConversation: () => summarizeConversation,
   summarizeInterventions: () => summarizeInterventions
 });
-import YAML9 from "yaml";
-import path33 from "path";
+import YAML10 from "yaml";
+import path35 from "path";
 import fs13 from "fs";
 async function loadTeamStats(repoPath) {
-  const statsDir = path33.join(repoPath, "stats");
+  const statsDir = path35.join(repoPath, "stats");
   const stats = [];
   try {
     const files = await listFiles(statsDir);
     for (const file of files) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
-      const content = await readFileSafe(path33.join(statsDir, file));
+      const content = await readFileSafe(path35.join(statsDir, file));
       if (!content) continue;
       try {
-        const parsed = YAML9.parse(content);
+        const parsed = YAML10.parse(content);
         if (parsed?.username && parsed?.skills) {
           stats.push(parsed);
         }
@@ -8361,17 +8813,17 @@ async function getRecentSkillChanges(repoPath) {
   return changes;
 }
 async function getRecentSessions(repoPath) {
-  const sessionsDir = path33.join(repoPath, "sessions");
+  const sessionsDir = path35.join(repoPath, "sessions");
   const summaries = [];
   try {
     const userDirs = await fs13.promises.readdir(sessionsDir, { withFileTypes: true });
     for (const userDir of userDirs) {
       if (!userDir.isDirectory()) continue;
-      const userSessionsDir = path33.join(sessionsDir, userDir.name);
+      const userSessionsDir = path35.join(sessionsDir, userDir.name);
       const files = await listFiles(userSessionsDir);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const content = await readFileSafe(path33.join(userSessionsDir, file));
+        const content = await readFileSafe(path35.join(userSessionsDir, file));
         if (content) {
           summaries.push(`[${userDir.name}] ${file}:
 ${content.slice(0, 500)}`);
@@ -8383,7 +8835,7 @@ ${content.slice(0, 500)}`);
   return summaries;
 }
 async function getRecentLearnings(repoPath) {
-  const learningsDir = path33.join(repoPath, "learnings");
+  const learningsDir = path35.join(repoPath, "learnings");
   const recent = [];
   let total = 0;
   try {
@@ -8396,7 +8848,7 @@ async function getRecentLearnings(repoPath) {
       if (!dateMatch) continue;
       const fileDate = dateMatch[1];
       if (fileDate < cutoff) continue;
-      const content = await readFileSafe(path33.join(learningsDir, filename));
+      const content = await readFileSafe(path35.join(learningsDir, filename));
       if (!content) continue;
       const parsed = parseLearningDoc(content, filename);
       const title = parsed?.meta.title ?? titleFromFilename(filename);
@@ -8580,8 +9032,8 @@ __export(stats_exports, {
   aggregateUsage: () => aggregateUsage,
   showStats: () => showStats
 });
-import YAML10 from "yaml";
-import path34 from "path";
+import YAML11 from "yaml";
+import path36 from "path";
 function aggregateUsage(events) {
   const map = /* @__PURE__ */ new Map();
   for (const event of events) {
@@ -8606,10 +9058,10 @@ async function loadReportedStats() {
   try {
     const config = await detectProjectConfig() ?? await loadLocalConfig();
     if (!config) return null;
-    const statsPath = path34.join(config.repo.localPath, "stats", `${config.username}.yaml`);
+    const statsPath = path36.join(config.repo.localPath, "stats", `${config.username}.yaml`);
     const content = await readFileSafe(statsPath);
     if (!content) return null;
-    const parsed = YAML10.parse(content);
+    const parsed = YAML11.parse(content);
     if (parsed?.username && parsed?.skills) return parsed;
     return null;
   } catch {
@@ -8762,13 +9214,13 @@ __export(team_push_exports, {
   mergeStats: () => mergeStats,
   reportUsageToTeam: () => reportUsageToTeam
 });
-import YAML11 from "yaml";
-import path35 from "path";
+import YAML12 from "yaml";
+import path37 from "path";
 async function readExistingStats(statsPath) {
   try {
     const content = await readFileSafe(statsPath);
     if (!content) return null;
-    const parsed = YAML11.parse(content);
+    const parsed = YAML12.parse(content);
     if (parsed?.username && parsed?.skills) return parsed;
     return null;
   } catch {
@@ -8801,7 +9253,7 @@ function mergeStats(existing, username, newEvents) {
   };
 }
 function getReportedInterventionsPath() {
-  return path35.join(process.env.HOME ?? "", ".teamai", "dashboard", "reported-interventions.json");
+  return path37.join(process.env.HOME ?? "", ".teamai", "dashboard", "reported-interventions.json");
 }
 async function readReportedInterventions() {
   const parsed = await readJson(getReportedInterventionsPath());
@@ -8839,7 +9291,7 @@ function hasInterventionDelta(d) {
   return d.sessions > 0 || d.interrupt > 0 || d.toolReject > 0 || d.correction > 0;
 }
 function getReportedPromptTokensPath() {
-  return path35.join(process.env.HOME ?? "", ".teamai", "dashboard", "reported-prompt-tokens.json");
+  return path37.join(process.env.HOME ?? "", ".teamai", "dashboard", "reported-prompt-tokens.json");
 }
 async function readReportedPromptTokens() {
   try {
@@ -8854,7 +9306,7 @@ async function readReportedPromptTokens() {
 async function writeReportedPromptTokens(data) {
   try {
     const p = getReportedPromptTokensPath();
-    await ensureDir(path35.dirname(p));
+    await ensureDir(path37.dirname(p));
     await writeFile(p, JSON.stringify(data));
   } catch (e) {
     log.error(`Failed to persist reported prompt/token snapshot: ${e.message}`);
@@ -8932,9 +9384,9 @@ async function reportUsageToTeam(repoPath, username, options) {
     await resetToCleanMaster(git, repoPath);
     await pullRepo(repoPath);
     if (hasUsage || hasInterventions || hasPromptTokens) {
-      const statsDir = path35.join(repoPath, "stats");
+      const statsDir = path37.join(repoPath, "stats");
       await ensureDir(statsDir);
-      const statsPath = path35.join(statsDir, `${username}.yaml`);
+      const statsPath = path37.join(statsDir, `${username}.yaml`);
       const existing = await readExistingStats(statsPath);
       const newStats = hasUsage ? aggregateUsage(events) : [];
       const merged = mergeStats(existing, username, newStats);
@@ -8946,22 +9398,15 @@ async function reportUsageToTeam(repoPath, username, options) {
         merged.prompts = pt.prompts;
         merged.tokens = pt.tokens;
       }
-      await writeFile(statsPath, YAML11.stringify(merged));
+      await writeFile(statsPath, YAML12.stringify(merged));
       filesToPush.push(`stats/${username}.yaml`);
     }
     try {
       if (await pathExists(VOTES_LOCAL_DIR)) {
-        const voteFiles = await listFiles(VOTES_LOCAL_DIR);
-        for (const vf of voteFiles) {
-          if (!vf.endsWith(".yaml") && !vf.endsWith(".yml")) continue;
-          const localVotePath = path35.join(VOTES_LOCAL_DIR, vf);
-          const repoVotePath = path35.join(repoPath, "votes", vf);
-          const content = await readFileSafe(localVotePath);
-          if (content) {
-            await ensureDir(path35.join(repoPath, "votes"));
-            await writeFile(repoVotePath, content);
-            filesToPush.push(`votes/${vf}`);
-          }
+        const { syncVotesToTeam: syncVotesToTeam2 } = await Promise.resolve().then(() => (init_votes(), votes_exports));
+        const synced = await syncVotesToTeam2(repoPath, username, VOTES_LOCAL_DIR);
+        if (synced) {
+          filesToPush.push(`votes/${username}.yaml`);
         }
       }
     } catch (e) {
@@ -9024,9 +9469,9 @@ __export(pull_exports, {
   pull: () => pull,
   scanRoleAwareSkills: () => scanRoleAwareSkills
 });
-import path36 from "path";
+import path38 from "path";
 import fse6 from "fs-extra";
-import matter3 from "gray-matter";
+import matter4 from "gray-matter";
 async function refreshTeamRepo(localConfig) {
   if (localConfig.repo.kind === "http") {
     const { resolveApiKey: resolveApiKey2 } = await Promise.resolve().then(() => (init_api_key(), api_key_exports));
@@ -9088,14 +9533,14 @@ async function buildRolePullContext(localConfig) {
   const activeSkillNames = /* @__PURE__ */ new Set();
   const inactiveSkillNames = /* @__PURE__ */ new Set();
   for (const namespace of activeNamespaces.skills) {
-    const namespaceDir = path36.join(localConfig.repo.localPath, "skills", namespace);
+    const namespaceDir = path38.join(localConfig.repo.localPath, "skills", namespace);
     const names = await listDirs(namespaceDir);
     for (const name of names) {
       activeSkillNames.add(name);
     }
   }
   for (const namespace of inactiveSkillNamespaces) {
-    const namespaceDir = path36.join(localConfig.repo.localPath, "skills", namespace);
+    const namespaceDir = path38.join(localConfig.repo.localPath, "skills", namespace);
     const names = await listDirs(namespaceDir);
     for (const name of names) {
       inactiveSkillNames.add(name);
@@ -9115,7 +9560,7 @@ function filterRulesByKnowledgeNamespaces(rules, knowledgeNamespaces) {
 async function scanRoleAwareSkills(localConfig, namespaces) {
   const items = /* @__PURE__ */ new Map();
   for (const namespace of namespaces.skills) {
-    const namespaceDir = path36.join(localConfig.repo.localPath, "skills", namespace);
+    const namespaceDir = path38.join(localConfig.repo.localPath, "skills", namespace);
     const dirs = await listDirs(namespaceDir);
     for (const dir of dirs) {
       const existing = items.get(dir);
@@ -9125,7 +9570,7 @@ async function scanRoleAwareSkills(localConfig, namespaces) {
       items.set(dir, {
         name: dir,
         type: "skills",
-        sourcePath: path36.join(namespaceDir, dir),
+        sourcePath: path38.join(namespaceDir, dir),
         relativePath: `skills/${namespace}/${dir}`,
         namespace
       });
@@ -9138,13 +9583,13 @@ async function cleanupInactiveNamespaceSkills(teamConfig, localConfig, activeSki
   for (const [tool, toolPath] of Object.entries(teamConfig.toolPaths)) {
     if (!toolPath.skills) continue;
     if (!await ResourceHandler.isToolInstalled(toolPath.skills, baseDir)) continue;
-    if (!await pathExists(path36.join(baseDir, toolPath.skills))) continue;
-    const localSkillNames = await listDirs(path36.join(baseDir, toolPath.skills));
+    if (!await pathExists(path38.join(baseDir, toolPath.skills))) continue;
+    const localSkillNames = await listDirs(path38.join(baseDir, toolPath.skills));
     for (const skillName of localSkillNames) {
       if (BUILTIN_SKILL_NAMES.has(skillName)) continue;
       if (activeSkillNames.has(skillName)) continue;
       if (!inactiveSkillNames.has(skillName)) continue;
-      const localSkillDir = path36.join(baseDir, toolPath.skills, skillName);
+      const localSkillDir = path38.join(baseDir, toolPath.skills, skillName);
       await remove(localSkillDir);
       log.debug(`[${localConfig.scope}] Removed inactive role-scoped skill ${skillName} from ${tool}`);
     }
@@ -9156,10 +9601,10 @@ async function getExistingLocalNames(type, items, teamConfig, localConfig) {
   if (type === "skills") {
     for (const [_tool, toolPath] of Object.entries(teamConfig.toolPaths)) {
       if (!toolPath.skills) continue;
-      const skillsDir = path36.join(baseDir, toolPath.skills);
+      const skillsDir = path38.join(baseDir, toolPath.skills);
       if (!await pathExists(skillsDir)) continue;
       for (const item of items) {
-        const skillDir = path36.join(skillsDir, item.name);
+        const skillDir = path38.join(skillsDir, item.name);
         if (await pathExists(skillDir)) {
           existing.add(item.name);
         }
@@ -9369,7 +9814,7 @@ async function pullForScope(localConfig, options) {
         if (!dir) continue;
         if (!await ResourceHandler.isToolInstalled(dir, baseDir)) continue;
         for (const name of tombstones) {
-          const localPath = path36.join(baseDir, dir, ext ? `${name}${ext}` : name);
+          const localPath = path38.join(baseDir, dir, ext ? `${name}${ext}` : name);
           if (await pathExists(localPath)) {
             await remove(localPath);
             log.debug(`[${scopeLabel}] Cleaned up tombstoned ${type} ${name} from ${dir}`);
@@ -9391,14 +9836,14 @@ async function pullForScope(localConfig, options) {
     for (const [tool, toolPath] of Object.entries(freshConfig.toolPaths)) {
       if (!toolPath.skills) continue;
       if (!await ResourceHandler.isToolInstalled(toolPath.skills, baseDir)) continue;
-      const skillsDir = path36.join(baseDir, toolPath.skills);
+      const skillsDir = path38.join(baseDir, toolPath.skills);
       if (!await pathExists(skillsDir)) continue;
       const localDirs = await listDirs(skillsDir);
       for (const dir of localDirs) {
         if (BUILTIN_SKILL_NAMES.has(dir)) continue;
         if (desiredSkillNames.has(dir)) continue;
         if (!knownRepoSkillNames.has(dir)) continue;
-        const skillDir = path36.join(skillsDir, dir);
+        const skillDir = path38.join(skillsDir, dir);
         await remove(skillDir);
         log.debug(`Removed excluded skill ${dir} from ${tool}`);
       }
@@ -9422,18 +9867,18 @@ async function pullForScope(localConfig, options) {
   }
   if (!options.dryRun) {
     try {
-      const learningsRepoDir = path36.join(localConfig.repo.localPath, "learnings");
-      const docsRepoDir = path36.join(localConfig.repo.localPath, "docs");
-      const rulesRepoDir = path36.join(localConfig.repo.localPath, "rules");
-      const skillsRepoDir = path36.join(localConfig.repo.localPath, "skills");
-      const votesDir = path36.join(localConfig.repo.localPath, "votes");
+      const learningsRepoDir = path38.join(localConfig.repo.localPath, "learnings");
+      const docsRepoDir = path38.join(localConfig.repo.localPath, "docs");
+      const rulesRepoDir = path38.join(localConfig.repo.localPath, "rules");
+      const skillsRepoDir = path38.join(localConfig.repo.localPath, "skills");
+      const votesDir = path38.join(localConfig.repo.localPath, "votes");
       let learningsCount = 0;
       let effectiveLearningsDir;
       if (localConfig.scope === "user") {
         if (await pathExists(learningsRepoDir)) {
           await fse6.copy(learningsRepoDir, LEARNINGS_LOCAL_DIR, {
             overwrite: true,
-            filter: (src) => !path36.basename(src).startsWith(".")
+            filter: (src) => !path38.basename(src).startsWith(".")
           });
           const allFiles = await listFiles(learningsRepoDir);
           learningsCount = allFiles.filter((f) => f.endsWith(".md")).length;
@@ -9447,12 +9892,12 @@ async function pullForScope(localConfig, options) {
         }
       }
       const hasAnySource = effectiveLearningsDir || await pathExists(docsRepoDir) || await pathExists(rulesRepoDir) || await pathExists(skillsRepoDir);
-      const repoCodebaseDir = path36.join(localConfig.repo.localPath, "docs", "team-codebase");
+      const repoCodebaseDir = path38.join(localConfig.repo.localPath, "docs", "team-codebase");
       const effectiveCodebaseDir = await pathExists(repoCodebaseDir) ? repoCodebaseDir : void 0;
       if (hasAnySource || effectiveCodebaseDir) {
         const votesExist = await pathExists(votesDir);
         const teamaiHome = getTeamaiHome(localConfig.scope, localConfig.projectRoot);
-        const indexPath = path36.join(teamaiHome, "search-index.json");
+        const indexPath = path38.join(teamaiHome, "search-index.json");
         const { buildIndex: buildIndex2 } = await Promise.resolve().then(() => (init_search_index(), search_index_exports));
         const elapsed = await buildIndex2({
           learningsDir: effectiveLearningsDir,
@@ -9476,18 +9921,18 @@ async function pullForScope(localConfig, options) {
   }
   if (!options.dryRun) {
     try {
-      const teamDomainsPath = path36.join(localConfig.repo.localPath, ".teamai", "domains.yaml");
+      const teamDomainsPath = path38.join(localConfig.repo.localPath, ".teamai", "domains.yaml");
       if (await pathExists(teamDomainsPath)) {
-        const localDomainsDir = path36.join(process.cwd(), ".teamai");
+        const localDomainsDir = path38.join(process.cwd(), ".teamai");
         await fse6.ensureDir(localDomainsDir);
-        await fse6.copy(teamDomainsPath, path36.join(localDomainsDir, "domains.yaml"), { overwrite: true });
+        await fse6.copy(teamDomainsPath, path38.join(localDomainsDir, "domains.yaml"), { overwrite: true });
       }
     } catch {
     }
   }
   if (!options.dryRun) {
     try {
-      const culturePath = path36.join(localConfig.repo.localPath, "culture.md");
+      const culturePath = path38.join(localConfig.repo.localPath, "culture.md");
       if (await pathExists(culturePath)) {
         const cultureContent = await readFileSafe(culturePath);
         if (cultureContent) {
@@ -9497,7 +9942,7 @@ async function pullForScope(localConfig, options) {
             for (const [tool, toolPath] of Object.entries(freshConfig.toolPaths)) {
               if (!toolPath.claudemd) continue;
               if (toolPath.rules && !await ResourceHandler.isToolInstalled(toolPath.rules, baseDir)) continue;
-              const claudeMdPath = path36.join(baseDir, toolPath.claudemd);
+              const claudeMdPath = path38.join(baseDir, toolPath.claudemd);
               try {
                 await injectClaudeMdSection(claudeMdPath, TEAMAI_CULTURE_START, TEAMAI_CULTURE_END, compiled);
                 log.debug(`Injected culture into ${tool} CLAUDE.md`);
@@ -9526,7 +9971,7 @@ async function pullForScope(localConfig, options) {
           for (const [tool, toolPath] of Object.entries(freshConfig.toolPaths)) {
             if (!toolPath.claudemd) continue;
             if (toolPath.rules && !await ResourceHandler.isToolInstalled(toolPath.rules, baseDir)) continue;
-            const claudeMdPath = path36.join(baseDir, toolPath.claudemd);
+            const claudeMdPath = path38.join(baseDir, toolPath.claudemd);
             try {
               await injectClaudeMdSection(claudeMdPath, TEAMAI_CLAUDEMD_START, TEAMAI_CLAUDEMD_END, compiled);
               log.debug(`Injected shared instructions into ${tool} CLAUDE.md`);
@@ -9549,7 +9994,7 @@ async function pullForScope(localConfig, options) {
       for (const [tool, toolPath] of Object.entries(freshConfig.toolPaths)) {
         if (!toolPath.claudemd || !toolPath.agents) continue;
         if (!await ResourceHandler.isToolInstalled(toolPath.agents, baseDir)) continue;
-        const claudeMdPath = path36.join(baseDir, toolPath.claudemd);
+        const claudeMdPath = path38.join(baseDir, toolPath.claudemd);
         try {
           await injectClaudeMdSection(
             claudeMdPath,
@@ -9609,14 +10054,14 @@ async function pullForScope(localConfig, options) {
   if (!options.silent && !options.dryRun) {
     try {
       const YAML18 = (await import("yaml")).default;
-      const { listFiles: listFiles2, readFileSafe: readFileSafe4 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+      const { listFiles: listFiles2, readFileSafe: readFileSafe5 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const { getRecommendations: getRecommendations2, displayRecommendations: displayRecommendations2 } = await Promise.resolve().then(() => (init_skill_recommend(), skill_recommend_exports));
-      const statsDir = path36.join(localConfig.repo.localPath, "stats");
+      const statsDir = path38.join(localConfig.repo.localPath, "stats");
       const files = await listFiles2(statsDir);
       const teamStats = [];
       for (const file of files) {
         if (!file.endsWith(".yaml")) continue;
-        const content = await readFileSafe4(path36.join(statsDir, file));
+        const content = await readFileSafe5(path38.join(statsDir, file));
         if (!content) continue;
         try {
           const parsed = YAML18.parse(content);
@@ -9635,7 +10080,7 @@ async function pullForScope(localConfig, options) {
 function compileCulture(raw) {
   let parsed;
   try {
-    parsed = matter3(raw);
+    parsed = matter4(raw);
   } catch {
     return null;
   }
@@ -9740,7 +10185,7 @@ function compileRecallRulesBlock() {
   return lines.join("\n");
 }
 async function collectClaudemdFiles(repoPath, roleContext) {
-  const claudemdDir = path36.join(repoPath, "claudemd");
+  const claudemdDir = path38.join(repoPath, "claudemd");
   if (!await pathExists(claudemdDir)) return [];
   let namespaceDirs;
   if (roleContext) {
@@ -9750,11 +10195,11 @@ async function collectClaudemdFiles(repoPath, roleContext) {
   }
   const contents = [];
   for (const ns of namespaceDirs) {
-    const nsDir = path36.join(claudemdDir, ns);
+    const nsDir = path38.join(claudemdDir, ns);
     if (!await pathExists(nsDir)) continue;
     const files = (await listFiles(nsDir)).filter((f) => f.endsWith(".md")).sort();
     for (const file of files) {
-      const content = await readFileSafe(path36.join(nsDir, file));
+      const content = await readFileSafe(path38.join(nsDir, file));
       if (content) contents.push(content);
     }
   }
@@ -9762,7 +10207,7 @@ async function collectClaudemdFiles(repoPath, roleContext) {
 }
 async function autoMigrateHooksIfNeeded() {
   const home = process.env.HOME ?? "";
-  const primarySettings = path36.join(home, ".claude", "settings.json");
+  const primarySettings = path38.join(home, ".claude", "settings.json");
   if (!await pathExists(primarySettings)) return;
   const content = await readFileSafe(primarySettings);
   if (!content) return;
@@ -9773,7 +10218,7 @@ async function autoMigrateHooksIfNeeded() {
   const { injectHooksToAllTools: injectHooksToAllTools2 } = await Promise.resolve().then(() => (init_hooks2(), hooks_exports));
   const { localConfig, teamConfig } = await autoDetectInit2();
   const baseDir = resolveBaseDir(localConfig);
-  await injectHooksToAllTools2(teamConfig.toolPaths, baseDir);
+  await injectHooksToAllTools2(teamConfig.toolPaths, baseDir, localConfig.enabledAgents);
   log.debug("Hooks migrated to dispatch format");
 }
 async function pull(options) {
@@ -9865,7 +10310,8 @@ async function reconcileHooksAllScopes(userConfig, projectConfig, options) {
       const { reconcileTeamHooksForConfig: reconcileTeamHooksForConfig2 } = await Promise.resolve().then(() => (init_hooks2(), hooks_exports));
       const teamDefs = await reconcileTeamHooksForConfig2(teamConfig, localConfig, {
         auto: true,
-        silent: options.silent
+        silent: options.silent,
+        filterAgents: localConfig.enabledAgents
       });
       if (teamDefs.length > 0) {
         log.debug(`[${localConfig.scope}] Reconciled ${teamDefs.length} team hook(s)`);
@@ -9983,17 +10429,17 @@ var init_known_agents = __esm({
 });
 
 // src/agent-skills.ts
-import path37 from "path";
-import YAML12 from "yaml";
+import path39 from "path";
+import YAML13 from "yaml";
 async function buildClassifyContext(localConfig) {
   const teamSkills = await collectTeamRepoSkills(localConfig.repo.localPath);
   const sourceSkills = /* @__PURE__ */ new Map();
   try {
-    const sourcesDir = path37.join(process.env.HOME ?? "", ".teamai", "sources");
+    const sourcesDir = path39.join(process.env.HOME ?? "", ".teamai", "sources");
     if (await pathExists(sourcesDir)) {
       const sourceNames = await listDirs(sourcesDir);
       for (const sourceName of sourceNames) {
-        const manifestPath = path37.join(sourcesDir, sourceName, "installed.json");
+        const manifestPath = path39.join(sourcesDir, sourceName, "installed.json");
         const raw = await readFileSafe(manifestPath);
         if (!raw) continue;
         try {
@@ -10010,13 +10456,13 @@ async function buildClassifyContext(localConfig) {
   return { teamSkills, sourceSkills };
 }
 async function collectTeamRepoSkills(repoPath) {
-  const teamSkillsDir = path37.join(repoPath, "skills");
+  const teamSkillsDir = path39.join(repoPath, "skills");
   const result = /* @__PURE__ */ new Map();
   if (!await pathExists(teamSkillsDir)) return result;
   const topDirs = await listDirs(teamSkillsDir);
   for (const dir of topDirs) {
-    const dirPath = path37.join(teamSkillsDir, dir);
-    const hasSkillMd = await pathExists(path37.join(dirPath, "SKILL.md"));
+    const dirPath = path39.join(teamSkillsDir, dir);
+    const hasSkillMd = await pathExists(path39.join(dirPath, "SKILL.md"));
     if (hasSkillMd) {
       result.set(dir, {});
     } else {
@@ -10063,8 +10509,8 @@ async function scanAgentSkills(agent, ctx) {
   const dirs = await listDirs(agent.absoluteSkillsPath);
   for (const name of dirs) {
     if (name.startsWith(".") || name.endsWith("-workspace")) continue;
-    const skillDir = path37.join(agent.absoluteSkillsPath, name);
-    const skillMd = path37.join(skillDir, "SKILL.md");
+    const skillDir = path39.join(agent.absoluteSkillsPath, name);
+    const skillMd = path39.join(skillDir, "SKILL.md");
     if (!await pathExists(skillMd)) continue;
     const description = await readSkillDescription(skillMd);
     skills.push({
@@ -10084,7 +10530,7 @@ async function readSkillDescription(skillMdPath) {
   if (!fm) return "";
   let parsed;
   try {
-    parsed = YAML12.parse(fm[1]);
+    parsed = YAML13.parse(fm[1]);
   } catch {
     return "";
   }
@@ -10114,8 +10560,8 @@ __export(status_exports, {
   list: () => list,
   status: () => status
 });
-import path38 from "path";
-import YAML13 from "yaml";
+import path40 from "path";
+import YAML14 from "yaml";
 async function status(options) {
   const { localConfig, teamConfig } = await autoDetectInit();
   const scopeLabel = localConfig.scope;
@@ -10147,20 +10593,20 @@ async function status(options) {
   log.info("Team resources:");
   const repoPath = localConfig.repo.localPath;
   const counts = {};
-  const skillsDirs = await listDirs(path38.join(repoPath, "skills"));
+  const skillsDirs = await listDirs(path40.join(repoPath, "skills"));
   counts.skills = skillsDirs.length;
-  const rulesFiles = (await listFiles(path38.join(repoPath, "rules"))).filter((f) => f.endsWith(".md"));
+  const rulesFiles = (await listFiles(path40.join(repoPath, "rules"))).filter((f) => f.endsWith(".md"));
   counts.rules = rulesFiles.length;
-  const docsExists = await pathExists(path38.join(repoPath, "docs"));
-  const docFiles = docsExists ? (await listFiles(path38.join(repoPath, "docs"))).filter((f) => !f.startsWith(".")) : [];
+  const docsExists = await pathExists(path40.join(repoPath, "docs"));
+  const docFiles = docsExists ? (await listFiles(path40.join(repoPath, "docs"))).filter((f) => !f.startsWith(".")) : [];
   counts.docs = docFiles.length;
-  const envYamlPath = path38.join(repoPath, "env", "env.yaml");
+  const envYamlPath = path40.join(repoPath, "env", "env.yaml");
   let envCount = 0;
   if (await pathExists(envYamlPath)) {
     const envContent = await readFileSafe(envYamlPath);
     if (envContent) {
       try {
-        const envData = YAML13.parse(envContent);
+        const envData = YAML14.parse(envContent);
         envCount = Array.isArray(envData?.variables) ? envData.variables.length : 0;
       } catch {
       }
@@ -10234,12 +10680,12 @@ async function printRepoSection(t, options, ctx) {
   console.log("");
   console.log(`=== REPO ${t.toUpperCase()} ===`);
   if (t === "env") {
-    const envYamlPath = path38.join(repoPath, "env", "env.yaml");
+    const envYamlPath = path40.join(repoPath, "env", "env.yaml");
     if (await pathExists(envYamlPath)) {
       const envContent = await readFileSafe(envYamlPath);
       if (envContent) {
         try {
-          const envData = YAML13.parse(envContent);
+          const envData = YAML14.parse(envContent);
           if (envData?.variables && envData.variables.length > 0) {
             for (const v of envData.variables) {
               console.log(`  ${v.key}=${v.value}`);
@@ -10356,7 +10802,7 @@ var skill_cmd_exports = {};
 __export(skill_cmd_exports, {
   skillShow: () => skillShow
 });
-import path39 from "path";
+import path41 from "path";
 async function skillShow(name, options) {
   const { localConfig, teamConfig } = await autoDetectInit();
   const agents = await detectInstalledAgents(localConfig, teamConfig);
@@ -10369,7 +10815,7 @@ async function skillShow(name, options) {
   }
   const ctx = await buildClassifyContext(localConfig);
   const source = classifySkill(name, ctx);
-  const description = truncate(await readSkillDescription(path39.join(resolved.primaryPath, "SKILL.md")), DESCRIPTION_MAX);
+  const description = truncate(await readSkillDescription(path41.join(resolved.primaryPath, "SKILL.md")), DESCRIPTION_MAX);
   const contributors = await SkillsHandler.readContributors(resolved.primaryPath);
   const tagsConfig = await loadTagsConfig(localConfig.repo.localPath);
   const tags = tagsConfig?.skills?.[name] ?? [];
@@ -10387,28 +10833,28 @@ async function skillShow(name, options) {
   });
   if (options.verbose) {
     console.log("");
-    console.log(`  Verbose: SKILL.md path is ${path39.join(resolved.primaryPath, "SKILL.md")}`);
+    console.log(`  Verbose: SKILL.md path is ${path41.join(resolved.primaryPath, "SKILL.md")}`);
   }
 }
 async function locateSkill(name, localConfig, agents) {
-  const teamSkillsDir = path39.join(localConfig.repo.localPath, "skills");
-  const flat = path39.join(teamSkillsDir, name);
-  if (await pathExists(path39.join(flat, "SKILL.md"))) {
+  const teamSkillsDir = path41.join(localConfig.repo.localPath, "skills");
+  const flat = path41.join(teamSkillsDir, name);
+  if (await pathExists(path41.join(flat, "SKILL.md"))) {
     return { name, primaryPath: flat, primaryOrigin: "team" };
   }
   if (await pathExists(teamSkillsDir)) {
     const namespaces = await listDirs(teamSkillsDir);
     for (const ns of namespaces) {
-      const candidate = path39.join(teamSkillsDir, ns, name);
-      if (await pathExists(path39.join(candidate, "SKILL.md"))) {
+      const candidate = path41.join(teamSkillsDir, ns, name);
+      if (await pathExists(path41.join(candidate, "SKILL.md"))) {
         return { name, primaryPath: candidate, primaryOrigin: "team", namespace: ns };
       }
     }
   }
   for (const agent of agents) {
     if (!agent.installed) continue;
-    const candidate = path39.join(agent.absoluteSkillsPath, name);
-    if (await pathExists(path39.join(candidate, "SKILL.md"))) {
+    const candidate = path41.join(agent.absoluteSkillsPath, name);
+    if (await pathExists(path41.join(candidate, "SKILL.md"))) {
       return { name, primaryPath: candidate, primaryOrigin: "agent" };
     }
   }
@@ -10418,8 +10864,8 @@ async function collectInstalledAgents(name, agents) {
   const matches = [];
   for (const agent of agents) {
     if (!agent.installed) continue;
-    const skillDir = path39.join(agent.absoluteSkillsPath, name);
-    if (await pathExists(path39.join(skillDir, "SKILL.md"))) {
+    const skillDir = path41.join(agent.absoluteSkillsPath, name);
+    if (await pathExists(path41.join(skillDir, "SKILL.md"))) {
       matches.push({ agent, path: skillDir });
     }
   }
@@ -10473,14 +10919,14 @@ __export(members_exports, {
   getMemberConfig: () => getMemberConfig,
   listMembers: () => listMembers
 });
-import YAML14 from "yaml";
-import path40 from "path";
+import YAML15 from "yaml";
+import path42 from "path";
 async function getMemberConfig(repoPath, username) {
-  const memberPath = path40.join(repoPath, "members", `${username}.yaml`);
+  const memberPath = path42.join(repoPath, "members", `${username}.yaml`);
   const content = await readFileSafe(memberPath);
   if (!content) return null;
   try {
-    const raw = YAML14.parse(content);
+    const raw = YAML15.parse(content);
     return MemberConfigSchema.parse(raw);
   } catch {
     return null;
@@ -10491,7 +10937,7 @@ async function listMembers(options) {
   const localConfig = projectConfig ?? (await requireInit()).localConfig;
   const repoPath = localConfig.repo.localPath;
   await pullRepo(repoPath);
-  const membersDir = path40.join(repoPath, "members");
+  const membersDir = path42.join(repoPath, "members");
   const files = await listFiles(membersDir);
   const yamlFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
   if (yamlFiles.length === 0) {
@@ -10502,10 +10948,10 @@ async function listMembers(options) {
   console.log(`Team members (${yamlFiles.length}):`);
   console.log("");
   for (const file of yamlFiles) {
-    const content = await readFileSafe(path40.join(membersDir, file));
+    const content = await readFileSafe(path42.join(membersDir, file));
     if (!content) continue;
     try {
-      const raw = YAML14.parse(content);
+      const raw = YAML15.parse(content);
       const member = MemberConfigSchema.parse(raw);
       const isSelf = member.username === localConfig.username;
       const marker = isSelf ? " (you)" : "";
@@ -10674,13 +11120,13 @@ var doctor_exports = {};
 __export(doctor_exports, {
   doctor: () => doctor
 });
-import path41 from "path";
+import path43 from "path";
 async function buildHookChecks(toolPaths, baseDir) {
   const checks = [];
   for (const [tool, paths] of Object.entries(toolPaths)) {
     if (!paths.settings) continue;
-    const settingsPath = path41.join(baseDir, paths.settings);
-    const parentDir = path41.dirname(settingsPath);
+    const settingsPath = path43.join(baseDir, paths.settings);
+    const parentDir = path43.dirname(settingsPath);
     if (!await pathExists(parentDir)) continue;
     checks.push({
       name: `teamai hooks in ${tool} settings`,
@@ -10772,13 +11218,13 @@ async function doctor(options) {
       check: async () => {
         if (teamConfig?.sharing?.env?.injectShellProfile === false) return true;
         if (!localConfig) return true;
-        const envYamlPath = path41.join(localConfig.repo.localPath, "env", "env.yaml");
+        const envYamlPath = path43.join(localConfig.repo.localPath, "env", "env.yaml");
         if (!await pathExists(envYamlPath)) return true;
         const home = process.env.HOME ?? "";
-        const envShPath = path41.join(home, ".teamai", "env.sh");
+        const envShPath = path43.join(home, ".teamai", "env.sh");
         if (!await pathExists(envShPath)) return false;
         const shell = process.env.SHELL ?? "";
-        const profilePath = shell.includes("zsh") ? path41.join(home, ".zshrc") : path41.join(home, ".bashrc");
+        const profilePath = shell.includes("zsh") ? path43.join(home, ".zshrc") : path43.join(home, ".bashrc");
         if (!await pathExists(profilePath)) return false;
         const content = await readFileSafe(profilePath);
         return content?.includes(TEAMAI_ENV_START) ?? false;
@@ -10825,8 +11271,8 @@ __export(roles_cmd_exports, {
   rolesSet: () => rolesSet,
   rolesUpdate: () => rolesUpdate
 });
-import path42 from "path";
-import YAML15 from "yaml";
+import path44 from "path";
+import YAML16 from "yaml";
 function parseNamespaces(input) {
   return input.split(",").map((s) => s.trim()).filter(Boolean);
 }
@@ -10870,7 +11316,7 @@ async function rolesInit(options) {
   const { localConfig, teamConfig } = await autoDetectInit();
   const repoPath = localConfig.repo.localPath;
   await pullLatest(repoPath);
-  const manifestPath = path42.join(repoPath, "manifest", "roles.yaml");
+  const manifestPath = path44.join(repoPath, "manifest", "roles.yaml");
   if (await pathExists(manifestPath)) {
     log.warn(`Roles manifest already exists at ${manifestPath}`);
     const overwrite = await askConfirmation("Overwrite existing manifest? [y/N] ");
@@ -10926,7 +11372,7 @@ async function rolesInit(options) {
   };
   if (options.dryRun) {
     log.info("[dry-run] Would write manifest:");
-    console.log(YAML15.stringify(manifest));
+    console.log(YAML16.stringify(manifest));
     return;
   }
   await saveRolesManifest(repoPath, manifest);
@@ -11213,7 +11659,7 @@ __export(tags_exports, {
   tagsSubscribe: () => tagsSubscribe,
   tagsUnsubscribe: () => tagsUnsubscribe
 });
-import path43 from "path";
+import path45 from "path";
 async function resolveTagsScope() {
   const projectConfig = await detectProjectConfig();
   return projectConfig ?? (await requireInit()).localConfig;
@@ -11378,7 +11824,7 @@ async function tagsRemove(resourceType, name, tags, options) {
 async function getTeamSkillCount(repoPath) {
   try {
     const { listDirs: listDirs2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-    const skillsDir = path43.join(repoPath, "skills");
+    const skillsDir = path45.join(repoPath, "skills");
     const dirs = await listDirs2(skillsDir);
     return dirs.length;
   } catch {
@@ -11626,24 +12072,24 @@ var uninstall_exports = {};
 __export(uninstall_exports, {
   uninstall: () => uninstall
 });
-import path44 from "path";
+import path46 from "path";
 function detectShellProfile() {
   const home = process.env.HOME;
   if (!home) return null;
   const shell = process.env.SHELL ?? "";
   if (shell.includes("zsh")) {
-    return path44.join(home, ".zshrc");
+    return path46.join(home, ".zshrc");
   }
-  return path44.join(home, ".bashrc");
+  return path46.join(home, ".bashrc");
 }
 async function collectTeamSkillNames(repoPath) {
-  const teamSkillsDir = path44.join(repoPath, "skills");
+  const teamSkillsDir = path46.join(repoPath, "skills");
   if (!await pathExists(teamSkillsDir)) return /* @__PURE__ */ new Set();
   const names = /* @__PURE__ */ new Set();
   const topDirs = await listDirs(teamSkillsDir);
   for (const dir of topDirs) {
-    const dirPath = path44.join(teamSkillsDir, dir);
-    const hasSkillMd = await pathExists(path44.join(dirPath, "SKILL.md"));
+    const dirPath = path46.join(teamSkillsDir, dir);
+    const hasSkillMd = await pathExists(path46.join(dirPath, "SKILL.md"));
     if (hasSkillMd) {
       names.add(dir);
     } else {
@@ -11656,7 +12102,7 @@ async function collectTeamSkillNames(repoPath) {
   return names;
 }
 async function collectTeamRuleNames(repoPath) {
-  const teamRulesDir = path44.join(repoPath, "rules");
+  const teamRulesDir = path46.join(repoPath, "rules");
   if (!await pathExists(teamRulesDir)) return /* @__PURE__ */ new Set();
   const files = await listFilesRecursive(teamRulesDir);
   return new Set(
@@ -11684,36 +12130,36 @@ async function buildRemovalPlan(localConfig, teamConfig) {
   const teamRuleNames = await collectTeamRuleNames(repoPath);
   for (const [tool, toolPath] of Object.entries(teamConfig.toolPaths)) {
     if (toolPath.settings) {
-      const settingsPath = path44.join(baseDir, toolPath.settings);
+      const settingsPath = path46.join(baseDir, toolPath.settings);
       if (await pathExists(settingsPath)) {
         plan.hookFiles.push({ path: settingsPath, tool });
       }
     } else {
-      const hooksDir = path44.join(baseDir, `.${tool}`, "hooks");
-      if (await pathExists(path44.join(hooksDir, OPENCLAW_HOOK_DIR))) {
+      const hooksDir = path46.join(baseDir, `.${tool}`, "hooks");
+      if (await pathExists(path46.join(hooksDir, OPENCLAW_HOOK_DIR))) {
         plan.openclawHookDirs.push({ hooksDir, tool });
       }
     }
     if (toolPath.claudemd) {
-      const claudeMdPath = path44.join(baseDir, toolPath.claudemd);
+      const claudeMdPath = path46.join(baseDir, toolPath.claudemd);
       const content = await readFileSafe(claudeMdPath);
       if (content && CLAUDEMD_MARKER_PAIRS.some(([start]) => content.includes(start))) {
         plan.claudeMdFiles.push(claudeMdPath);
       }
     }
     if (toolPath.skills) {
-      const skillsDir = path44.join(baseDir, toolPath.skills);
+      const skillsDir = path46.join(baseDir, toolPath.skills);
       if (await pathExists(skillsDir)) {
         const dirs = await listDirs(skillsDir);
         for (const dir of dirs) {
           if (teamSkillNames.has(dir)) {
-            plan.skillDirs.push(path44.join(skillsDir, dir));
+            plan.skillDirs.push(path46.join(skillsDir, dir));
           }
         }
       }
     }
     if (toolPath.rules) {
-      const rulesDir = path44.join(baseDir, toolPath.rules);
+      const rulesDir = path46.join(baseDir, toolPath.rules);
       if (await pathExists(rulesDir)) {
         const files = await listFilesRecursive(rulesDir);
         for (const file of files) {
@@ -11721,7 +12167,7 @@ async function buildRemovalPlan(localConfig, teamConfig) {
           const ruleName = file.replace(/\.md$/, "");
           if (EXCLUDED_RULE_NAMES.has(ruleName)) continue;
           if (teamRuleNames.has(ruleName)) {
-            plan.ruleFiles.push(path44.join(rulesDir, file));
+            plan.ruleFiles.push(path46.join(rulesDir, file));
           }
         }
       }
@@ -11737,7 +12183,7 @@ async function buildRemovalPlan(localConfig, teamConfig) {
   const docsLocalDir = teamConfig.sharing.docs.localDir;
   let docsDir;
   if (localConfig.scope === "project" && localConfig.projectRoot) {
-    docsDir = docsLocalDir.startsWith("~/") ? path44.join(localConfig.projectRoot, docsLocalDir.substring(2)) : expandHome(docsLocalDir);
+    docsDir = docsLocalDir.startsWith("~/") ? path46.join(localConfig.projectRoot, docsLocalDir.substring(2)) : expandHome(docsLocalDir);
   } else {
     docsDir = expandHome(docsLocalDir);
   }
@@ -11765,7 +12211,7 @@ function printSummary(plan) {
   if (plan.openclawHookDirs.length > 0) {
     console.log(`   OpenClaw Hooks (${plan.openclawHookDirs.length} \u4E2A\u76EE\u5F55):`);
     for (const { hooksDir } of plan.openclawHookDirs) {
-      console.log(`     ${path44.join(hooksDir, OPENCLAW_HOOK_DIR)}/`);
+      console.log(`     ${path46.join(hooksDir, OPENCLAW_HOOK_DIR)}/`);
     }
     console.log("");
   }
@@ -11928,7 +12374,7 @@ async function uninstall(opts) {
       log.error("\u65E0\u6CD5\u786E\u5B9A\u7528\u6237\u4E3B\u76EE\u5F55\uFF08HOME \u73AF\u5883\u53D8\u91CF\u672A\u8BBE\u7F6E\uFF09");
       return;
     }
-    const home = path44.join(homeDir, ".teamai");
+    const home = path46.join(homeDir, ".teamai");
     if (!await pathExists(home)) {
       log.info("\u6CA1\u6709\u9700\u8981\u5378\u8F7D\u7684\u5185\u5BB9");
       return;
@@ -11986,7 +12432,7 @@ __export(env_commands_exports, {
   envList: () => envList,
   envRemove: () => envRemove
 });
-import path45 from "path";
+import path47 from "path";
 function maskValue(value) {
   if (value.length < 4) return "****";
   return `${value.slice(0, 2)}****`;
@@ -11994,7 +12440,7 @@ function maskValue(value) {
 async function envList(options) {
   const projectConfig = await detectProjectConfig();
   const localConfig = projectConfig ?? (await requireInit()).localConfig;
-  const envYamlPath = path45.join(localConfig.repo.localPath, "env", "env.yaml");
+  const envYamlPath = path47.join(localConfig.repo.localPath, "env", "env.yaml");
   if (!await pathExists(envYamlPath)) {
     log.info("No env variables defined (env/env.yaml not found)");
     return;
@@ -12023,7 +12469,7 @@ async function envAdd(key, value, options) {
   const projectConfig = await detectProjectConfig();
   const localConfig = projectConfig ?? (await requireInit()).localConfig;
   const repoPath = localConfig.repo.localPath;
-  const envYamlPath = path45.join(repoPath, "env", "env.yaml");
+  const envYamlPath = path47.join(repoPath, "env", "env.yaml");
   const pullSpin = spinner("Pulling latest...").start();
   try {
     await pullRepo(repoPath);
@@ -12050,7 +12496,7 @@ async function envAdd(key, value, options) {
     log.info(`[dry-run] Would ${isUpdate ? "update" : "add"} env variable: ${key}=${value}`);
     return;
   }
-  await ensureDir(path45.join(repoPath, "env"));
+  await ensureDir(path47.join(repoPath, "env"));
   await envHandler.writeEnvYaml(envYamlPath, envConfig);
   const action = isUpdate ? "Updated" : "Added";
   log.success(`${action} env variable: ${key}=${value}`);
@@ -12060,7 +12506,7 @@ async function envRemove(key, options) {
   const projectConfig = await detectProjectConfig();
   const localConfig = projectConfig ?? (await requireInit()).localConfig;
   const repoPath = localConfig.repo.localPath;
-  const envYamlPath = path45.join(repoPath, "env", "env.yaml");
+  const envYamlPath = path47.join(repoPath, "env", "env.yaml");
   const pullSpin = spinner("Pulling latest...").start();
   try {
     await pullRepo(repoPath);
@@ -12107,7 +12553,7 @@ __export(hooks_cmd_exports, {
   hooksList: () => hooksList,
   hooksRemove: () => hooksRemove
 });
-import path46 from "path";
+import path48 from "path";
 function resolveHookScopeTargets(localConfig) {
   const baseDir = resolveBaseDir(localConfig) ?? "";
   const manifestPath = getManagedHooksPath(localConfig.scope, localConfig.projectRoot);
@@ -12127,7 +12573,7 @@ function formatDisplayPath(settingsPath) {
   const home = process.env.HOME;
   if (!home) return settingsPath;
   if (settingsPath === home) return "~";
-  if (settingsPath.startsWith(home + path46.sep) || settingsPath.startsWith(home + "/")) {
+  if (settingsPath.startsWith(home + path48.sep) || settingsPath.startsWith(home + "/")) {
     return `~${settingsPath.slice(home.length)}`;
   }
   return settingsPath;
@@ -12169,7 +12615,7 @@ async function hooksList(_options) {
       continue;
     }
     for (const baseDir of baseDirs) {
-      const settingsPath = path46.join(baseDir, paths.settings);
+      const settingsPath = path48.join(baseDir, paths.settings);
       rows.push({
         tool,
         status: await getHookStatus(settingsPath, tool),
@@ -12965,11 +13411,11 @@ __export(dashboard_exports, {
 });
 import http from "http";
 import fs14 from "fs";
-import path47 from "path";
+import path49 from "path";
 async function startDashboard(port) {
   const serverPort = port ?? DASHBOARD_DEFAULT_PORT;
-  const eventsPath = path47.join(process.env.HOME ?? "", ".teamai", "dashboard", "events.jsonl");
-  await ensureDir(path47.dirname(eventsPath));
+  const eventsPath = path49.join(process.env.HOME ?? "", ".teamai", "dashboard", "events.jsonl");
+  await ensureDir(path49.dirname(eventsPath));
   try {
     await fs14.promises.access(eventsPath);
   } catch {
@@ -13107,14 +13553,14 @@ var init_dashboard = __esm({
 });
 
 // src/recall-quality.ts
-import path48 from "path";
+import path50 from "path";
 import fs15 from "fs";
 function sanitizeSessionId(sessionId) {
   return sessionId.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function getCachePath(sessionId) {
   const safeName = sanitizeSessionId(sessionId);
-  return path48.join(
+  return path50.join(
     process.env.HOME ?? "",
     ".teamai",
     "sessions",
@@ -13145,7 +13591,7 @@ function readCache(sessionId) {
 function writeCache(sessionId, cache) {
   try {
     const cachePath = getCachePath(sessionId);
-    const dir = path48.dirname(cachePath);
+    const dir = path50.dirname(cachePath);
     if (!fs15.existsSync(dir)) {
       fs15.mkdirSync(dir, { recursive: true });
     }
@@ -13208,13 +13654,13 @@ __export(contribute_check_exports, {
   writeContributeState: () => writeContributeState
 });
 import fs16 from "fs";
-import path49 from "path";
+import path51 from "path";
 import { execFileSync } from "child_process";
 function sanitizeSessionId2(sessionId) {
   return sessionId.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function getSessionPath(sessionId) {
-  return path49.join(
+  return path51.join(
     process.env.HOME ?? "",
     ".teamai",
     "sessions",
@@ -13250,9 +13696,9 @@ async function readContributeState(sessionId) {
 async function writeContributeState(sessionId, state) {
   try {
     const filePath = getSessionPath(sessionId);
-    await ensureDir(path49.dirname(filePath));
+    await ensureDir(path51.dirname(filePath));
     await writeJson(filePath, state);
-    await cleanupStaleSessions(path49.dirname(filePath), sessionId);
+    await cleanupStaleSessions(path51.dirname(filePath), sessionId);
   } catch (e) {
     log.error(`Failed to write contribute state: ${e.message}`);
   }
@@ -13265,7 +13711,7 @@ async function cleanupStaleSessions(dir, currentSessionId) {
     if (!entry.endsWith(".json")) continue;
     const name = entry.replace(".json", "");
     if (name === currentBasename) continue;
-    const filePath = path49.join(dir, entry);
+    const filePath = path51.join(dir, entry);
     try {
       const stat6 = await fs16.promises.stat(filePath);
       if (now - stat6.mtimeMs > STALE_SESSION_MS) {
@@ -13506,21 +13952,21 @@ __export(contribute_exports, {
   contribute: () => contribute
 });
 import fs17 from "fs";
-import path50 from "path";
+import path52 from "path";
 import fse8 from "fs-extra";
 async function rebuildIndexAfterContribute(localConfig) {
   const repoPath = localConfig.repo.localPath;
-  const learningsRepoDir = path50.join(repoPath, "learnings");
-  const docsRepoDir = path50.join(repoPath, "docs");
-  const rulesRepoDir = path50.join(repoPath, "rules");
-  const skillsRepoDir = path50.join(repoPath, "skills");
-  const votesDir = path50.join(repoPath, "votes");
+  const learningsRepoDir = path52.join(repoPath, "learnings");
+  const docsRepoDir = path52.join(repoPath, "docs");
+  const rulesRepoDir = path52.join(repoPath, "rules");
+  const skillsRepoDir = path52.join(repoPath, "skills");
+  const votesDir = path52.join(repoPath, "votes");
   let effectiveLearningsDir;
   if (localConfig.scope === "user") {
     if (await pathExists(learningsRepoDir)) {
       await fse8.copy(learningsRepoDir, LEARNINGS_LOCAL_DIR, {
         overwrite: true,
-        filter: (src) => !path50.basename(src).startsWith(".")
+        filter: (src) => !path52.basename(src).startsWith(".")
       });
     }
     effectiveLearningsDir = await pathExists(LEARNINGS_LOCAL_DIR) ? LEARNINGS_LOCAL_DIR : void 0;
@@ -13528,7 +13974,7 @@ async function rebuildIndexAfterContribute(localConfig) {
     effectiveLearningsDir = await pathExists(learningsRepoDir) ? learningsRepoDir : void 0;
   }
   const teamaiHome = getTeamaiHome(localConfig.scope, localConfig.projectRoot);
-  const indexPath = path50.join(teamaiHome, "search-index.json");
+  const indexPath = path52.join(teamaiHome, "search-index.json");
   const { buildIndex: buildIndex2 } = await Promise.resolve().then(() => (init_search_index(), search_index_exports));
   await buildIndex2({
     learningsDir: effectiveLearningsDir,
@@ -13587,9 +14033,9 @@ async function contribute(options) {
   const pushSpin = spinner("Contributing session knowledge...").start();
   const filename = generateFilename(options.title);
   try {
-    const aiDocsDir = path50.join(repoPath, "learnings");
+    const aiDocsDir = path52.join(repoPath, "learnings");
     await ensureDir(aiDocsDir);
-    const destPath = path50.join(aiDocsDir, filename);
+    const destPath = path52.join(aiDocsDir, filename);
     await fs17.promises.writeFile(destPath, content, "utf-8");
     try {
       await pullRepo(repoPath);
@@ -13644,7 +14090,7 @@ var init_contribute = __esm({
 });
 
 // src/wiki-engine/core/wiki-protocol.ts
-import path51 from "path";
+import path53 from "path";
 function safeIgnore(filePath) {
   const normalized = toPosix(filePath);
   const parts = normalized.split("/").filter(Boolean);
@@ -13658,7 +14104,7 @@ function safeIgnore(filePath) {
   return /\.(pem|key|p12|pfx)$/i.test(base);
 }
 function toPosix(value) {
-  return value.split(path51.sep).join("/");
+  return value.split(path53.sep).join("/");
 }
 var CONFIDENCE_SCORE_DEFAULTS, SAFE_IGNORE_SEGMENTS, SENSITIVE_FILE_NAMES;
 var init_wiki_protocol = __esm({
@@ -13705,7 +14151,7 @@ __export(graph_index_schema_exports, {
   validateGraph: () => validateGraph
 });
 import { readFile, writeFile as writeFile4, mkdir } from "fs/promises";
-import path52 from "path";
+import path54 from "path";
 function toPageSlug(relativePath) {
   return relativePath.replace(/\.md$/u, "").replace(/\\/g, "/");
 }
@@ -13876,7 +14322,7 @@ function computeGraphHealth(graph) {
   };
 }
 async function loadGraphIndex(wikiRoot) {
-  const graphPath = path52.join(wikiRoot, ".indices", "graph-index.json");
+  const graphPath = path54.join(wikiRoot, ".indices", "graph-index.json");
   try {
     const raw = await readFile(graphPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -13889,9 +14335,9 @@ async function loadGraphIndex(wikiRoot) {
   }
 }
 async function saveGraphIndex(wikiRoot, graph) {
-  const dir = path52.join(wikiRoot, ".indices");
+  const dir = path54.join(wikiRoot, ".indices");
   await mkdir(dir, { recursive: true });
-  const outPath = path52.join(dir, "graph-index.json");
+  const outPath = path54.join(dir, "graph-index.json");
   await writeFile4(outPath, JSON.stringify(graph, null, 2), "utf8");
   return outPath;
 }
@@ -13944,7 +14390,7 @@ var init_graph_index_schema = __esm({
 
 // src/code-knowledge-recall.ts
 import { readFile as readFile2, readdir } from "fs/promises";
-import path53 from "path";
+import path55 from "path";
 function countOccurrences(text, token) {
   let count = 0;
   let idx = 0;
@@ -14078,7 +14524,7 @@ function extractSnippet(content, queryTokens, maxLen = 300) {
 async function loadWikiPages(wikiRoot, depth) {
   const pages = [];
   if (depth === "route") {
-    const routerPath = path53.join(wikiRoot, "router.md");
+    const routerPath = path55.join(wikiRoot, "router.md");
     try {
       const content = await readFile2(routerPath, "utf-8");
       const titleMatch = content.match(/^title:\s*(.+)$/m);
@@ -14094,7 +14540,7 @@ async function loadWikiPages(wikiRoot, depth) {
     }
     return pages;
   }
-  const evidenceDir = path53.join(wikiRoot, "evidence", "code");
+  const evidenceDir = path55.join(wikiRoot, "evidence", "code");
   let projectDirs;
   try {
     const entries = await readdir(evidenceDir, { withFileTypes: true });
@@ -14103,7 +14549,7 @@ async function loadWikiPages(wikiRoot, depth) {
     return pages;
   }
   for (const project of projectDirs) {
-    const projectDir = path53.join(evidenceDir, project);
+    const projectDir = path55.join(evidenceDir, project);
     await loadPagesRecursive(projectDir, `evidence/code/${project}`, pages, depth);
   }
   return pages;
@@ -14112,7 +14558,7 @@ async function loadPagesRecursive(dir, relativePath, pages, depth, currentDepth
   if (currentDepth >= MAX_RECURSION_DEPTH) return;
   const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
-    const fullPath = path53.join(dir, entry.name);
+    const fullPath = path55.join(dir, entry.name);
     if (entry.isDirectory()) {
       await loadPagesRecursive(
         fullPath,
@@ -14234,8 +14680,7 @@ __export(recall_exports, {
   formatResults: () => formatResults,
   recall: () => recall
 });
-import path54 from "path";
-import YAML16 from "yaml";
+import path56 from "path";
 function getVotesLocalDir() {
   return `${process.env.HOME ?? ""}/.teamai/votes`;
 }
@@ -14265,49 +14710,25 @@ function formatResults(results) {
   lines.push("\u4EE5\u4E0A\u5185\u5BB9\u6765\u81EA\u56E2\u961F\u77E5\u8BC6\u5E93\uFF0C\u4EC5\u4F9B\u53C2\u8003\u3002\u5982\u9700\u8BE6\u7EC6\u4FE1\u606F\uFF0C\u8BF7\u7528 Read \u5DE5\u5177\u8BFB\u53D6\u5BF9\u5E94\u6587\u4EF6\u3002");
   return lines.join("\n");
 }
-async function autoUpvote(results, username, repoPath) {
+async function autoUpvote(results, username, _repoPath) {
   if (results.length === 0) return;
   try {
+    const { incrementRecalled: incrementRecalled2 } = await Promise.resolve().then(() => (init_votes(), votes_exports));
     const votesDir = getVotesLocalDir();
-    const localVotePath = path54.join(votesDir, `${username}.yaml`);
+    const localVotePath = path56.join(votesDir, `${username}.yaml`);
     await ensureDir(votesDir);
-    let userVotes = { votes: {} };
-    const existingContent = await readFileSafe(localVotePath);
-    if (existingContent) {
-      try {
-        const parsed = YAML16.parse(existingContent);
-        if (parsed?.votes) {
-          userVotes = parsed;
-        }
-      } catch {
-        log.debug("Corrupt local votes file, resetting");
-      }
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    let newVotes = 0;
-    for (const result of results) {
-      const docId = result.entry.filename.replace(/\.md$/i, "");
-      if (!userVotes.votes[docId]) {
-        userVotes.votes[docId] = { at: now };
-        newVotes++;
-      }
-    }
-    if (newVotes === 0) {
-      log.debug("autoUpvote: all docs already voted, skipping write");
-      return;
-    }
-    const yamlContent = YAML16.stringify(userVotes);
-    await writeFile(localVotePath, yamlContent);
-    log.debug(`autoUpvote: recorded ${newVotes} new vote(s) for ${username}`);
+    const docIds = results.map((r) => r.entry.filename.replace(/\.md$/i, ""));
+    await incrementRecalled2(localVotePath, docIds);
+    log.debug(`autoUpvote: incremented recalled_count for ${docIds.length} doc(s)`);
   } catch (e) {
     log.error(`autoUpvote failed: ${e.message}`);
   }
 }
 async function loadOrBuildScopeIndex(localConfig, scopeLabel) {
   const teamaiHome = localConfig.scope === "project" && localConfig.projectRoot ? getTeamaiHome("project", localConfig.projectRoot) : getTeamaiHome("user");
-  const indexPath = path54.join(teamaiHome, "search-index.json");
-  const localLearningsDir = path54.join(teamaiHome, "learnings");
-  const repoLearningsDir = path54.join(localConfig.repo.localPath, "learnings");
+  const indexPath = path56.join(teamaiHome, "search-index.json");
+  const localLearningsDir = path56.join(teamaiHome, "learnings");
+  const repoLearningsDir = path56.join(localConfig.repo.localPath, "learnings");
   let effectiveLearningsDir = null;
   if (scopeLabel === "user" && await pathExists(localLearningsDir)) {
     effectiveLearningsDir = localLearningsDir;
@@ -14316,13 +14737,13 @@ async function loadOrBuildScopeIndex(localConfig, scopeLabel) {
   }
   let index = await loadIndex(indexPath);
   const needsRebuild = !index || isLegacyIndex(index);
-  if (needsRebuild && (effectiveLearningsDir || await pathExists(path54.join(localConfig.repo.localPath, "docs")) || await pathExists(path54.join(localConfig.repo.localPath, "rules")) || await pathExists(path54.join(localConfig.repo.localPath, "skills")))) {
-    const votesDir = path54.join(localConfig.repo.localPath, "votes");
+  if (needsRebuild && (effectiveLearningsDir || await pathExists(path56.join(localConfig.repo.localPath, "docs")) || await pathExists(path56.join(localConfig.repo.localPath, "rules")) || await pathExists(path56.join(localConfig.repo.localPath, "skills")))) {
+    const votesDir = path56.join(localConfig.repo.localPath, "votes");
     const votesExist = await pathExists(votesDir);
-    const docsDir = path54.join(localConfig.repo.localPath, "docs");
-    const rulesDir = path54.join(localConfig.repo.localPath, "rules");
-    const skillsDir = path54.join(localConfig.repo.localPath, "skills");
-    const repoCodebaseDir = path54.join(localConfig.repo.localPath, "docs", "team-codebase");
+    const docsDir = path56.join(localConfig.repo.localPath, "docs");
+    const rulesDir = path56.join(localConfig.repo.localPath, "rules");
+    const skillsDir = path56.join(localConfig.repo.localPath, "skills");
+    const repoCodebaseDir = path56.join(localConfig.repo.localPath, "docs", "team-codebase");
     const codebaseDir = await pathExists(repoCodebaseDir) ? repoCodebaseDir : void 0;
     try {
       await buildIndex({
@@ -14382,7 +14803,7 @@ async function recall(query, options) {
     }
   }
   const wikiConfig = scopeIndexes[0]?.config;
-  const wikiRoot = wikiConfig ? path54.join(wikiConfig.repo.localPath, "teamwiki") : path54.join(process.cwd(), ".teamai", "team-repo", "teamwiki");
+  const wikiRoot = wikiConfig ? path56.join(wikiConfig.repo.localPath, "teamwiki") : path56.join(process.cwd(), ".teamai", "team-repo", "teamwiki");
   const hasWiki = await pathExists(wikiRoot);
   if (scopeIndexes.length === 0 && !hasWiki) {
     log.info("No learnings available. Run `teamai pull` first to sync team knowledge.");
@@ -14413,7 +14834,7 @@ async function recall(query, options) {
           votes: 0,
           type: "docs",
           domain: "technical",
-          path: path54.join(wikiRoot, cr.page),
+          path: path56.join(wikiRoot, cr.page),
           snippet: cr.snippet
         },
         score: Math.min(10, Math.log2(cr.score + 1) * 2),
@@ -14472,19 +14893,19 @@ __export(recall_toggle_exports, {
   recallEnable: () => recallEnable,
   recallStatus: () => recallStatus
 });
-import path55 from "path";
+import path57 from "path";
 async function removeRecallArtifacts(teamConfig, localConfig) {
   const baseDir = resolveBaseDir(localConfig);
   for (const [tool, toolPath] of Object.entries(teamConfig.toolPaths)) {
     if (toolPath.rules) {
-      const ruleFile = path55.join(baseDir, toolPath.rules, "teamai-recall.md");
+      const ruleFile = path57.join(baseDir, toolPath.rules, "teamai-recall.md");
       if (await pathExists(ruleFile)) {
         await remove(ruleFile);
         log.debug(`Removed recall rule from ${tool}`);
       }
     }
     if (toolPath.agents) {
-      const agentFile = path55.join(baseDir, toolPath.agents, "teamai-recall.md");
+      const agentFile = path57.join(baseDir, toolPath.agents, "teamai-recall.md");
       if (await pathExists(agentFile)) {
         await remove(agentFile);
         log.debug(`Removed recall agent from ${tool}`);
@@ -14492,7 +14913,7 @@ async function removeRecallArtifacts(teamConfig, localConfig) {
     }
     if (toolPath.skills) {
       for (const skillName of RECALL_DEPENDENT_SKILLS) {
-        const skillDir = path55.join(baseDir, toolPath.skills, skillName);
+        const skillDir = path57.join(baseDir, toolPath.skills, skillName);
         if (await pathExists(skillDir)) {
           await remove(skillDir);
           log.debug(`Removed recall skill ${skillName} from ${tool}`);
@@ -14500,7 +14921,7 @@ async function removeRecallArtifacts(teamConfig, localConfig) {
       }
     }
     if (toolPath.claudemd) {
-      const claudeMdPath = path55.join(baseDir, toolPath.claudemd);
+      const claudeMdPath = path57.join(baseDir, toolPath.claudemd);
       const content = await readFileSafe(claudeMdPath);
       if (content && content.includes(TEAMAI_RECALL_RULES_START)) {
         const startIdx = content.indexOf(TEAMAI_RECALL_RULES_START);
@@ -14534,7 +14955,7 @@ async function deployRecallArtifacts(teamConfig, localConfig) {
   for (const [tool, toolPath] of Object.entries(teamConfig.toolPaths)) {
     if (!toolPath.claudemd || !toolPath.agents) continue;
     if (!await ResourceHandler.isToolInstalled(toolPath.agents, baseDir)) continue;
-    const claudeMdPath = path55.join(baseDir, toolPath.claudemd);
+    const claudeMdPath = path57.join(baseDir, toolPath.claudemd);
     try {
       await injectClaudeMdSection2(
         claudeMdPath,
@@ -14594,10 +15015,10 @@ __export(todowrite_hint_exports, {
   shouldSkipTodoWriteHint: () => shouldSkipTodoWriteHint,
   todoWriteHint: () => todoWriteHint
 });
-import path56 from "path";
+import path58 from "path";
 import fs18 from "fs";
 function getTodoWriteHintCachePath(sessionId) {
-  return path56.join(
+  return path58.join(
     process.env.HOME ?? "",
     ".teamai",
     "sessions",
@@ -14620,7 +15041,7 @@ function readCache2(sessionId) {
 function writeCache2(sessionId, cache) {
   try {
     const cachePath = getTodoWriteHintCachePath(sessionId);
-    const dir = path56.dirname(cachePath);
+    const dir = path58.dirname(cachePath);
     if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
     fs18.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
   } catch {
@@ -14691,20 +15112,20 @@ var init_todowrite_hint = __esm({
 });
 
 // src/utils/cache-index.ts
-import path57 from "path";
+import path59 from "path";
 import os3 from "os";
 import fs19 from "fs-extra";
 function getCacheRoot() {
-  return process.env.TEAMAI_CACHE_DIR ?? path57.join(os3.homedir(), ".teamai", "cache", "repos");
+  return process.env.TEAMAI_CACHE_DIR ?? path59.join(os3.homedir(), ".teamai", "cache", "repos");
 }
 function buildKey(provider, owner, repo) {
   return `${provider}/${owner}/${repo}`;
 }
 function keyToAbsPath(key) {
-  return path57.join(getCacheRoot(), key);
+  return path59.join(getCacheRoot(), key);
 }
 async function loadCacheIndex() {
-  const indexPath = path57.join(getCacheRoot(), INDEX_FILENAME);
+  const indexPath = path59.join(getCacheRoot(), INDEX_FILENAME);
   try {
     const stat6 = await fs19.stat(indexPath);
     if (stat6.size > MAX_CONFIG_FILE_BYTES) {
@@ -14727,7 +15148,7 @@ async function loadCacheIndex() {
 async function saveCacheIndex(idx) {
   const root = getCacheRoot();
   await fs19.ensureDir(root);
-  const indexPath = path57.join(root, INDEX_FILENAME);
+  const indexPath = path59.join(root, INDEX_FILENAME);
   const updated = { ...idx, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
   await fs19.writeFile(indexPath, JSON.stringify(updated, null, 2), "utf8");
 }
@@ -14760,7 +15181,7 @@ async function statDirSize(absPath) {
     return 0;
   }
   for (const entry of entries) {
-    const childPath = path57.join(absPath, entry.name);
+    const childPath = path59.join(absPath, entry.name);
     if (entry.isSymbolicLink()) {
       continue;
     }
@@ -15073,6 +15494,12 @@ var init_cache_cmd = __esm({
 });
 
 // src/utils/ai-client.ts
+var ai_client_exports = {};
+__export(ai_client_exports, {
+  callClaude: () => callClaude,
+  callClaudeParallel: () => callClaudeParallel,
+  getAICliName: () => getAICliName
+});
 import { spawn, execFileSync as execFileSync2 } from "child_process";
 import { existsSync } from "fs";
 function detectClaudeCli() {
@@ -15242,7 +15669,7 @@ var init_ai_client = __esm({
 
 // src/import-local.ts
 import fs20 from "fs";
-import path58 from "path";
+import path60 from "path";
 import readline3 from "readline";
 function toSlug(title) {
   return title.toLowerCase().replace(/[^a-z0-9一-鿿]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
@@ -15278,7 +15705,7 @@ function parseClassifyOutput(sourcePath, rawContent, output) {
       sourcePath,
       rawContent,
       type: knownType,
-      title: typeof parsed.title === "string" ? parsed.title : path58.basename(sourcePath),
+      title: typeof parsed.title === "string" ? parsed.title : path60.basename(sourcePath),
       summary: typeof parsed.summary === "string" ? parsed.summary : "",
       tags: Array.isArray(parsed.tags) ? parsed.tags.filter((t) => typeof t === "string") : [],
       confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0,
@@ -15290,7 +15717,7 @@ function parseClassifyOutput(sourcePath, rawContent, output) {
       sourcePath,
       rawContent,
       type: "learning",
-      title: path58.basename(sourcePath),
+      title: path60.basename(sourcePath),
       summary: "",
       tags: [],
       confidence: 0,
@@ -15336,9 +15763,9 @@ async function scanCandidates(opts) {
     const relPaths = await listFilesRecursive(expandedDir);
     for (const relPath of relPaths) {
       if (relPath.split("/").some((seg) => seg.startsWith("."))) continue;
-      const ext = path58.extname(relPath).toLowerCase();
+      const ext = path60.extname(relPath).toLowerCase();
       if (ext !== ".md" && ext !== ".txt") continue;
-      const absPath = path58.join(expandedDir, relPath);
+      const absPath = path60.join(expandedDir, relPath);
       try {
         const stat6 = fs20.statSync(absPath);
         if (stat6.size > MAX_FILE_SIZE_BYTES) continue;
@@ -15360,8 +15787,8 @@ async function scanCandidates(opts) {
       if (!fs20.existsSync(baseDir)) continue;
       const relPaths = await listFilesRecursive(baseDir);
       for (const relPath of relPaths) {
-        if (path58.extname(relPath).toLowerCase() !== ".md") continue;
-        const absPath = path58.join(baseDir, relPath);
+        if (path60.extname(relPath).toLowerCase() !== ".md") continue;
+        const absPath = path60.join(baseDir, relPath);
         try {
           const stat6 = fs20.statSync(absPath);
           if (stat6.size > MAX_FILE_SIZE_BYTES) continue;
@@ -15392,7 +15819,7 @@ async function classifyWithAI(candidates) {
       sourcePath: c.path,
       rawContent: c.rawContent,
       type: "learning",
-      title: path58.basename(c.path),
+      title: path60.basename(c.path),
       summary: "",
       tags: [],
       confidence: 0,
@@ -15472,7 +15899,7 @@ async function interactiveReview(items, opts) {
   for (const sessionItem of pendingItems) {
     const currentIndex = session.items.indexOf(sessionItem) + 1;
     const classified = classifiedMap.get(sessionItem.sourcePath ?? "");
-    const title = sessionItem.learningDraft?.title ?? classified?.title ?? path58.basename(sessionItem.sourcePath ?? "");
+    const title = sessionItem.learningDraft?.title ?? classified?.title ?? path60.basename(sessionItem.sourcePath ?? "");
     const itemType = classified?.type ?? "learning";
     const summary = classified?.summary ?? "";
     const tags = classified?.tags ?? [];
@@ -15539,9 +15966,9 @@ async function pushAccepted(session, repoPath, opts) {
     } else {
       const typeInContent = detectTypeFromContent(draft.content);
       const subDir = typeInContent === "rule" ? "rules" : typeInContent === "doc" ? "docs" : "learnings";
-      destDir = path58.join(expandHome(repoPath), subDir);
+      destDir = path60.join(expandHome(repoPath), subDir);
     }
-    const destPath = path58.join(destDir, filename);
+    const destPath = path60.join(destDir, filename);
     if (opts.dryRun) {
       log.info(`[dry-run] would write: ${destPath}`);
       pushed++;
@@ -15806,7 +16233,7 @@ var init_iwiki_client = __esm({
 });
 
 // src/import-iwiki.ts
-import path59 from "path";
+import path61 from "path";
 import { readFile as readFile3, writeFile as writeFile5 } from "fs/promises";
 function parseIWikiInput(input) {
   const trimmed = input.trim();
@@ -15895,8 +16322,8 @@ async function importFromIWiki(opts) {
     dryRun: opts.dryRun,
     outputDir: opts.outputDir
   });
-  const teamwikiRoot = path59.join(repoPath, "teamwiki");
-  if (await pathExists(path59.join(teamwikiRoot, ".indices", "graph-index.json"))) {
+  const teamwikiRoot = path61.join(repoPath, "teamwiki");
+  if (await pathExists(path61.join(teamwikiRoot, ".indices", "graph-index.json"))) {
     try {
       const mapsToEdges = await reconcileIwikiWithCodebase(documents, teamwikiRoot);
       if (mapsToEdges.length > 0) {
@@ -15915,7 +16342,7 @@ async function importFromIWiki(opts) {
   log.success("iWiki import complete");
 }
 async function reconcileIwikiWithCodebase(documents, teamwikiRoot) {
-  const graphPath = path59.join(teamwikiRoot, ".indices", "graph-index.json");
+  const graphPath = path61.join(teamwikiRoot, ".indices", "graph-index.json");
   const graphRaw = await readFile3(graphPath, "utf-8");
   const graph = JSON.parse(graphRaw);
   const codeLabels = /* @__PURE__ */ new Map();
@@ -15924,17 +16351,17 @@ async function reconcileIwikiWithCodebase(documents, teamwikiRoot) {
     const words = node.label.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
     codeLabels.set(words, node.id);
   }
-  const evidenceDir = path59.join(teamwikiRoot, "evidence", "code");
+  const evidenceDir = path61.join(teamwikiRoot, "evidence", "code");
   const codePageContents = /* @__PURE__ */ new Map();
   if (await pathExists(evidenceDir)) {
     const { readdir: readdir9 } = await import("fs/promises");
     const projects = await readdir9(evidenceDir);
     for (const project of projects) {
-      const projectDir = path59.join(evidenceDir, project);
+      const projectDir = path61.join(evidenceDir, project);
       const files = await readdir9(projectDir).catch(() => []);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const content = await readFile3(path59.join(projectDir, file), "utf-8").catch(() => "");
+        const content = await readFile3(path61.join(projectDir, file), "utf-8").catch(() => "");
         codePageContents.set(`evidence/code/${project}/${file}`, content);
       }
     }
@@ -16023,7 +16450,7 @@ function parseGitHubPRUrl(url) {
   }
   return { owner: match[1], repo: match[2], number: match[3] };
 }
-async function githubApiGet(path92) {
+async function githubApiGet(path99) {
   return new Promise((resolve, reject) => {
     const token = process.env["GITHUB_TOKEN"];
     const headers = {
@@ -16032,7 +16459,7 @@ async function githubApiGet(path92) {
     };
     if (token) headers["Authorization"] = `Bearer ${token}`;
     const req = https2.request(
-      { hostname: "api.github.com", path: path92, headers },
+      { hostname: "api.github.com", path: path99, headers },
       (res) => {
         const chunks = [];
         res.on("data", (c) => chunks.push(c));
@@ -16228,8 +16655,8 @@ var init_mr_fetch2 = __esm({
 
 // src/utils/dedup.ts
 import fs21 from "fs/promises";
-import path60 from "path";
-import matter4 from "gray-matter";
+import path62 from "path";
+import matter5 from "gray-matter";
 function extractKeywords(text) {
   const keywords = /* @__PURE__ */ new Set();
   const enWords = text.match(/[a-zA-Z]+/g) ?? [];
@@ -16286,14 +16713,14 @@ async function findSupersededLearnings(draftKeywords, learningsDir, withinDays =
   const cutoffDate = new Date(Date.now() - withinDays * 24 * 60 * 60 * 1e3);
   const results = [];
   for (const filename of mdFiles) {
-    const filePath = path60.join(learningsDir, filename);
+    const filePath = path62.join(learningsDir, filename);
     try {
       const docDate = await resolveDocDate(filePath, filename);
       if (docDate < cutoffDate) {
         continue;
       }
       const raw = await fs21.readFile(filePath, "utf8");
-      const { content: body } = matter4(raw);
+      const { content: body } = matter5(raw);
       const fileKeywords = extractKeywords(body);
       const ratio = overlapRatio(draftKeywords, fileKeywords);
       if (ratio >= 0.6) {
@@ -16368,9 +16795,9 @@ var init_dedup = __esm({
 
 // src/import-mr.ts
 import fs22 from "fs/promises";
-import path61 from "path";
+import path63 from "path";
 import readline4 from "readline/promises";
-import matter5 from "gray-matter";
+import matter6 from "gray-matter";
 async function fetchMR(url) {
   if (url.includes("github.com")) {
     return fetchGitHubPR(url);
@@ -16472,7 +16899,7 @@ async function importFromMR(opts) {
   if (frontmatterStart > 0) {
     learningContent = learningContent.slice(frontmatterStart);
   }
-  const parsed = matter5(learningContent);
+  const parsed = matter6(learningContent);
   const learningTitle = parsed.data["title"] ?? mr.title;
   const draftKeywords = extractKeywords(learningContent);
   const supersededEntries = await findSupersededLearnings(draftKeywords, learningsDir);
@@ -16506,18 +16933,18 @@ async function importFromMR(opts) {
 async function writeLearning(draft, outputDir, repoPath) {
   if (outputDir) {
     await fs22.mkdir(outputDir, { recursive: true });
-    const filePath = path61.join(outputDir, "learning.md");
+    const filePath = path63.join(outputDir, "learning.md");
     await fs22.writeFile(filePath, draft.content, "utf-8");
     log.info(`Learning written: ${filePath}`);
     return;
   }
   if (repoPath) {
-    const learningsDir = path61.join(repoPath, "learnings");
+    const learningsDir = path63.join(repoPath, "learnings");
     await fs22.mkdir(learningsDir, { recursive: true });
     const datePrefix = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const safeTitle = draft.title.slice(0, 40).replace(/[^a-zA-Z0-9一-鿿_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
     const filename = `${datePrefix}-${safeTitle}.md`;
-    const filePath = path61.join(learningsDir, filename);
+    const filePath = path63.join(learningsDir, filename);
     await fs22.writeFile(filePath, draft.content, "utf-8");
     log.info(`Learning written: ${filePath}`);
     return;
@@ -16533,7 +16960,7 @@ var init_import_mr = __esm({
     init_ai_client();
     init_dedup();
     init_logger();
-    DEFAULT_LEARNINGS_DIR = path61.join(process.env.HOME ?? "/tmp", ".teamai", "learnings");
+    DEFAULT_LEARNINGS_DIR = path63.join(process.env.HOME ?? "/tmp", ".teamai", "learnings");
     SUPERSEDE_THRESHOLD = 0.6;
   }
 });
@@ -16541,8 +16968,8 @@ var init_import_mr = __esm({
 // src/codebase.ts
 import { execSync as execSync6 } from "child_process";
 import fs23 from "fs";
-import path62 from "path";
-import matter6 from "gray-matter";
+import path64 from "path";
+import matter7 from "gray-matter";
 async function gatherRepoContext(repoPath) {
   const parts = [];
   try {
@@ -16565,7 +16992,7 @@ ${truncated}`);
   } catch (err) {
     log.debug(`gatherRepoContext: find \u5931\u8D25 \u2014 ${String(err)}`);
   }
-  const pkgPath = path62.join(repoPath, "package.json");
+  const pkgPath = path64.join(repoPath, "package.json");
   if (fs23.existsSync(pkgPath)) {
     try {
       const raw = fs23.readFileSync(pkgPath, "utf-8");
@@ -16579,7 +17006,7 @@ ${excerpt}
     }
   }
   for (const candidate of ["src/index.ts", "src/main.ts", "index.ts", "main.py"]) {
-    const entryPath = path62.join(repoPath, candidate);
+    const entryPath = path64.join(repoPath, candidate);
     if (fs23.existsSync(entryPath)) {
       try {
         const raw = fs23.readFileSync(entryPath, "utf-8");
@@ -16595,7 +17022,7 @@ ${excerpt}
     }
   }
   for (const candidate of ["src/types.ts", "src/types/index.ts", "types.py"]) {
-    const typesPath = path62.join(repoPath, candidate);
+    const typesPath = path64.join(repoPath, candidate);
     if (fs23.existsSync(typesPath)) {
       try {
         const raw = fs23.readFileSync(typesPath, "utf-8");
@@ -16611,10 +17038,10 @@ ${excerpt}
     }
   }
   const docCandidates = [
-    path62.join(repoPath, "README.md"),
-    path62.join(repoPath, "ARCHITECTURE.md")
+    path64.join(repoPath, "README.md"),
+    path64.join(repoPath, "ARCHITECTURE.md")
   ];
-  const docsDir = path62.join(repoPath, "docs");
+  const docsDir = path64.join(repoPath, "docs");
   if (fs23.existsSync(docsDir)) {
     try {
       const entries = fs23.readdirSync(docsDir);
@@ -16622,7 +17049,7 @@ ${excerpt}
       for (const entry of entries) {
         if (count >= DOCS_MAX_FILES) break;
         if (entry.endsWith(".md")) {
-          docCandidates.push(path62.join(docsDir, entry));
+          docCandidates.push(path64.join(docsDir, entry));
           count++;
         }
       }
@@ -16635,7 +17062,7 @@ ${excerpt}
     try {
       const raw = fs23.readFileSync(docPath, "utf-8");
       const excerpt = raw.length > DOC_MAX_CHARS ? raw.slice(0, DOC_MAX_CHARS) + "\n\u2026\uFF08\u5DF2\u622A\u65AD\uFF09" : raw;
-      const relPath = path62.relative(repoPath, docPath);
+      const relPath = path64.relative(repoPath, docPath);
       parts.push(`## \u6587\u6863\u6458\u8981\uFF1A${relPath}
 ${excerpt}`);
     } catch (err) {
@@ -16666,9 +17093,9 @@ ${lines.join("\n")}`);
         if (fileCount >= LEARNINGS_MAX_FILES) break;
         if (!entry.endsWith(".md")) continue;
         try {
-          const filePath = path62.join(learningsDir, entry);
+          const filePath = path64.join(learningsDir, entry);
           const raw = fs23.readFileSync(filePath, "utf-8");
-          const parsed = matter6(raw);
+          const parsed = matter7(raw);
           const tags = parsed.data["tags"];
           if (Array.isArray(tags)) {
             for (const tag of tags) {
@@ -16861,7 +17288,7 @@ var init_codebase = __esm({
 import { createHash } from "crypto";
 import { execFile } from "child_process";
 import { readFile as readFile4, readdir as readdir2, stat } from "fs/promises";
-import path63 from "path";
+import path65 from "path";
 import { promisify } from "util";
 function isKeyFile(relativePath, language) {
   const patterns = KEY_FILE_PATTERNS[language];
@@ -16869,12 +17296,12 @@ function isKeyFile(relativePath, language) {
   return patterns.some((pattern) => pattern.test(relativePath));
 }
 async function collectCode(options) {
-  const root = path63.resolve(options.root);
+  const root = path65.resolve(options.root);
   const filePaths = [];
   await walk(root, filePaths, options.includeTests ?? false);
   let filtered = filePaths.sort((a, b) => {
-    const relA = toPosix(path63.relative(root, a));
-    const relB = toPosix(path63.relative(root, b));
+    const relA = toPosix(path65.relative(root, a));
+    const relB = toPosix(path65.relative(root, b));
     const langA = languageFor(a);
     const langB = languageFor(b);
     const keyA = isKeyFile(relA, langA) ? 0 : 1;
@@ -16888,7 +17315,7 @@ async function collectCode(options) {
   if (options.changedFiles && options.changedFiles.length > 0) {
     const changedSet = new Set(options.changedFiles.map((f) => toPosix(f)));
     filtered = filtered.filter((fp) => {
-      const relativePath = toPosix(path63.relative(root, fp));
+      const relativePath = toPosix(path65.relative(root, fp));
       return changedSet.has(relativePath);
     });
   }
@@ -16896,7 +17323,7 @@ async function collectCode(options) {
   const files = [];
   for (const filePath of limited) {
     const content = await readFile4(filePath, "utf8");
-    const relativePath = toPosix(path63.relative(root, filePath));
+    const relativePath = toPosix(path65.relative(root, filePath));
     const language = languageFor(filePath);
     files.push({
       path: filePath,
@@ -16923,7 +17350,7 @@ async function walk(directory, results, includeTests) {
     return;
   }
   for (const entry of await readdir2(directory, { withFileTypes: true })) {
-    const fullPath = path63.join(directory, entry.name);
+    const fullPath = path65.join(directory, entry.name);
     if (safeIgnore(fullPath) || !includeTests && isTestPath(fullPath)) {
       continue;
     }
@@ -16936,14 +17363,14 @@ async function walk(directory, results, includeTests) {
 }
 function isCodeFile(filePath) {
   return [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs", ".java", ".json", ".yaml", ".yml", ".toml", ".sql", ".conf", ".ini"].includes(
-    path63.extname(filePath).toLowerCase()
+    path65.extname(filePath).toLowerCase()
   );
 }
 function isTestPath(filePath) {
   return /(^|\/|\\)(test|tests|__tests__|fixtures)(\/|\\)|\.test\.|\.spec\./u.test(filePath);
 }
 function languageFor(filePath) {
-  const ext = path63.extname(filePath).toLowerCase();
+  const ext = path65.extname(filePath).toLowerCase();
   const map = {
     ".ts": "typescript",
     ".tsx": "typescript",
@@ -17587,14 +18014,14 @@ var init_code_extractors = __esm({
 });
 
 // src/wiki-engine/code-knowledge/code-graph.ts
-import path64 from "path";
+import path66 from "path";
 function buildCodeGraph(facts) {
   const nodes = facts.filter((fact) => fact.kind !== "relation").map((fact) => ({
     slug: `${fact.kind}/${fact.name}`,
     type: mapFactKindToCategory(fact.kind),
     confidence: fact.confidence === "EXTRACTED" ? "EXTRACTED" : "INFERRED",
     title: fact.name,
-    domain: path64.dirname(fact.file).split("/")[0] || void 0
+    domain: path66.dirname(fact.file).split("/")[0] || void 0
   }));
   const nodeFiles = new Set(facts.filter((f) => f.kind !== "relation").map((f) => f.file));
   const edges = facts.filter((fact) => fact.kind === "relation").flatMap((fact) => {
@@ -17637,7 +18064,7 @@ var init_code_graph = __esm({
 
 // src/wiki-engine/code-knowledge/code-incremental.ts
 import { readFile as readFile5, writeFile as writeFile6, stat as stat2, mkdir as mkdir3 } from "fs/promises";
-import path65 from "path";
+import path67 from "path";
 async function detectCodeIncrementalChanges(root, manifestPath, project) {
   const previous = await exists(manifestPath) ? JSON.parse(await readFile5(manifestPath, "utf8")) : { files: [] };
   const current = await collectCode({ root });
@@ -17663,14 +18090,14 @@ function affectedPages(project, files) {
 }
 async function exists(filePath) {
   try {
-    await stat2(path65.resolve(filePath));
+    await stat2(path67.resolve(filePath));
     return true;
   } catch {
     return false;
   }
 }
 async function loadFactsCache(indicesDir) {
-  const cachePath = path65.join(indicesDir, FACTS_CACHE_FILENAME);
+  const cachePath = path67.join(indicesDir, FACTS_CACHE_FILENAME);
   try {
     const raw = await readFile5(cachePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -17681,10 +18108,10 @@ async function loadFactsCache(indicesDir) {
 }
 async function saveFactsCache(indicesDir, facts) {
   await mkdir3(indicesDir, { recursive: true });
-  await writeFile6(path65.join(indicesDir, FACTS_CACHE_FILENAME), JSON.stringify(facts), "utf-8");
+  await writeFile6(path67.join(indicesDir, FACTS_CACHE_FILENAME), JSON.stringify(facts), "utf-8");
 }
 async function loadInterfacesCache(indicesDir) {
-  const cachePath = path65.join(indicesDir, INTERFACES_CACHE_FILENAME);
+  const cachePath = path67.join(indicesDir, INTERFACES_CACHE_FILENAME);
   try {
     const raw = await readFile5(cachePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -17696,7 +18123,7 @@ async function loadInterfacesCache(indicesDir) {
 async function saveInterfacesCache(indicesDir, inventory) {
   await mkdir3(indicesDir, { recursive: true });
   await writeFile6(
-    path65.join(indicesDir, INTERFACES_CACHE_FILENAME),
+    path67.join(indicesDir, INTERFACES_CACHE_FILENAME),
     JSON.stringify(inventory, null, 2),
     "utf-8"
   );
@@ -17722,7 +18149,7 @@ var init_code_incremental = __esm({
 });
 
 // src/wiki-engine/interface-scanner.ts
-import path66 from "path";
+import path68 from "path";
 async function scanInterfaces(files) {
   const componentMap = groupByComponent(files);
   const entries = [];
@@ -17790,7 +18217,7 @@ function groupByComponent(files) {
     if (file.repo) {
       component = parts.length > 1 ? `${file.repo}/${parts[0]}` : file.repo;
     } else {
-      component = parts.length > 1 ? parts[0] : path66.basename(path66.dirname(file.path));
+      component = parts.length > 1 ? parts[0] : path68.basename(path68.dirname(file.path));
     }
     const group = map.get(component) ?? [];
     group.push(file);
@@ -18076,7 +18503,7 @@ var init_reconciler_v2_types = __esm({
 
 // src/wiki-engine/knowledge-reconciler.ts
 import { readFile as readFile6, readdir as readdir3, stat as stat3 } from "fs/promises";
-import path67 from "path";
+import path69 from "path";
 async function exists2(p) {
   return stat3(p).then(() => true).catch(() => false);
 }
@@ -18085,7 +18512,7 @@ async function readPages(dirPath) {
   const entries = await readdir3(dirPath, { withFileTypes: true });
   const pages = [];
   for (const entry of entries) {
-    const full = path67.join(dirPath, entry.name);
+    const full = path69.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       pages.push(...await readPages(full));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -18178,17 +18605,17 @@ async function reconcileKnowledge(options) {
   const productDirNames = options.productDirs ?? ["product", "docs"];
   const codeDirNames = options.codeDirs ?? ["evidence/code"];
   for (const dir of [...productDirNames, ...codeDirNames]) {
-    if (dir.includes("..") || path67.isAbsolute(dir)) {
+    if (dir.includes("..") || path69.isAbsolute(dir)) {
       throw new Error(`Unsafe directory path rejected: ${dir}`);
     }
   }
   const productPages = [];
   for (const dir of productDirNames) {
-    productPages.push(...await readPages(path67.join(wikiRoot, dir)));
+    productPages.push(...await readPages(path69.join(wikiRoot, dir)));
   }
   const codePages = [];
   for (const dir of codeDirNames) {
-    codePages.push(...await readPages(path67.join(wikiRoot, dir)));
+    codePages.push(...await readPages(path69.join(wikiRoot, dir)));
   }
   const graphEdges = [];
   const gaps = [];
@@ -18215,8 +18642,8 @@ async function reconcileKnowledge(options) {
         ];
         const nc = buildConfidence(factors);
         graphEdges.push({
-          from: toPageSlug(path67.relative(wikiRoot, productPage.path)),
-          to: toPageSlug(path67.relative(wikiRoot, codePage.path)),
+          from: toPageSlug(path69.relative(wikiRoot, productPage.path)),
+          to: toPageSlug(path69.relative(wikiRoot, codePage.path)),
           relation: "MAPS_TO",
           term,
           confidence: nc.label,
@@ -18297,10 +18724,10 @@ async function reconcileKnowledge(options) {
   const MS_PER_DAY = 864e5;
   for (const edge of graphEdges) {
     const fromPage = productPages.find(
-      (p) => toPageSlug(path67.relative(wikiRoot, p.path)) === edge.from
+      (p) => toPageSlug(path69.relative(wikiRoot, p.path)) === edge.from
     );
     const toPage = codePages.find(
-      (p) => toPageSlug(path67.relative(wikiRoot, p.path)) === edge.to
+      (p) => toPageSlug(path69.relative(wikiRoot, p.path)) === edge.to
     );
     if (!fromPage?.updated || !toPage?.updated) continue;
     const fromMs = new Date(fromPage.updated).getTime();
@@ -18559,7 +18986,7 @@ __export(enrich_with_ai_exports, {
   enrichWithAI: () => enrichWithAI,
   writeManifest: () => writeManifest
 });
-import path68 from "path";
+import path70 from "path";
 import { writeFile as writeFile8, mkdir as mkdir5 } from "fs/promises";
 function sanitizeForPrompt(text) {
   return text.replace(/[\n\r]/g, " ").replace(/[<>]/g, "").slice(0, 200);
@@ -18700,7 +19127,7 @@ async function enrichWithAI(ctx) {
 }
 async function writeManifest(manifest, outputDir) {
   await mkdir5(outputDir, { recursive: true });
-  const manifestPath = path68.join(outputDir, "_manifest.json");
+  const manifestPath = path70.join(outputDir, "_manifest.json");
   await writeFile8(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   return manifestPath;
 }
@@ -18718,7 +19145,7 @@ __export(codebase_extract_exports, {
   extractCodebase: () => extractCodebase
 });
 import { mkdir as mkdir6, writeFile as writeFile9, readFile as readFile7 } from "fs/promises";
-import path69 from "path";
+import path71 from "path";
 import chalk3 from "chalk";
 function detectKnowledgeGaps(facts, graph, files) {
   const gaps = [];
@@ -18735,7 +19162,7 @@ function detectKnowledgeGaps(facts, graph, files) {
     const target = rel.name;
     if (target.startsWith(".")) continue;
     if (target.startsWith("node:")) continue;
-    const matchesAnyFile = [...scannedFiles].some((f) => f.includes(target.replace(/\//g, path69.sep)));
+    const matchesAnyFile = [...scannedFiles].some((f) => f.includes(target.replace(/\//g, path71.sep)));
     if (!matchesAnyFile) {
       unresolvedImports.add(target);
     }
@@ -19079,21 +19506,21 @@ function buildOverview(facts, graph, project, interfaceInventory, callChains) {
     lines.push("## Key Dependency Paths");
     lines.push("");
     for (const chain of callChains.slice(0, 5)) {
-      const path92 = chain.steps.map((s) => s.symbol).join(" \u2192 ");
-      lines.push(`- ${chain.entryPoint}: ${path92}`);
+      const path99 = chain.steps.map((s) => s.symbol).join(" \u2192 ");
+      lines.push(`- ${chain.entryPoint}: ${path99}`);
     }
   }
   lines.push("");
   return lines.join("\n");
 }
 async function extractCodebase(opts) {
-  const root = path69.resolve(opts.path || ".");
-  const project = opts.project || path69.basename(root);
+  const root = path71.resolve(opts.path || ".");
+  const project = opts.project || path71.basename(root);
   const maxFiles = opts.maxFiles || 200;
-  const outputBase = opts.outputRoot ? path69.resolve(opts.outputRoot) : root;
-  const wikiRoot = path69.join(outputBase, "teamwiki");
-  const evidenceDir = path69.join(wikiRoot, "evidence", "code", project);
-  const manifestPath = path69.join(wikiRoot, "source-manifest.json");
+  const outputBase = opts.outputRoot ? path71.resolve(opts.outputRoot) : root;
+  const wikiRoot = path71.join(outputBase, "teamwiki");
+  const evidenceDir = path71.join(wikiRoot, "evidence", "code", project);
+  const manifestPath = path71.join(wikiRoot, "source-manifest.json");
   let changedFiles;
   let deletedFiles = [];
   if (opts.incremental) {
@@ -19130,7 +19557,7 @@ async function extractCodebase(opts) {
   const newFacts = files.length > 0 ? extractCodeFacts(files) : [];
   let facts;
   let interfaceInventory;
-  const indicesDir = path69.join(wikiRoot, ".indices");
+  const indicesDir = path71.join(wikiRoot, ".indices");
   if (changedFiles !== void 0) {
     const oldFacts = await loadFactsCache(indicesDir);
     const oldInterfaces = await loadInterfacesCache(indicesDir);
@@ -19158,7 +19585,7 @@ async function extractCodebase(opts) {
   }
   const graph = buildCodeGraph(facts);
   let callChains;
-  const depPathsFile = path69.join(evidenceDir, "dependency-paths.md");
+  const depPathsFile = path71.join(evidenceDir, "dependency-paths.md");
   if (changedFiles) {
     callChains = [];
   } else {
@@ -19174,7 +19601,7 @@ async function extractCodebase(opts) {
     }
   }
   for (const [filename, content] of pages) {
-    await writeIfChanged(path69.join(evidenceDir, filename), content);
+    await writeIfChanged(path71.join(evidenceDir, filename), content);
   }
   const pageSlugs = [...pages.keys()].map((p) => `evidence/code/${project}/${p.replace(".md", "")}`);
   const overlay = buildIndexHubOverlay(project, "evidence/code", pageSlugs);
@@ -19203,7 +19630,7 @@ async function extractCodebase(opts) {
         keywords: enrichResult.repoKeywords || [],
         components: enrichResult.domains[0]?.components ?? []
       };
-      await writeFile9(path69.join(evidenceDir, "_domains.json"), JSON.stringify(domainMeta, null, 2), "utf-8");
+      await writeFile9(path71.join(evidenceDir, "_domains.json"), JSON.stringify(domainMeta, null, 2), "utf-8");
       if (!opts.json) {
         const domainLabel = domainMeta.domain || "uncategorized";
         console.log(`  AI enrich: ${enrichResult.manifest.components.length} modules, domain=${domainLabel}`);
@@ -19216,14 +19643,14 @@ async function extractCodebase(opts) {
   }
   const moduleSummaries = buildModuleSummaries(facts, graph, project);
   if (moduleSummaries.size > 0) {
-    const modulesDir = path69.join(evidenceDir, "modules");
+    const modulesDir = path71.join(evidenceDir, "modules");
     await mkdir6(modulesDir, { recursive: true });
     for (const [filename, content] of moduleSummaries) {
-      await writeIfChanged(path69.join(modulesDir, filename), content);
+      await writeIfChanged(path71.join(modulesDir, filename), content);
     }
   }
   const overview = buildOverview(facts, repoGraph, project, interfaceInventory, callChains);
-  await writeIfChanged(path69.join(evidenceDir, "overview.md"), overview);
+  await writeIfChanged(path71.join(evidenceDir, "overview.md"), overview);
   const proj = [{ slug: project, label: project }];
   const ifByType = {};
   for (const e of interfaceInventory.entries) {
@@ -19236,11 +19663,11 @@ async function extractCodebase(opts) {
     interfaces: Object.keys(ifByType).length > 0 ? ifByType : void 0,
     callChains: callChains.length > 0 ? callChains.length : void 0
   };
-  await writeIfChanged(path69.join(wikiRoot, "router.md"), routerTemplate(proj, aiDomains.length > 0 ? aiDomains : void 0));
-  await writeIfChanged(path69.join(wikiRoot, "hot.md"), HOT_TEMPLATE);
-  await writeIfChanged(path69.join(wikiRoot, "index.md"), indexTemplate(proj, indexStats));
+  await writeIfChanged(path71.join(wikiRoot, "router.md"), routerTemplate(proj, aiDomains.length > 0 ? aiDomains : void 0));
+  await writeIfChanged(path71.join(wikiRoot, "hot.md"), HOT_TEMPLATE);
+  await writeIfChanged(path71.join(wikiRoot, "index.md"), indexTemplate(proj, indexStats));
   const gaps = detectKnowledgeGaps(facts, graph, files);
-  const gapsDir = path69.join(wikiRoot, "gaps");
+  const gapsDir = path71.join(wikiRoot, "gaps");
   await mkdir6(gapsDir, { recursive: true });
   const gapLines = [
     "---",
@@ -19263,7 +19690,7 @@ async function extractCodebase(opts) {
     gapLines.push("| \u2014 | \u2014 | \u2014 | \u672A\u53D1\u73B0\u660E\u663E\u77E5\u8BC6\u7F3A\u53E3 | \u2014 |");
   }
   gapLines.push("");
-  await writeIfChanged(path69.join(gapsDir, "detected.md"), gapLines.join("\n"));
+  await writeIfChanged(path71.join(gapsDir, "detected.md"), gapLines.join("\n"));
   await saveFactsCache(indicesDir, facts);
   await saveInterfacesCache(indicesDir, interfaceInventory);
   let allManifestFiles = collectionManifest.files.map((f) => ({
@@ -19493,10 +19920,10 @@ var init_clone = __esm({
 
 // src/review-store.ts
 import crypto2 from "crypto";
-import path70 from "path";
+import path72 from "path";
 import fs25 from "fs-extra";
 function getPendingReviewPath(cwd) {
-  return path70.join(cwd, PENDING_REVIEW_PATH);
+  return path72.join(cwd, PENDING_REVIEW_PATH);
 }
 function computeReviewId(file, section, ts) {
   return crypto2.createHash("sha1").update(`${file}|${section ?? ""}|${ts}`).digest("hex").slice(0, 12);
@@ -19572,7 +19999,7 @@ async function loadPendingReview(cwd) {
 async function savePendingReview(cwd, items) {
   const filePath = getPendingReviewPath(cwd);
   const tmpPath = `${filePath}.tmp`;
-  await fs25.ensureDir(path70.dirname(filePath));
+  await fs25.ensureDir(path72.dirname(filePath));
   const content = items.map((item) => JSON.stringify(item)).join("\n") + (items.length > 0 ? "\n" : "");
   await fs25.writeFile(tmpPath, content, "utf8");
   await fs25.rename(tmpPath, filePath);
@@ -19592,7 +20019,7 @@ async function appendPendingReview(cwd, partial) {
     risk
   };
   const filePath = getPendingReviewPath(cwd);
-  await fs25.ensureDir(path70.dirname(filePath));
+  await fs25.ensureDir(path72.dirname(filePath));
   await fs25.appendFile(filePath, JSON.stringify(item) + "\n", "utf8");
   return item;
 }
@@ -19635,14 +20062,14 @@ __export(repo_cache_exports, {
   readLastSync: () => readLastSync,
   writeLastSync: () => writeLastSync
 });
-import path71 from "path";
+import path73 from "path";
 import os4 from "os";
 import fs26 from "fs-extra";
 function getCacheRoot2() {
-  return process.env.TEAMAI_CACHE_DIR ?? path71.join(os4.homedir(), ".teamai", "cache", "repos");
+  return process.env.TEAMAI_CACHE_DIR ?? path73.join(os4.homedir(), ".teamai", "cache", "repos");
 }
 function getRepoCacheDir(provider, owner, repo) {
-  return path71.join(getCacheRoot2(), provider, owner, repo);
+  return path73.join(getCacheRoot2(), provider, owner, repo);
 }
 function getRepoSlug(provider, owner, repo) {
   const safeOwner = owner.replace(/\//g, "-");
@@ -19653,10 +20080,10 @@ async function writeLastSync(cacheDir, sha) {
   const content = `${sha}
 ${isoTs}
 `;
-  await fs26.writeFile(path71.join(cacheDir, LAST_SYNC_FILE), content, "utf8");
+  await fs26.writeFile(path73.join(cacheDir, LAST_SYNC_FILE), content, "utf8");
 }
 async function readLastSync(cacheDir) {
-  const filePath = path71.join(cacheDir, LAST_SYNC_FILE);
+  const filePath = path73.join(cacheDir, LAST_SYNC_FILE);
   const exists3 = await fs26.pathExists(filePath);
   if (!exists3) {
     return null;
@@ -19721,7 +20148,7 @@ var init_schema = __esm({
 });
 
 // src/domains/store.ts
-import path72 from "path";
+import path74 from "path";
 import fs27 from "fs-extra";
 import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 function parseAndValidate(content, filePath) {
@@ -19734,7 +20161,7 @@ function parseAndValidate(content, filePath) {
   return result.data;
 }
 async function loadDomains(cwd) {
-  const filePath = path72.join(cwd, DOMAINS_PATH);
+  const filePath = path74.join(cwd, DOMAINS_PATH);
   const exists3 = await fs27.pathExists(filePath);
   if (!exists3) {
     return DomainsFileSchema.parse({});
@@ -19747,14 +20174,14 @@ async function loadDomains(cwd) {
   return parseAndValidate(content, filePath);
 }
 async function saveDomains(cwd, data) {
-  const filePath = path72.join(cwd, DOMAINS_PATH);
-  await fs27.ensureDir(path72.dirname(filePath));
+  const filePath = path74.join(cwd, DOMAINS_PATH);
+  await fs27.ensureDir(path74.dirname(filePath));
   await fs27.writeFile(filePath, yamlStringify(data), "utf8");
 }
 async function appendHistory(cwd, event) {
   const validated = HistoryEventSchema.parse(event);
-  const filePath = path72.join(cwd, HISTORY_PATH);
-  await fs27.ensureDir(path72.dirname(filePath));
+  const filePath = path74.join(cwd, HISTORY_PATH);
+  await fs27.ensureDir(path74.dirname(filePath));
   await fs27.appendFile(filePath, JSON.stringify(validated) + "\n", "utf8");
 }
 var DOMAINS_PATH, HISTORY_PATH, MAX_CONFIG_FILE_BYTES3;
@@ -19901,8 +20328,8 @@ __export(deep_enrich_exports, {
   deepEnrich: () => deepEnrich
 });
 import { readFile as readFile8, writeFile as writeFile10, readdir as readdir4, mkdir as mkdir7 } from "fs/promises";
-import path73 from "path";
-async function readFileSafe3(filePath) {
+import path75 from "path";
+async function readFileSafe4(filePath) {
   try {
     return await readFile8(filePath, "utf-8");
   } catch {
@@ -19910,7 +20337,7 @@ async function readFileSafe3(filePath) {
   }
 }
 async function loadContext(evidenceDir) {
-  const manifestRaw = await readFileSafe3(path73.join(evidenceDir, "_manifest.json"));
+  const manifestRaw = await readFileSafe4(path75.join(evidenceDir, "_manifest.json"));
   let manifest = {};
   try {
     manifest = JSON.parse(manifestRaw);
@@ -19918,18 +20345,18 @@ async function loadContext(evidenceDir) {
     log.debug("deep-enrich: failed to parse _manifest.json");
   }
   const [indexMd, callChains, overview] = await Promise.all([
-    readFileSafe3(path73.join(evidenceDir, "index.md")),
-    readFileSafe3(path73.join(evidenceDir, "dependency-paths.md")),
-    readFileSafe3(path73.join(evidenceDir, "overview.md"))
+    readFileSafe4(path75.join(evidenceDir, "index.md")),
+    readFileSafe4(path75.join(evidenceDir, "dependency-paths.md")),
+    readFileSafe4(path75.join(evidenceDir, "overview.md"))
   ]);
-  const modulesDir = path73.join(evidenceDir, "modules");
+  const modulesDir = path75.join(evidenceDir, "modules");
   const moduleDocs = /* @__PURE__ */ new Map();
   if (await pathExists(modulesDir)) {
     try {
       const entries = await readdir4(modulesDir);
       await Promise.all(
         entries.filter((e) => e.endsWith(".md")).map(async (e) => {
-          const content = await readFileSafe3(path73.join(modulesDir, e));
+          const content = await readFileSafe4(path75.join(modulesDir, e));
           moduleDocs.set(e.replace(/\.md$/, ""), content);
         })
       );
@@ -19940,7 +20367,7 @@ async function loadContext(evidenceDir) {
   return { manifest, indexMd, callChains, overview, moduleDocs };
 }
 function progressPath(evidenceDir) {
-  return path73.join(evidenceDir, PROGRESS_PATH_SUBDIR, PROGRESS_FILENAME);
+  return path75.join(evidenceDir, PROGRESS_PATH_SUBDIR, PROGRESS_FILENAME);
 }
 function isValidProgressState(v, project) {
   if (typeof v !== "object" || v === null) return false;
@@ -19966,7 +20393,7 @@ async function loadProgress(evidenceDir, project, allComponents) {
 }
 async function saveProgress(evidenceDir, state) {
   const p = progressPath(evidenceDir);
-  await mkdir7(path73.dirname(p), { recursive: true });
+  await mkdir7(path75.dirname(p), { recursive: true });
   const updated = { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   await writeFile10(p, JSON.stringify(updated, null, 2), "utf-8");
 }
@@ -20205,7 +20632,7 @@ async function runPhaseComponents(opts, ctx, progress, docsDir) {
         log.warn(`deep-enrich[${project}]: Skipping unsafe component slug "${comp.slug}": ${e.message}`);
         continue;
       }
-      const outPath = path73.join(docsDir, `${comp.slug}.md`);
+      const outPath = path75.join(docsDir, `${comp.slug}.md`);
       await mkdir7(docsDir, { recursive: true });
       await writeFile10(outPath, content, "utf-8");
       progress.componentsDone.push(comp.slug);
@@ -20233,7 +20660,7 @@ async function runPhaseArchitecture(opts, ctx, docsDir) {
     log.warn(`deep-enrich[${project}]: Architecture overview: AI returned empty, skipping write`);
     return;
   }
-  const outPath = path73.join(docsDir, "architecture.md");
+  const outPath = path75.join(docsDir, "architecture.md");
   await mkdir7(docsDir, { recursive: true });
   await writeFile10(outPath, content, "utf-8");
   log.debug(`deep-enrich[${project}]: Architecture overview written: ${outPath}`);
@@ -20241,15 +20668,15 @@ async function runPhaseArchitecture(opts, ctx, docsDir) {
 async function runPhaseGraph(opts, ctx, docsDir) {
   const { project, evidenceDir } = opts;
   log.info(`deep-enrich[${project}]: Phase 3 \u2014 Generating deterministic graph docs`);
-  const interfacesMd = await readFileSafe3(path73.join(evidenceDir, "interfaces.md"));
+  const interfacesMd = await readFileSafe4(path75.join(evidenceDir, "interfaces.md"));
   const g1 = buildG1RelationsDoc(ctx.manifest);
   const g2 = buildG2DataflowDoc(ctx.callChains);
   const g3 = buildG3InterfacesDoc(interfacesMd);
   await mkdir7(docsDir, { recursive: true });
   await Promise.all([
-    writeFile10(path73.join(docsDir, "graph-g1-relations.md"), g1, "utf-8"),
-    writeFile10(path73.join(docsDir, "graph-g2-dataflow.md"), g2, "utf-8"),
-    writeFile10(path73.join(docsDir, "graph-g3-interfaces.md"), g3, "utf-8")
+    writeFile10(path75.join(docsDir, "graph-g1-relations.md"), g1, "utf-8"),
+    writeFile10(path75.join(docsDir, "graph-g2-dataflow.md"), g2, "utf-8"),
+    writeFile10(path75.join(docsDir, "graph-g3-interfaces.md"), g3, "utf-8")
   ]);
   log.debug(`deep-enrich[${project}]: Graph docs written: ${docsDir}`);
 }
@@ -20355,14 +20782,14 @@ async function runPhaseAiGraph(opts, ctx, docsDir) {
   await mkdir7(docsDir, { recursive: true });
   const g6HasEdges = (ctx.manifest.edges ?? []).length > 0;
   const g6 = buildG6Content(project, ctx.manifest);
-  await writeFile10(path73.join(docsDir, "graph-g6-multihop.md"), g6, "utf-8");
+  await writeFile10(path75.join(docsDir, "graph-g6-multihop.md"), g6, "utf-8");
   log.debug(`deep-enrich[${project}]: G6 multi-hop analysis written`);
   let g5Generated = false;
   if (ctx.moduleDocs.size < 2) {
     log.warn(`deep-enrich[${project}]: Insufficient modules (${ctx.moduleDocs.size} < 2), skipping G5`);
     return { g5Generated, g6Generated: g6HasEdges };
   }
-  const architectureMd = await readFileSafe3(path73.join(docsDir, "architecture.md"));
+  const architectureMd = await readFileSafe4(path75.join(docsDir, "architecture.md"));
   if (!architectureMd.trim()) {
     log.warn(`deep-enrich[${project}]: No architecture doc, skipping G5 scenarios`);
     return { g5Generated, g6Generated: g6HasEdges };
@@ -20372,7 +20799,7 @@ async function runPhaseAiGraph(opts, ctx, docsDir) {
   try {
     const g5Content = await callClaude(prompt);
     if (g5Content.trim()) {
-      await writeFile10(path73.join(docsDir, "graph-g5-scenarios.md"), g5Content, "utf-8");
+      await writeFile10(path75.join(docsDir, "graph-g5-scenarios.md"), g5Content, "utf-8");
       log.debug(`deep-enrich[${project}]: G5 scenario diagrams written`);
       g5Generated = true;
     }
@@ -20390,10 +20817,10 @@ async function runPhaseIndexEnhance(opts, ctx, docsDir, graphFlags) {
     hasG5: graphFlags?.g5Generated ?? false,
     hasG6: graphFlags?.g6Generated ?? true
   });
-  await writeFile10(path73.join(docsDir, "README.md"), graphReadme, "utf-8");
+  await writeFile10(path75.join(docsDir, "README.md"), graphReadme, "utf-8");
   log.debug(`deep-enrich[${project}]: graph/README.md routing table written`);
   const { wikiRoot } = opts;
-  const domainsJson = await readFileSafe3(path73.join(evidenceDir, "_domains.json"));
+  const domainsJson = await readFileSafe4(path75.join(evidenceDir, "_domains.json"));
   let keywords = [];
   let description = "";
   try {
@@ -20402,8 +20829,8 @@ async function runPhaseIndexEnhance(opts, ctx, docsDir, graphFlags) {
     description = domains.description ?? "";
   } catch {
   }
-  const routerPath = path73.join(wikiRoot, "router.md");
-  const routerContent = await readFileSafe3(routerPath);
+  const routerPath = path75.join(wikiRoot, "router.md");
+  const routerContent = await readFileSafe4(routerPath);
   const projectLink = `[[evidence/code/${project}/index]]`;
   if (routerContent && !routerContent.includes(projectLink)) {
     const kw = keywords.length > 0 ? ` [${keywords.slice(0, 5).join(", ")}]` : "";
@@ -20412,8 +20839,8 @@ async function runPhaseIndexEnhance(opts, ctx, docsDir, graphFlags) {
 `;
     await writeFile10(routerPath, routerContent.trimEnd() + "\n" + line, "utf-8");
   }
-  const indexPath = path73.join(wikiRoot, "index.md");
-  const indexContent = await readFileSafe3(indexPath);
+  const indexPath = path75.join(wikiRoot, "index.md");
+  const indexContent = await readFileSafe4(indexPath);
   if (indexContent && !indexContent.includes(`evidence/code/${project}/`)) {
     const navBlock = [
       `### ${project}`,
@@ -20437,7 +20864,7 @@ async function runPhaseIndexEnhance(opts, ctx, docsDir, graphFlags) {
 }
 async function deepEnrich(opts) {
   const { project, evidenceDir } = opts;
-  const docsDir = path73.join(evidenceDir, "docs");
+  const docsDir = path75.join(evidenceDir, "docs");
   log.info(`deep-enrich[${project}]: Starting deep knowledge generation, evidenceDir=${evidenceDir}`);
   const ctx = await loadContext(evidenceDir);
   let components = ctx.manifest.components ?? [];
@@ -20526,11 +20953,11 @@ var graph_aggregate_exports = {};
 __export(graph_aggregate_exports, {
   aggregateGlobalGraph: () => aggregateGlobalGraph
 });
-import path74 from "path";
+import path76 from "path";
 import { readdir as readdir5 } from "fs/promises";
 import fs28 from "fs-extra";
 async function aggregateGlobalGraph(teamwikiRoot) {
-  const evidenceBase = path74.join(teamwikiRoot, "evidence", "code");
+  const evidenceBase = path76.join(teamwikiRoot, "evidence", "code");
   if (!await fs28.pathExists(evidenceBase)) return null;
   const { mergeGraphs: mergeGraphs2 } = await Promise.resolve().then(() => (init_adapters(), adapters_exports));
   const { detectCrossRepoEdges: detectCrossRepoEdges2 } = await Promise.resolve().then(() => (init_import_repo(), import_repo_exports));
@@ -20538,7 +20965,7 @@ async function aggregateGlobalGraph(teamwikiRoot) {
   const projectDirs = await readdir5(evidenceBase, { withFileTypes: true });
   for (const dir of projectDirs) {
     if (!dir.isDirectory()) continue;
-    const graphPath = path74.join(evidenceBase, dir.name, ".indices", "graph-index.json");
+    const graphPath = path76.join(evidenceBase, dir.name, ".indices", "graph-index.json");
     if (!await fs28.pathExists(graphPath)) continue;
     try {
       const overlay = JSON.parse(await fs28.readFile(graphPath, "utf8"));
@@ -20556,8 +20983,8 @@ async function aggregateGlobalGraph(teamwikiRoot) {
     }
   }
   if (globalGraph) {
-    const destPath = path74.join(teamwikiRoot, ".indices", "graph-index.json");
-    await fs28.ensureDir(path74.dirname(destPath));
+    const destPath = path76.join(teamwikiRoot, ".indices", "graph-index.json");
+    await fs28.ensureDir(path76.dirname(destPath));
     await fs28.writeFile(destPath, JSON.stringify(globalGraph, null, 2), "utf8");
     log.info(`global graph-index.json aggregated (${globalGraph.nodes.length} nodes, ${globalGraph.edges.length} edges)`);
     return { nodes: globalGraph.nodes.length, edges: globalGraph.edges.length };
@@ -20579,7 +21006,7 @@ __export(import_repo_exports, {
   detectDomainDrift: () => detectDomainDrift,
   importFromRepo: () => importFromRepo
 });
-import path75 from "path";
+import path77 from "path";
 import fs29 from "fs-extra";
 import chalk5 from "chalk";
 function detectCrossRepoEdges(overlay, existing) {
@@ -20694,9 +21121,9 @@ async function detectPrimaryLanguage(repoPath, maxDepth = 3) {
         if (["node_modules", ".git", "dist", "build", "__pycache__", ".venv"].includes(name)) {
           continue;
         }
-        await walk2(path75.join(dir, name), depth + 1);
+        await walk2(path77.join(dir, name), depth + 1);
       } else if (entry.isFile()) {
-        const ext = path75.extname(name).toLowerCase();
+        const ext = path77.extname(name).toLowerCase();
         const lang = langExtMap[ext];
         if (lang) {
           counts.set(lang, (counts.get(lang) ?? 0) + 1);
@@ -20720,7 +21147,7 @@ async function buildRepoMetaFromPath(repoPath, url, name) {
   const meta = { url, name };
   const readmeCandidates = ["README.md", "readme.md", "README.zh-CN.md", "README.zh.md"];
   for (const candidate of readmeCandidates) {
-    const filePath = path75.join(repoPath, candidate);
+    const filePath = path77.join(repoPath, candidate);
     if (await fs29.pathExists(filePath)) {
       try {
         const content = await fs29.readFile(filePath, "utf8");
@@ -20731,7 +21158,7 @@ async function buildRepoMetaFromPath(repoPath, url, name) {
       }
     }
   }
-  const pkgPath = path75.join(repoPath, "package.json");
+  const pkgPath = path77.join(repoPath, "package.json");
   if (await fs29.pathExists(pkgPath)) {
     try {
       const pkgRaw = await fs29.readFile(pkgPath, "utf8");
@@ -20746,7 +21173,7 @@ async function buildRepoMetaFromPath(repoPath, url, name) {
     }
   }
   if (!meta.description) {
-    const setupPath = path75.join(repoPath, "setup.py");
+    const setupPath = path77.join(repoPath, "setup.py");
     if (await fs29.pathExists(setupPath)) {
       try {
         const setupContent = await fs29.readFile(setupPath, "utf8");
@@ -20877,7 +21304,7 @@ async function importFromRepo(opts) {
   const cacheDir = getRepoCacheDir(providerName, owner, repoName);
   const slug = getRepoSlug(providerName, owner, repoName);
   const lastSync = await readLastSync(cacheDir);
-  const cacheExists = await fs29.pathExists(path75.join(cacheDir, ".git"));
+  const cacheExists = await fs29.pathExists(path77.join(cacheDir, ".git"));
   const useIncremental = incremental && cacheExists && lastSync !== null;
   let cloneSha;
   let cloneBranch;
@@ -20955,42 +21382,42 @@ async function importFromRepo(opts) {
     mrTeamConfig = { repo: tc.repo, provider: tc.provider, reviewers: tc.reviewers };
     mrLocalConfig = { repo: lc.repo, username: lc.username };
   } catch {
-    teamRepoDir = path75.join(process.cwd(), ".teamai", "team-repo");
+    teamRepoDir = path77.join(process.cwd(), ".teamai", "team-repo");
   }
-  const teamwikiRoot = output ? path75.resolve(output, "..", "teamwiki") : path75.join(teamRepoDir, "teamwiki");
+  const teamwikiRoot = output ? path77.resolve(output, "..", "teamwiki") : path77.join(teamRepoDir, "teamwiki");
   if (!dryRun) {
-    const cacheWiki = path75.join(cacheDir, "teamwiki");
+    const cacheWiki = path77.join(cacheDir, "teamwiki");
     try {
       if (incremental) {
-        const destIndices = path75.join(teamwikiRoot, ".indices");
-        const cacheIndices = path75.join(cacheDir, "teamwiki", ".indices");
+        const destIndices = path77.join(teamwikiRoot, ".indices");
+        const cacheIndices = path77.join(cacheDir, "teamwiki", ".indices");
         await fs29.ensureDir(cacheIndices);
         for (const f of ["facts-cache.json", "interfaces-cache.json"]) {
-          const src = path75.join(destIndices, f);
+          const src = path77.join(destIndices, f);
           if (await fs29.pathExists(src)) {
-            await fs29.copy(src, path75.join(cacheIndices, f));
+            await fs29.copy(src, path77.join(cacheIndices, f));
           }
         }
-        const existingManifest = path75.join(teamwikiRoot, "source-manifest.json");
+        const existingManifest = path77.join(teamwikiRoot, "source-manifest.json");
         if (await fs29.pathExists(existingManifest)) {
-          await fs29.copy(existingManifest, path75.join(cacheDir, "teamwiki", "source-manifest.json"));
+          await fs29.copy(existingManifest, path77.join(cacheDir, "teamwiki", "source-manifest.json"));
         }
       }
       await extractCodebase({ path: cacheDir, project: slug, json: false, skipEnrich, incremental });
       if (await fs29.pathExists(cacheWiki)) {
-        const evidenceSrc = path75.join(cacheWiki, "evidence", "code", slug);
-        const evidenceDest = path75.join(teamwikiRoot, "evidence", "code", slug);
+        const evidenceSrc = path77.join(cacheWiki, "evidence", "code", slug);
+        const evidenceDest = path77.join(teamwikiRoot, "evidence", "code", slug);
         if (await fs29.pathExists(evidenceDest)) {
           const entries = await fs29.readdir(evidenceDest);
           for (const entry of entries) {
             if (entry === ".indices") continue;
-            await fs29.remove(path75.join(evidenceDest, entry));
+            await fs29.remove(path77.join(evidenceDest, entry));
           }
         }
         await fs29.ensureDir(evidenceDest);
         await fs29.copy(evidenceSrc, evidenceDest, { overwrite: true });
         if (codebaseMd) {
-          const overviewPath = path75.join(evidenceDest, "overview.md");
+          const overviewPath = path77.join(evidenceDest, "overview.md");
           const existing = await fs29.readFile(overviewPath, "utf8").catch(() => "");
           const aiNarrative = codebaseMd.replace(/^---[\s\S]*?---\n*/m, "");
           const marker = "## AI Architecture Narrative";
@@ -21013,31 +21440,31 @@ ${aiNarrative}`;
           }
           await fs29.writeFile(overviewPath, combined, "utf8");
         }
-        const srcGraph = path75.join(cacheWiki, ".indices", "graph-index.json");
+        const srcGraph = path77.join(cacheWiki, ".indices", "graph-index.json");
         if (await fs29.pathExists(srcGraph)) {
-          const evidenceGraphDir = path75.join(teamwikiRoot, "evidence", "code", slug, ".indices");
+          const evidenceGraphDir = path77.join(teamwikiRoot, "evidence", "code", slug, ".indices");
           await fs29.ensureDir(evidenceGraphDir);
-          await fs29.copy(srcGraph, path75.join(evidenceGraphDir, "graph-index.json"));
+          await fs29.copy(srcGraph, path77.join(evidenceGraphDir, "graph-index.json"));
         } else {
           log.debug(`[graph] per-repo graph-index.json not found, skipping copy`);
         }
-        const cacheIndices = path75.join(cacheWiki, ".indices");
-        const destIndices = path75.join(teamwikiRoot, ".indices");
+        const cacheIndices = path77.join(cacheWiki, ".indices");
+        const destIndices = path77.join(teamwikiRoot, ".indices");
         for (const cacheFile of ["facts-cache.json", "interfaces-cache.json"]) {
-          const src = path75.join(cacheIndices, cacheFile);
+          const src = path77.join(cacheIndices, cacheFile);
           if (await fs29.pathExists(src)) {
             await fs29.ensureDir(destIndices);
-            await fs29.copy(src, path75.join(destIndices, cacheFile), { overwrite: true });
+            await fs29.copy(src, path77.join(destIndices, cacheFile), { overwrite: true });
           }
         }
-        const srcManifest = path75.join(cacheWiki, "source-manifest.json");
+        const srcManifest = path77.join(cacheWiki, "source-manifest.json");
         if (await fs29.pathExists(srcManifest)) {
-          await fs29.copy(srcManifest, path75.join(teamwikiRoot, "source-manifest.json"), { overwrite: true });
+          await fs29.copy(srcManifest, path77.join(teamwikiRoot, "source-manifest.json"), { overwrite: true });
         }
         await fs29.remove(cacheWiki);
       }
       if (explicitDomain) {
-        const domainsJsonPath = path75.join(teamwikiRoot, "evidence", "code", slug, "_domains.json");
+        const domainsJsonPath = path77.join(teamwikiRoot, "evidence", "code", slug, "_domains.json");
         if (await fs29.pathExists(domainsJsonPath)) {
           try {
             const existing = JSON.parse(await fs29.readFile(domainsJsonPath, "utf8"));
@@ -21050,8 +21477,8 @@ ${aiNarrative}`;
         }
       }
       const { routerTemplate: routerTemplate2, indexTemplate: indexTemplate2, HOT_TEMPLATE: HOT_TEMPLATE2 } = await Promise.resolve().then(() => (init_templates(), templates_exports));
-      const routerPath = path75.join(teamwikiRoot, "router.md");
-      const indexPath = path75.join(teamwikiRoot, "index.md");
+      const routerPath = path77.join(teamwikiRoot, "router.md");
+      const indexPath = path77.join(teamwikiRoot, "index.md");
       const projectLink = `[[evidence/code/${slug}/index]]`;
       if (await fs29.pathExists(routerPath)) {
         const router = await fs29.readFile(routerPath, "utf8");
@@ -21077,8 +21504,8 @@ ${aiNarrative}`;
       } else {
         await fs29.writeFile(indexPath, indexTemplate2([{ slug, label: slug }]), "utf8");
       }
-      if (!await fs29.pathExists(path75.join(teamwikiRoot, "hot.md"))) {
-        await fs29.writeFile(path75.join(teamwikiRoot, "hot.md"), HOT_TEMPLATE2, "utf8");
+      if (!await fs29.pathExists(path77.join(teamwikiRoot, "hot.md"))) {
+        await fs29.writeFile(path77.join(teamwikiRoot, "hot.md"), HOT_TEMPLATE2, "utf8");
       }
       log.info(chalk5.green(`\u2713 teamwiki/ knowledge graph updated: ${slug}`));
     } catch (err) {
@@ -21100,8 +21527,8 @@ ${aiNarrative}`;
     }
   }
   if (!dryRun && !skipEnrich && teamwikiRoot) {
-    const evidenceDir = path75.join(teamwikiRoot, "evidence", "code", slug);
-    if (await fs29.pathExists(path75.join(evidenceDir, "_manifest.json"))) {
+    const evidenceDir = path77.join(teamwikiRoot, "evidence", "code", slug);
+    if (await fs29.pathExists(path77.join(evidenceDir, "_manifest.json"))) {
       try {
         const { deepEnrich: deepEnrich2 } = await Promise.resolve().then(() => (init_deep_enrich(), deep_enrich_exports));
         await deepEnrich2({ project: slug, evidenceDir, wikiRoot: teamwikiRoot, cacheDir });
@@ -21220,14 +21647,14 @@ var init_store2 = __esm({
 });
 
 // src/utils/team-codebase-paths.ts
-import path76 from "path";
+import path78 from "path";
 function getTeamCodebasePaths(cwd, output) {
-  const root = output ?? path76.join(cwd, "docs", TEAM_CODEBASE_DIR);
+  const root = output ?? path78.join(cwd, "docs", TEAM_CODEBASE_DIR);
   return {
     root,
-    index: path76.join(root, "index.md"),
-    domainsDir: path76.join(root, "domains"),
-    reposDir: path76.join(root, "repos")
+    index: path78.join(root, "index.md"),
+    domainsDir: path78.join(root, "domains"),
+    reposDir: path78.join(root, "repos")
   };
 }
 function safeDomainSlug(name) {
@@ -21246,12 +21673,12 @@ var init_team_codebase_paths = __esm({
 });
 
 // src/aggregate.ts
-import path77 from "path";
+import path79 from "path";
 import fs31 from "fs-extra";
-import matter7 from "gray-matter";
+import matter8 from "gray-matter";
 async function parseRepoMd(filePath, slug) {
   const raw = await fs31.readFile(filePath, "utf8");
-  const { data, content } = matter7(raw);
+  const { data, content } = matter8(raw);
   const fm = data;
   const url = typeof fm.repo_url === "string" ? fm.repo_url : typeof fm.url === "string" ? fm.url : "";
   let name = typeof fm.repo_name === "string" ? fm.repo_name : "";
@@ -21293,7 +21720,7 @@ async function regenerateAggregate(opts) {
   for (const file of repoFiles) {
     const slug = file.replace(/\.md$/, "");
     try {
-      const summary = await parseRepoMd(path77.join(paths.reposDir, file), slug);
+      const summary = await parseRepoMd(path79.join(paths.reposDir, file), slug);
       repoMap.set(slug, summary);
     } catch {
     }
@@ -21330,7 +21757,7 @@ async function regenerateAggregate(opts) {
   );
   for (const oldFile of existingDomainFiles) {
     if (!newDomainFileNames.has(oldFile)) {
-      await fs31.remove(path77.join(paths.domainsDir, oldFile));
+      await fs31.remove(path79.join(paths.domainsDir, oldFile));
     }
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -21339,7 +21766,7 @@ async function regenerateAggregate(opts) {
     const domainEntry = domains.domains.find((d) => d.name === domainName);
     const description = domainEntry?.description ?? "";
     const safeSlug = safeDomainSlug(domainName);
-    const outputPath = path77.join(paths.domainsDir, `domain-${safeSlug}.md`);
+    const outputPath = path79.join(paths.domainsDir, `domain-${safeSlug}.md`);
     const tableRows = slugs.map((slug) => {
       const s = repoMap.get(slug);
       if (!s) return "";
@@ -21443,7 +21870,7 @@ var init_aggregate = __esm({
 });
 
 // src/import-repo-list.ts
-import path78 from "path";
+import path80 from "path";
 function sortByPriority(entries) {
   const order = { high: 0, normal: 1, low: 2 };
   return [...entries].sort((a, b) => {
@@ -21521,7 +21948,7 @@ async function importFromRepoList(opts) {
       const { autoDetectInit: autoDetectInit2 } = await Promise.resolve().then(() => (init_config(), config_exports));
       const { localConfig: lc } = await autoDetectInit2();
       const teamRepoPath = lc.repo.localPath;
-      const teamwikiRoot = path78.join(teamRepoPath, "teamwiki");
+      const teamwikiRoot = path80.join(teamRepoPath, "teamwiki");
       const { aggregateGlobalGraph: aggregateGlobalGraph2 } = await Promise.resolve().then(() => (init_graph_aggregate(), graph_aggregate_exports));
       await aggregateGlobalGraph2(teamwikiRoot);
     } catch (e) {
@@ -21538,7 +21965,7 @@ async function importFromRepoList(opts) {
         try {
           const { autoDetectInit: autoDetectInit2 } = await Promise.resolve().then(() => (init_config(), config_exports));
           const { localConfig: lc } = await autoDetectInit2();
-          resolvedOutput = path78.join(lc.repo.localPath, "docs", "team-codebase");
+          resolvedOutput = path80.join(lc.repo.localPath, "docs", "team-codebase");
           domainsBase = lc.repo.localPath;
         } catch {
         }
@@ -21600,9 +22027,9 @@ __export(rebuild_wiki_index_exports, {
   rebuildWikiIndex: () => rebuildWikiIndex
 });
 import { readFile as readFile9, readdir as readdir6, stat as stat4, writeFile as writeFile11 } from "fs/promises";
-import path79 from "path";
+import path81 from "path";
 async function rebuildWikiIndex(teamwikiRoot) {
-  const evidenceCodeDir = path79.join(teamwikiRoot, "evidence", "code");
+  const evidenceCodeDir = path81.join(teamwikiRoot, "evidence", "code");
   if (!await pathExists(evidenceCodeDir)) return;
   const projects = [];
   let totalFacts = 0, totalNodes = 0, totalEdges = 0;
@@ -21610,7 +22037,7 @@ async function rebuildWikiIndex(teamwikiRoot) {
   let totalCallChains = 0;
   const dirs = await readdir6(evidenceCodeDir);
   for (const dir of dirs) {
-    const dirPath = path79.join(evidenceCodeDir, dir);
+    const dirPath = path81.join(evidenceCodeDir, dir);
     const dirStat = await stat4(dirPath).catch(() => null);
     if (!dirStat?.isDirectory()) continue;
     const info = {
@@ -21623,7 +22050,7 @@ async function rebuildWikiIndex(teamwikiRoot) {
       keywords: [],
       domain: ""
     };
-    const overviewPath = path79.join(dirPath, "overview.md");
+    const overviewPath = path81.join(dirPath, "overview.md");
     if (await pathExists(overviewPath)) {
       const content = await readFile9(overviewPath, "utf-8");
       const bodyStart = content.indexOf("\n\n", content.indexOf("---", 3));
@@ -21636,7 +22063,7 @@ async function rebuildWikiIndex(teamwikiRoot) {
         }
       }
     }
-    const projectIndex = path79.join(dirPath, "index.md");
+    const projectIndex = path81.join(dirPath, "index.md");
     if (await pathExists(projectIndex)) {
       const content = await readFile9(projectIndex, "utf-8");
       const factsMatch = content.match(/Facts:\s*(\d+)/);
@@ -21646,7 +22073,7 @@ async function rebuildWikiIndex(teamwikiRoot) {
         info.interfaces[m[1]] = (info.interfaces[m[1]] ?? 0) + parseInt(m[2], 10);
       }
     }
-    const manifestPath = path79.join(dirPath, "_manifest.json");
+    const manifestPath = path81.join(dirPath, "_manifest.json");
     if (await pathExists(manifestPath)) {
       try {
         const raw = await readFile9(manifestPath, "utf-8");
@@ -21658,7 +22085,7 @@ async function rebuildWikiIndex(teamwikiRoot) {
       } catch {
       }
     }
-    const domainsPath = path79.join(dirPath, "_domains.json");
+    const domainsPath = path81.join(dirPath, "_domains.json");
     if (await pathExists(domainsPath)) {
       try {
         const raw = await readFile9(domainsPath, "utf-8");
@@ -21675,7 +22102,7 @@ async function rebuildWikiIndex(teamwikiRoot) {
       } catch {
       }
     }
-    const chainsPath = path79.join(dirPath, "dependency-paths.md");
+    const chainsPath = path81.join(dirPath, "dependency-paths.md");
     if (await pathExists(chainsPath)) {
       const content = await readFile9(chainsPath, "utf-8");
       const chainMatch = content.match(/(\d+)\s*call chain/);
@@ -21691,7 +22118,7 @@ async function rebuildWikiIndex(teamwikiRoot) {
     }
     projects.push(info);
   }
-  const graphPath = path79.join(teamwikiRoot, ".indices", "graph-index.json");
+  const graphPath = path81.join(teamwikiRoot, ".indices", "graph-index.json");
   if (await pathExists(graphPath)) {
     try {
       const raw = await readFile9(graphPath, "utf-8");
@@ -21732,7 +22159,7 @@ async function rebuildWikiIndex(teamwikiRoot) {
   routerLines.push("4. **\u8C03\u7528\u94FE/\u6392\u969C** \u2192 \u67E5\u5BF9\u5E94\u4ED3\u5E93\u7684 dependency-paths.md");
   routerLines.push("5. **\u6A21\u5757\u804C\u8D23\u6982\u8FF0** \u2192 \u67E5 overview.md \u6216 modules/*.md");
   routerLines.push("");
-  await writeFile11(path79.join(teamwikiRoot, "router.md"), routerLines.join("\n"), "utf-8");
+  await writeFile11(path81.join(teamwikiRoot, "router.md"), routerLines.join("\n"), "utf-8");
   const indexLines = [
     "# Team Wiki Index",
     "",
@@ -21768,9 +22195,9 @@ async function rebuildWikiIndex(teamwikiRoot) {
   indexLines.push("- [router.md](./router.md) \u2014 \u4EA7\u54C1\u57DF\u8DEF\u7531\uFF08\u8868\u683C + \u8DEF\u7531\u89C4\u5219\uFF09");
   indexLines.push("- [hot.md](./hot.md) \u2014 \u6D3B\u8DC3\u5DE5\u4F5C\u8BB0\u5FC6");
   indexLines.push("");
-  await writeFile11(path79.join(teamwikiRoot, "index.md"), indexLines.join("\n"), "utf-8");
-  if (!await pathExists(path79.join(teamwikiRoot, "hot.md"))) {
-    await writeFile11(path79.join(teamwikiRoot, "hot.md"), HOT_TEMPLATE, "utf-8");
+  await writeFile11(path81.join(teamwikiRoot, "index.md"), indexLines.join("\n"), "utf-8");
+  if (!await pathExists(path81.join(teamwikiRoot, "hot.md"))) {
+    await writeFile11(path81.join(teamwikiRoot, "hot.md"), HOT_TEMPLATE, "utf-8");
   }
   log.debug(`rebuildWikiIndex: ${projects.length} projects, ${totalNodes} nodes, ${totalEdges} edges`);
 }
@@ -21809,7 +22236,7 @@ var init_rebuild_wiki_index = __esm({
 });
 
 // src/import-org.ts
-import path80 from "path";
+import path82 from "path";
 import fs32 from "fs-extra";
 import { stringify as yamlStringify2 } from "yaml";
 function parseOrgInput(org) {
@@ -21888,9 +22315,9 @@ async function importFromOrg(opts) {
     return;
   }
   log.info(`${filteredRepos.length} repos after filtering, generating whitelist...`);
-  const whitelistDraftPath = path80.join(cwd, WHITELIST_DRAFT_PATH);
+  const whitelistDraftPath = path82.join(cwd, WHITELIST_DRAFT_PATH);
   if (!opts.dryRun) {
-    await fs32.ensureDir(path80.dirname(whitelistDraftPath));
+    await fs32.ensureDir(path82.dirname(whitelistDraftPath));
     const lines = ["version: 1", "repos:"];
     for (const repo of filteredRepos) {
       lines.push(`  - url: ${repo.url}`);
@@ -21920,8 +22347,8 @@ async function importFromOrg(opts) {
         );
         try {
           const { rebuildWikiIndex: rebuildWikiIndex2 } = await Promise.resolve().then(() => (init_rebuild_wiki_index(), rebuild_wiki_index_exports));
-          const teamRepoPath = path80.join(cwd, ".teamai", "team-repo");
-          const teamRepoWiki = path80.join(teamRepoPath, "teamwiki");
+          const teamRepoPath = path82.join(cwd, ".teamai", "team-repo");
+          const teamRepoWiki = path82.join(teamRepoPath, "teamwiki");
           if (await fs32.pathExists(teamRepoWiki)) {
             await rebuildWikiIndex2(teamRepoWiki);
             log.info("teamwiki router.md / index.md rebuilt");
@@ -21963,7 +22390,7 @@ var init_import_org = __esm({
 });
 
 // src/iwiki-dual.ts
-import path81 from "path";
+import path83 from "path";
 import fs33 from "fs-extra";
 function parseIWikiInput2(input) {
   const trimmed = input.trim();
@@ -22128,10 +22555,10 @@ async function importFromIWikiDual(opts) {
     return { sectionsUpdated: [], pendingReview: false };
   }
   const paths = getTeamCodebasePaths(cwd, opts.output);
-  const filePath = path81.join(paths.root, "external-knowledge.md");
+  const filePath = path83.join(paths.root, "external-knowledge.md");
   if (opts.requireReview) {
     if (!opts.dryRun) {
-      const relativeFilePath = path81.relative(cwd, filePath);
+      const relativeFilePath = path83.relative(cwd, filePath);
       for (const sectionKey of sections) {
         const body = aiOutput[sectionKey] ?? "";
         if (!body) continue;
@@ -22198,7 +22625,7 @@ var import_exports = {};
 __export(import_exports, {
   importCmd: () => importCmd
 });
-import path82 from "path";
+import path84 from "path";
 import os5 from "os";
 import fs34 from "fs-extra";
 import { Listr, PRESET_TIMER } from "listr2";
@@ -22316,7 +22743,7 @@ async function importCmd(opts) {
           task: async (ctx) => {
             const { learning, repoUrl } = await importFromMR({
               url: opts.fromMr,
-              learningsDir: path82.join(localConfig.repo.localPath, "learnings"),
+              learningsDir: path84.join(localConfig.repo.localPath, "learnings"),
               all: opts.all,
               outputDir: opts.output,
               repoPath: opts.dryRun ? void 0 : localConfig.repo.localPath,
@@ -22330,7 +22757,7 @@ async function importCmd(opts) {
           title: "Incremental teamwiki update",
           skip: (ctx) => !ctx.repoUrl || !!opts.dryRun || !!opts.output,
           task: async (ctx, task) => {
-            const teamwikiRoot = path82.join(localConfig.repo.localPath, "teamwiki");
+            const teamwikiRoot = path84.join(localConfig.repo.localPath, "teamwiki");
             try {
               const { detectProvider: detectProvider2, getProvider: getProvider2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
               const { getRepoSlug: getRepoSlug2 } = await Promise.resolve().then(() => (init_repo_cache(), repo_cache_exports));
@@ -22338,7 +22765,7 @@ async function importCmd(opts) {
               const provider = getProvider2(providerName);
               const repoInfo = provider.parseRepoInput(ctx.repoUrl);
               const slug = getRepoSlug2(providerName, repoInfo.owner, repoInfo.repo);
-              const evidenceDir = path82.join(teamwikiRoot, "evidence", "code", slug);
+              const evidenceDir = path84.join(teamwikiRoot, "evidence", "code", slug);
               if (await fs34.pathExists(evidenceDir)) {
                 task.output = `Updating ${slug}...`;
                 await importFromRepo({
@@ -22383,18 +22810,18 @@ async function importCmd(opts) {
         setSilent(false);
       }
     } else if (opts.dir) {
-      const dirPath = path82.resolve(opts.dir);
+      const dirPath = path84.resolve(opts.dir);
       if (!await fs34.pathExists(dirPath)) {
         throw new Error(`Directory not found: ${dirPath}`);
       }
-      const slug = path82.basename(dirPath);
+      const slug = path84.basename(dirPath);
       log.info(`Scanning local directory: ${dirPath} (project: ${slug})`);
       if (opts.dryRun) {
         log.info(`[dry-run] skipping code extraction, no action taken`);
         log.success(`Local directory ${slug} import complete (dry-run)`);
         return;
       }
-      const tmpExtractDir = await fs34.mkdtemp(path82.join(os5.tmpdir(), "teamai-extract-"));
+      const tmpExtractDir = await fs34.mkdtemp(path84.join(os5.tmpdir(), "teamai-extract-"));
       try {
         const { extractCodebase: extractCodebase2 } = await Promise.resolve().then(() => (init_codebase_extract(), codebase_extract_exports));
         await extractCodebase2({
@@ -22404,9 +22831,9 @@ async function importCmd(opts) {
           skipEnrich: opts.skipEnrich ?? false,
           outputRoot: tmpExtractDir
         });
-        const srcWiki = path82.join(tmpExtractDir, "teamwiki");
+        const srcWiki = path84.join(tmpExtractDir, "teamwiki");
         if (opts.output) {
-          const outputWiki = path82.join(opts.output, "teamwiki");
+          const outputWiki = path84.join(opts.output, "teamwiki");
           if (await fs34.pathExists(srcWiki)) {
             await fs34.copy(srcWiki, outputWiki, { overwrite: true });
             log.info(`Output written: ${outputWiki}`);
@@ -22414,19 +22841,19 @@ async function importCmd(opts) {
         } else {
           const { localConfig } = await autoDetectInit();
           const teamRepoPath = localConfig.repo.localPath;
-          const teamwikiRoot = path82.join(teamRepoPath, "teamwiki");
+          const teamwikiRoot = path84.join(teamRepoPath, "teamwiki");
           if (await fs34.pathExists(srcWiki)) {
-            const evidenceSrc = path82.join(srcWiki, "evidence", "code", slug);
-            const evidenceDest = path82.join(teamwikiRoot, "evidence", "code", slug);
+            const evidenceSrc = path84.join(srcWiki, "evidence", "code", slug);
+            const evidenceDest = path84.join(teamwikiRoot, "evidence", "code", slug);
             if (await fs34.pathExists(evidenceSrc)) {
-              await fs34.ensureDir(path82.dirname(evidenceDest));
+              await fs34.ensureDir(path84.dirname(evidenceDest));
               await fs34.copy(evidenceSrc, evidenceDest, { overwrite: true });
             }
-            const srcGraph = path82.join(srcWiki, ".indices", "graph-index.json");
+            const srcGraph = path84.join(srcWiki, ".indices", "graph-index.json");
             if (await fs34.pathExists(srcGraph)) {
-              const destGraphDir = path82.join(evidenceDest, ".indices");
+              const destGraphDir = path84.join(evidenceDest, ".indices");
               await fs34.ensureDir(destGraphDir);
-              await fs34.copy(srcGraph, path82.join(destGraphDir, "graph-index.json"), { overwrite: true });
+              await fs34.copy(srcGraph, path84.join(destGraphDir, "graph-index.json"), { overwrite: true });
             }
             log.info(`teamwiki/ knowledge graph updated: ${slug}`);
           }
@@ -22492,12 +22919,12 @@ __export(mr_hint_exports, {
 });
 import { spawnSync as spawnSync3 } from "child_process";
 import fs35 from "fs";
-import path83 from "path";
+import path85 from "path";
 function repoSlug(owner, repo) {
   return `${owner}/${repo}`.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function getCachePath2(owner, repo) {
-  return path83.join(
+  return path85.join(
     process.env.HOME ?? "",
     ".teamai",
     "sessions",
@@ -22520,7 +22947,7 @@ function loadCache(owner, repo) {
 function saveCache(owner, repo, cache) {
   try {
     const cachePath = getCachePath2(owner, repo);
-    const dir = path83.dirname(cachePath);
+    const dir = path85.dirname(cachePath);
     if (!fs35.existsSync(dir)) fs35.mkdirSync(dir, { recursive: true });
     fs35.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
   } catch {
@@ -22667,7 +23094,7 @@ function buildHintMessage2(mrs) {
 async function computeMrHintOutput() {
   if (process.env.TEAMAI_MR_HINT_DISABLED === "1") return null;
   const rawCwd = process.env.TEAMAI_MR_HINT_CWD ?? process.cwd();
-  const cwd = path83.resolve(rawCwd);
+  const cwd = path85.resolve(rawCwd);
   try {
     if (!fs35.statSync(cwd).isDirectory()) {
       return null;
@@ -22735,10 +23162,10 @@ var init_mr_hint = __esm({
 });
 
 // src/codebase-lint.ts
-import path84 from "path";
+import path86 from "path";
 import os6 from "os";
 import fs36 from "fs-extra";
-import matter8 from "gray-matter";
+import matter9 from "gray-matter";
 import chalk6 from "chalk";
 function severityAtLeast(issue, threshold) {
   return SEVERITY_ORDER[issue] >= SEVERITY_ORDER[threshold];
@@ -22946,7 +23373,7 @@ async function lintTeamCodebase(opts) {
       fixable: false
     });
   }
-  const whitelistPath = path84.join(opts.cwd, ".teamai", "repo-whitelist.yaml");
+  const whitelistPath = path86.join(opts.cwd, ".teamai", "repo-whitelist.yaml");
   let whitelistData = null;
   try {
     whitelistData = await loadRepoList(whitelistPath);
@@ -22983,7 +23410,7 @@ async function lintTeamCodebase(opts) {
     for (const url of allDomainUrls) {
       const slug = urlToSlugMap.get(url);
       if (!slug) continue;
-      const mdPath = path84.join(paths.reposDir, `${slug}.md`);
+      const mdPath = path86.join(paths.reposDir, `${slug}.md`);
       if (!await fs36.pathExists(mdPath)) {
         issues.push({
           severity: "high",
@@ -23011,13 +23438,13 @@ async function lintTeamCodebase(opts) {
       }
     }
   }
-  const cacheRoot = path84.join(os6.homedir(), ".teamai", "cache", "repos");
+  const cacheRoot = path86.join(os6.homedir(), ".teamai", "cache", "repos");
   const cacheExists = await fs36.pathExists(cacheRoot);
   for (const mdFile of repoMdFiles) {
-    const mdPath = path84.join(paths.reposDir, mdFile);
+    const mdPath = path86.join(paths.reposDir, mdFile);
     try {
       const content = await fs36.readFile(mdPath, "utf8");
-      const parsed = matter8(content);
+      const parsed = matter9(content);
       const fm = parsed.data;
       issues.push(...checkRepoFrontmatterRequired(fm, `docs/team-codebase/repos/${mdFile}`));
       const source = fm["source"];
@@ -23071,10 +23498,10 @@ async function lintTeamCodebase(opts) {
     }
   }
   for (const domFile of domainMdFiles) {
-    const domPath = path84.join(paths.domainsDir, domFile);
+    const domPath = path86.join(paths.domainsDir, domFile);
     try {
       const content = await fs36.readFile(domPath, "utf8");
-      const parsed = matter8(content);
+      const parsed = matter9(content);
       const fm = parsed.data;
       issues.push(
         ...checkDomainFrontmatterRequired(fm, `docs/team-codebase/domains/${domFile}`)
@@ -23128,7 +23555,7 @@ async function lintTeamCodebase(opts) {
     scanned.indexFile = true;
     try {
       const content = await fs36.readFile(paths.index, "utf8");
-      const parsed = matter8(content);
+      const parsed = matter9(content);
       const fm = parsed.data;
       issues.push(...checkIndexFrontmatterRequired(fm, "docs/team-codebase/index.md"));
       const fmRepoCnt = Number(fm["repo_count"] ?? -1);
@@ -23165,7 +23592,7 @@ async function lintTeamCodebase(opts) {
       });
     }
   }
-  const extKnowledgePath = path84.join(paths.root, "external-knowledge.md");
+  const extKnowledgePath = path86.join(paths.root, "external-knowledge.md");
   if (await fs36.pathExists(extKnowledgePath)) {
     scanned.externalKnowledgeFile = true;
     try {
@@ -23220,7 +23647,7 @@ async function lintTeamCodebase(opts) {
       }
     }
   }
-  const pendingPath = path84.join(opts.cwd, ".teamai", "pending-review.jsonl");
+  const pendingPath = path86.join(opts.cwd, ".teamai", "pending-review.jsonl");
   if (await fs36.pathExists(pendingPath)) {
     try {
       const content = await fs36.readFile(pendingPath, "utf8");
@@ -23238,7 +23665,7 @@ async function lintTeamCodebase(opts) {
     } catch {
     }
   }
-  const sourceMarksPath = path84.join(opts.cwd, ".teamai", "source-marks.jsonl");
+  const sourceMarksPath = path86.join(opts.cwd, ".teamai", "source-marks.jsonl");
   if (await fs36.pathExists(sourceMarksPath)) {
     try {
       const content = await fs36.readFile(sourceMarksPath, "utf8");
@@ -23316,10 +23743,10 @@ async function fixTeamCodebase(opts) {
       continue;
     }
     if (issue.category === "orphan-md") {
-      const mdFile = path84.basename(issue.location);
-      const srcPath = path84.join(paths.reposDir, mdFile);
-      const archivedDir = path84.join(paths.reposDir, ".archived");
-      const dstPath = path84.join(archivedDir, mdFile);
+      const mdFile = path86.basename(issue.location);
+      const srcPath = path86.join(paths.reposDir, mdFile);
+      const archivedDir = path86.join(paths.reposDir, ".archived");
+      const dstPath = path86.join(archivedDir, mdFile);
       if (opts.dryRun) {
         applied.push({
           category: issue.category,
@@ -23345,7 +23772,7 @@ async function fixTeamCodebase(opts) {
       }
     } else if (issue.category === "frontmatter-missing") {
       const relPath = issue.location;
-      const absPath = path84.join(opts.cwd, relPath);
+      const absPath = path86.join(opts.cwd, relPath);
       if (opts.dryRun) {
         applied.push({
           category: issue.category,
@@ -23355,10 +23782,10 @@ async function fixTeamCodebase(opts) {
       } else {
         try {
           const content = await fs36.readFile(absPath, "utf8");
-          const parsed = matter8(content);
+          const parsed = matter9(content);
           if (!parsed.data["schemaVersion"]) {
             parsed.data["schemaVersion"] = 1;
-            const newContent = matter8.stringify(parsed.content, parsed.data);
+            const newContent = matter9.stringify(parsed.content, parsed.data);
             await fs36.writeFile(absPath, newContent, "utf8");
             applied.push({
               category: issue.category,
@@ -23394,14 +23821,14 @@ async function fixTeamCodebase(opts) {
       } else {
         try {
           const indexContent = await fs36.readFile(paths.index, "utf8");
-          const parsed = matter8(indexContent);
+          const parsed = matter9(indexContent);
           const repoFiles = await fs36.readdir(paths.reposDir).catch(() => []);
           const domainFiles = await fs36.readdir(paths.domainsDir).catch(() => []);
           const repoCnt = repoFiles.filter((f) => f.endsWith(".md")).length;
           const domainCnt = domainFiles.filter((f) => f.endsWith(".md")).length;
           parsed.data["repo_count"] = repoCnt;
           parsed.data["domain_count"] = domainCnt;
-          const newContent = matter8.stringify(parsed.content, parsed.data);
+          const newContent = matter9.stringify(parsed.content, parsed.data);
           await fs36.writeFile(paths.index, newContent, "utf8");
           applied.push({
             category: issue.category,
@@ -23444,11 +23871,11 @@ __export(codebase_upgrade_wiki_exports, {
   upgradeCodebaseWiki: () => upgradeCodebaseWiki
 });
 import { readdir as readdir7, readFile as readFile10 } from "fs/promises";
-import path85 from "path";
+import path87 from "path";
 import chalk7 from "chalk";
-import matter9 from "gray-matter";
+import matter10 from "gray-matter";
 async function upgradeCodebaseWiki(opts) {
-  const teamCodebaseDir = path85.join(opts.cwd, "docs", "team-codebase", "repos");
+  const teamCodebaseDir = path87.join(opts.cwd, "docs", "team-codebase", "repos");
   if (!await pathExists(teamCodebaseDir)) {
     if (opts.json) {
       console.log(JSON.stringify({ status: "nothing-to-migrate", reason: "docs/team-codebase/repos/ not found" }));
@@ -23473,10 +23900,10 @@ async function upgradeCodebaseWiki(opts) {
   const result = { migrated: [], skipped: [], errors: [] };
   for (const file of mdFiles) {
     const slug = file.replace(".md", "");
-    const filePath = path85.join(teamCodebaseDir, file);
+    const filePath = path87.join(teamCodebaseDir, file);
     try {
       const content = await readFile10(filePath, "utf-8");
-      const parsed = matter9(content);
+      const parsed = matter10(content);
       const source = parsed.data["source"] ?? parsed.data["repo_url"];
       if (!source) {
         result.skipped.push(`${slug}: \u65E0 source/repo_url \u5B57\u6BB5`);
@@ -23486,9 +23913,9 @@ async function upgradeCodebaseWiki(opts) {
         result.migrated.push(`${slug} \u2192 teamwiki/evidence/code/${slug}/`);
         continue;
       }
-      const cacheBase = path85.join(process.env["HOME"] ?? "", ".teamai", "cache", "repos");
+      const cacheBase = path87.join(process.env["HOME"] ?? "", ".teamai", "cache", "repos");
       const urlParts = String(source).replace(/^https?:\/\//, "").replace(/@.*$/, "").split("/");
-      const cachePath = path85.join(cacheBase, ...urlParts.slice(0, 3));
+      const cachePath = path87.join(cacheBase, ...urlParts.slice(0, 3));
       if (await pathExists(cachePath)) {
         await extractCodebase({ path: cachePath, project: slug });
         result.migrated.push(slug);
@@ -23543,10 +23970,10 @@ __export(codebase_wiki_lint_exports, {
   lintTeamwiki: () => lintTeamwiki
 });
 import { readFile as readFile11, readdir as readdir8, stat as stat5 } from "fs/promises";
-import path86 from "path";
+import path88 from "path";
 import chalk8 from "chalk";
 async function lintTeamwiki(opts) {
-  const wikiRoot = opts.wikiRoot ?? path86.join(opts.cwd ?? process.cwd(), "teamwiki");
+  const wikiRoot = opts.wikiRoot ?? path88.join(opts.cwd ?? process.cwd(), "teamwiki");
   const issues = [];
   const minSeverity = opts.severity ?? "info";
   const severityOrder = ["info", "low", "medium", "high"];
@@ -23556,7 +23983,7 @@ async function lintTeamwiki(opts) {
       issues.push(issue);
     }
   }
-  const graphPath = path86.join(wikiRoot, ".indices", "graph-index.json");
+  const graphPath = path88.join(wikiRoot, ".indices", "graph-index.json");
   let graph = null;
   if (!await pathExists(graphPath)) {
     addIssue({
@@ -23578,7 +24005,7 @@ async function lintTeamwiki(opts) {
       });
     }
   }
-  const evidenceDir = path86.join(wikiRoot, "evidence", "code");
+  const evidenceDir = path88.join(wikiRoot, "evidence", "code");
   if (!await pathExists(evidenceDir)) {
     addIssue({
       severity: "high",
@@ -23597,7 +24024,7 @@ async function lintTeamwiki(opts) {
       });
     }
     for (const project of projects) {
-      const projectDir = path86.join(evidenceDir, project);
+      const projectDir = path88.join(evidenceDir, project);
       const pStat = await stat5(projectDir).catch(() => null);
       if (!pStat?.isDirectory()) {
         if (!pStat) {
@@ -23617,7 +24044,7 @@ async function lintTeamwiki(opts) {
     }
   }
   for (const navFile of ["router.md", "index.md", "hot.md"]) {
-    if (!await pathExists(path86.join(wikiRoot, navFile))) {
+    if (!await pathExists(path88.join(wikiRoot, navFile))) {
       addIssue({
         severity: "low",
         category: "nav-missing",
@@ -23626,7 +24053,7 @@ async function lintTeamwiki(opts) {
       });
     }
   }
-  const manifestPath = path86.join(wikiRoot, "source-manifest.json");
+  const manifestPath = path88.join(wikiRoot, "source-manifest.json");
   if (!await pathExists(manifestPath)) {
     addIssue({
       severity: "low",
@@ -23742,7 +24169,7 @@ var codebase_cmd_exports = {};
 __export(codebase_cmd_exports, {
   codebaseCmd: () => codebaseCmd
 });
-import path87 from "path";
+import path89 from "path";
 import chalk9 from "chalk";
 function formatFixResult(result) {
   const lines = [];
@@ -23801,9 +24228,9 @@ async function codebaseCmd(opts) {
   try {
     const { autoDetectInit: autoDetectInit2 } = await Promise.resolve().then(() => (init_config(), config_exports));
     const { localConfig: lc } = await autoDetectInit2();
-    teamwikiDir = path87.join(lc.repo.localPath, "teamwiki");
+    teamwikiDir = path89.join(lc.repo.localPath, "teamwiki");
   } catch {
-    teamwikiDir = path87.join(cwd, ".teamai", "team-repo", "teamwiki");
+    teamwikiDir = path89.join(cwd, ".teamai", "team-repo", "teamwiki");
   }
   if (await pathExists3(teamwikiDir)) {
     const { lintTeamwiki: lintTeamwiki2, formatWikiLintReport: formatWikiLintReport2 } = await Promise.resolve().then(() => (init_codebase_wiki_lint(), codebase_wiki_lint_exports));
@@ -23940,7 +24367,7 @@ var review_cmd_exports = {};
 __export(review_cmd_exports, {
   reviewCmd: () => reviewCmd
 });
-import path88 from "path";
+import path90 from "path";
 import chalk10 from "chalk";
 import fs37 from "fs-extra";
 function riskAtMost(itemRisk, ceiling) {
@@ -24016,7 +24443,7 @@ async function applyOne(cwd, item) {
   if (!section) {
     return { ok: false, reason: "target.section \u7F3A\u5931" };
   }
-  const filePath = path88.isAbsolute(file) ? file : path88.join(cwd, file);
+  const filePath = path90.isAbsolute(file) ? file : path90.join(cwd, file);
   if (!await fs37.pathExists(filePath)) {
     return { ok: false, reason: `\u76EE\u6807\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${filePath}` };
   }
@@ -24457,9 +24884,93 @@ var init_hook_output = __esm({
   }
 });
 
+// src/transcript-parser.ts
+var transcript_parser_exports = {};
+__export(transcript_parser_exports, {
+  parseTranscriptForVotes: () => parseTranscriptForVotes
+});
+import fs38 from "fs";
+import path91 from "path";
+import readline5 from "readline";
+async function parseTranscriptForVotes(transcriptPath) {
+  const recalledSet = /* @__PURE__ */ new Set();
+  const referencedSet = /* @__PURE__ */ new Set();
+  try {
+    const stat6 = await fs38.promises.stat(transcriptPath);
+    if (stat6.size === 0) return { recalledDocIds: [], referencedDocIds: [] };
+  } catch {
+    return { recalledDocIds: [], referencedDocIds: [] };
+  }
+  const rl = readline5.createInterface({
+    input: fs38.createReadStream(transcriptPath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.includes('"assistant"')) continue;
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (entry["type"] !== "assistant") continue;
+    const message = entry["message"];
+    if (!message || !Array.isArray(message["content"])) continue;
+    for (const block of message["content"]) {
+      if (block["type"] !== "text") continue;
+      const text = block["text"];
+      if (typeof text !== "string") continue;
+      extractRecalledDocIds(text, recalledSet);
+      extractReferencedDocIds(text, referencedSet);
+    }
+  }
+  return {
+    recalledDocIds: [...recalledSet],
+    referencedDocIds: [...referencedSet]
+  };
+}
+function extractRecalledDocIds(text, out) {
+  const START = "--- [teamai:recall:start] ---";
+  const END = "--- [teamai:recall:end] ---";
+  const filePattern = /^File:\s*(.+)$/gm;
+  let searchFrom = 0;
+  while (true) {
+    const startIdx = text.indexOf(START, searchFrom);
+    if (startIdx === -1) break;
+    const endIdx = text.indexOf(END, startIdx + START.length);
+    if (endIdx === -1) break;
+    const region = text.slice(startIdx + START.length, endIdx);
+    filePattern.lastIndex = 0;
+    let match;
+    while ((match = filePattern.exec(region)) !== null) {
+      const filePath = match[1].trim();
+      const docId = path91.basename(filePath).replace(/\.md$/i, "");
+      out.add(docId);
+    }
+    searchFrom = endIdx + END.length;
+  }
+}
+function extractReferencedDocIds(text, out) {
+  const pattern = /<!--\s*teamai:referenced-doc-ids:\s*\[([^\]]*)\]\s*-->/g;
+  let match;
+  while ((match = pattern.exec(text)) !== null) {
+    const raw = match[1];
+    for (const item of raw.split(",")) {
+      const docId = item.trim().replace(/^['"]|['"]$/g, "");
+      if (docId) out.add(docId);
+    }
+  }
+}
+var init_transcript_parser = __esm({
+  "src/transcript-parser.ts"() {
+    "use strict";
+  }
+});
+
 // src/machine-id.ts
 import crypto4 from "crypto";
-import fs38 from "fs";
+import fs39 from "fs";
 import { execFileSync as execFileSync4 } from "child_process";
 function getMachineId() {
   if (cachedMachineId !== null) return cachedMachineId;
@@ -24500,7 +25011,7 @@ function readWindowsMachineId() {
 function readLinuxMachineId() {
   for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
     try {
-      const content = fs38.readFileSync(p, "utf-8").trim();
+      const content = fs39.readFileSync(p, "utf-8").trim();
       if (content) return content;
     } catch {
     }
@@ -24525,7 +25036,7 @@ var init_machine_id = __esm({
 // src/agent-version.ts
 import { execFile as execFile2 } from "child_process";
 import { readFile as readFile12 } from "fs/promises";
-import path89 from "path";
+import path92 from "path";
 async function execVersion(bin, args = ["--version"]) {
   return new Promise((resolve) => {
     execFile2(bin, args, { timeout: 5e3 }, (err, stdout) => {
@@ -24538,7 +25049,7 @@ async function execVersion(bin, args = ["--version"]) {
   });
 }
 async function readPlistVersion(appPath) {
-  const plistPath = path89.join(appPath, "Contents", "Info.plist");
+  const plistPath = path92.join(appPath, "Contents", "Info.plist");
   try {
     const content = await readFile12(plistPath, "utf-8");
     const match = content.match(
@@ -24622,7 +25133,7 @@ __export(status_report_exports, {
   scanReportableSkills: () => scanReportableSkills
 });
 import os7 from "os";
-import path90 from "path";
+import path93 from "path";
 import YAML17 from "yaml";
 function resolveEndpoints() {
   const raw = process.env.TEAMAI_REPORT_PATHS;
@@ -24668,7 +25179,7 @@ async function scanReportableSkills(skillsDir) {
   const dirs = (await listDirs(skillsDir)).filter((slug) => !slug.startsWith("."));
   const skills = await Promise.all(
     dirs.map(async (slug) => {
-      const skillMd = path90.join(skillsDir, slug, "SKILL.md");
+      const skillMd = path93.join(skillsDir, slug, "SKILL.md");
       if (!await pathExists(skillMd)) return null;
       const meta = await readSkillMeta(skillMd);
       return { slug, version: meta.version, display_name: meta.name || slug };
@@ -24677,11 +25188,11 @@ async function scanReportableSkills(skillsDir) {
   return skills.filter((s) => s !== null).sort((a, b) => a.slug.localeCompare(b.slug));
 }
 function queuePath() {
-  return path90.join(process.env.HOME ?? "", ".teamai", "reporter", "queue.jsonl");
+  return path93.join(process.env.HOME ?? "", ".teamai", "reporter", "queue.jsonl");
 }
 async function enqueue(req) {
   const p = queuePath();
-  await ensureDir(path90.dirname(p));
+  await ensureDir(path93.dirname(p));
   const fse9 = await import("fs-extra");
   await fse9.default.appendFile(p, JSON.stringify(req) + "\n", "utf-8");
 }
@@ -24755,8 +25266,8 @@ async function runStatusReportInner(opts) {
     return;
   }
   const baseDir = resolveBaseDir(localConfig);
-  const skillsDir = path90.join(baseDir, skillsRel);
-  const installPath = path90.join(baseDir, path90.dirname(skillsRel));
+  const skillsDir = path93.join(baseDir, skillsRel);
+  const installPath = path93.join(baseDir, path93.dirname(skillsRel));
   const machineId = getMachineId();
   const localAgentId = deriveLocalAgentId(agentType, machineId, installPath);
   const endpoints = resolveEndpoints();
@@ -24863,6 +25374,7 @@ var init_status_report = __esm({
 });
 
 // src/hook-handlers.ts
+import path94 from "path";
 function buildHandlerRegistry() {
   return [
     // ─── SessionStart ─────────────────────────────────
@@ -24873,6 +25385,7 @@ function buildHandlerRegistry() {
     // ─── Stop ─────────────────────────────────────────
     { event: "stop", matcher: "*", handler: updateHandler, timeoutMs: UPDATE_TIMEOUT_MS },
     { event: "stop", matcher: "*", handler: contributeCheckHandler, timeoutMs: CONTRIBUTE_CHECK_TIMEOUT_MS },
+    { event: "stop", matcher: "*", handler: votesSyncHandler, timeoutMs: VOTES_SYNC_TIMEOUT_MS },
     { event: "stop", matcher: "*", handler: dashboardReportHandler, timeoutMs: DASHBOARD_TIMEOUT_MS },
     // ─── PostToolUse ──────────────────────────────────
     { event: "post-tool-use", matcher: "*", handler: dashboardReportHandler, timeoutMs: DASHBOARD_TIMEOUT_MS },
@@ -24884,7 +25397,7 @@ function buildHandlerRegistry() {
     { event: "prompt-submit", matcher: "*", handler: statusReportMessageHandler, timeoutMs: STATUS_REPORT_TIMEOUT_MS }
   ];
 }
-var PULL_TIMEOUT_MS, UPDATE_TIMEOUT_MS, TRACK_TIMEOUT_MS, DASHBOARD_TIMEOUT_MS, CONTRIBUTE_CHECK_TIMEOUT_MS, TODOWRITE_HINT_TIMEOUT_MS, MR_HINT_TIMEOUT_MS, STATUS_REPORT_TIMEOUT_MS, pullHandler, updateHandler, dashboardReportHandler, trackHandler, trackSlashHandler, contributeCheckHandler, todowriteHintHandler, mrHintHandler, statusReportSessionHandler, statusReportMessageHandler;
+var PULL_TIMEOUT_MS, UPDATE_TIMEOUT_MS, TRACK_TIMEOUT_MS, DASHBOARD_TIMEOUT_MS, CONTRIBUTE_CHECK_TIMEOUT_MS, VOTES_SYNC_TIMEOUT_MS, TODOWRITE_HINT_TIMEOUT_MS, MR_HINT_TIMEOUT_MS, STATUS_REPORT_TIMEOUT_MS, pullHandler, updateHandler, dashboardReportHandler, trackHandler, trackSlashHandler, contributeCheckHandler, votesSyncHandler, todowriteHintHandler, mrHintHandler, statusReportSessionHandler, statusReportMessageHandler;
 var init_hook_handlers = __esm({
   "src/hook-handlers.ts"() {
     "use strict";
@@ -24895,6 +25408,7 @@ var init_hook_handlers = __esm({
     TRACK_TIMEOUT_MS = 5e3;
     DASHBOARD_TIMEOUT_MS = 5e3;
     CONTRIBUTE_CHECK_TIMEOUT_MS = 1e4;
+    VOTES_SYNC_TIMEOUT_MS = 8e3;
     TODOWRITE_HINT_TIMEOUT_MS = 5e3;
     MR_HINT_TIMEOUT_MS = 1e4;
     STATUS_REPORT_TIMEOUT_MS = 3e4;
@@ -24987,6 +25501,31 @@ var init_hook_handlers = __esm({
         return null;
       }
     };
+    votesSyncHandler = {
+      name: "votes-sync",
+      async execute(stdin) {
+        if (process.env.TEAMAI_RECALL_DISABLED === "1") return null;
+        const transcriptPath = typeof stdin.transcript_path === "string" ? stdin.transcript_path : null;
+        if (!transcriptPath) return null;
+        try {
+          const { parseTranscriptForVotes: parseTranscriptForVotes2 } = await Promise.resolve().then(() => (init_transcript_parser(), transcript_parser_exports));
+          const { incrementUpvoted: incrementUpvoted2, syncVotesToTeam: syncVotesToTeam2 } = await Promise.resolve().then(() => (init_votes(), votes_exports));
+          const { requireInit: requireInit3 } = await Promise.resolve().then(() => (init_config(), config_exports));
+          const voteData = await parseTranscriptForVotes2(transcriptPath);
+          const { localConfig } = await requireInit3();
+          const { VOTES_LOCAL_DIR: VOTES_LOCAL_DIR2 } = await Promise.resolve().then(() => (init_types(), types_exports));
+          const votesDir = VOTES_LOCAL_DIR2;
+          const votePath = path94.join(votesDir, `${localConfig.username}.yaml`);
+          if (voteData.referencedDocIds.length > 0) {
+            await incrementUpvoted2(votePath, voteData.referencedDocIds);
+          }
+          await syncVotesToTeam2(localConfig.repo.localPath, localConfig.username, votesDir).catch(() => {
+          });
+        } catch {
+        }
+        return null;
+      }
+    };
     todowriteHintHandler = {
       name: "todowrite-hint",
       async execute(stdin, _tool) {
@@ -25113,10 +25652,10 @@ function formatComment(learning, suggestions, marker) {
   lines.push("> _Auto-generated by `teamai ci extract-mr`_");
   return lines.join("\n");
 }
-async function githubRequest(path92, method, body) {
+async function githubRequest(path99, method, body) {
   const token = process.env["GITHUB_TOKEN"];
   if (!token) throw new Error("\u672A\u8BBE\u7F6E GITHUB_TOKEN \u73AF\u5883\u53D8\u91CF");
-  const url = `https://api.github.com${path92}`;
+  const url = `https://api.github.com${path99}`;
   const headers = {
     Authorization: `Bearer ${token}`,
     Accept: "application/vnd.github+json",
@@ -25172,9 +25711,9 @@ function getTGitToken() {
   if (oauthToken) return oauthToken;
   throw new Error("\u672A\u8BBE\u7F6E TAI_PAT_TOKEN \u73AF\u5883\u53D8\u91CF\uFF0C\u4E14\u65E0\u6CD5\u4ECE gf credential \u83B7\u53D6 token");
 }
-async function tgitRequest(path92, method, body) {
+async function tgitRequest(path99, method, body) {
   const token = getTGitToken();
-  const url = `https://git.woa.com/api/v3${path92}`;
+  const url = `https://git.woa.com/api/v3${path99}`;
   const headers = {
     Authorization: `Bearer ${token}`,
     "Content-Type": "application/json"
@@ -25464,10 +26003,10 @@ function extractMarkerId(body) {
   const match = body.match(MARKER_REGEX);
   return match ? match[1] : null;
 }
-async function githubRequest2(path92) {
+async function githubRequest2(path99) {
   const token = process.env["GITHUB_TOKEN"];
   if (!token) throw new Error("\u672A\u8BBE\u7F6E GITHUB_TOKEN");
-  return fetch(`https://api.github.com${path92}`, {
+  return fetch(`https://api.github.com${path99}`, {
     headers: {
       Authorization: `Bearer ${token}`,
       Accept: "application/vnd.github+json",
@@ -25509,9 +26048,9 @@ function getTGitToken2() {
   if (oauthToken) return oauthToken;
   throw new Error("\u672A\u8BBE\u7F6E TAI_PAT_TOKEN \u4E14\u65E0\u6CD5\u83B7\u53D6 OAuth token");
 }
-async function tgitRequest2(path92) {
+async function tgitRequest2(path99) {
   const token = getTGitToken2();
-  return fetch(`https://git.woa.com/api/v3${path92}`, {
+  return fetch(`https://git.woa.com/api/v3${path99}`, {
     headers: {
       Authorization: `Bearer ${token}`,
       "Content-Type": "application/json"
@@ -25577,8 +26116,8 @@ var extract_mr_exports = {};
 __export(extract_mr_exports, {
   ciExtractMr: () => ciExtractMr
 });
-import fs39 from "fs/promises";
-import path91 from "path";
+import fs40 from "fs/promises";
+import path95 from "path";
 async function configureGitUser2(repoPath, provider) {
   const { execFileSync: execFileSync5 } = await import("child_process");
   let name = "teamai-ci";
@@ -25631,11 +26170,11 @@ async function writeKnowledgeToRepo(teamRepo, learning, suggestions, writeMode,
     const safeTitle = learning.title.replace(/[^a-zA-Z0-9一-鿿_-]/g, "-").replace(/-+/g, "-").slice(0, 50);
     const dateStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const filename = `${dateStr}-${safeTitle}.md`;
-    const learningsDir = path91.join(teamRepo, "learnings");
-    const learningPath = path91.join(learningsDir, filename);
+    const learningsDir = path95.join(teamRepo, "learnings");
+    const learningPath = path95.join(learningsDir, filename);
     if (!dryRun) {
-      await fs39.mkdir(learningsDir, { recursive: true });
-      await fs39.writeFile(learningPath, learning.content, "utf-8");
+      await fs40.mkdir(learningsDir, { recursive: true });
+      await fs40.writeFile(learningPath, learning.content, "utf-8");
     }
     log.success(`Learning \u5199\u5165: learnings/${filename}`);
     changedFiles.push(`learnings/${filename}`);
@@ -25670,13 +26209,13 @@ async function writeKnowledgeToRepo(teamRepo, learning, suggestions, writeMode,
   }
 }
 async function writeArtifacts(outputDir, learning, suggestions) {
-  await fs39.mkdir(outputDir, { recursive: true });
+  await fs40.mkdir(outputDir, { recursive: true });
   if (learning) {
-    await fs39.writeFile(path91.join(outputDir, "learning.md"), learning.content, "utf-8");
+    await fs40.writeFile(path95.join(outputDir, "learning.md"), learning.content, "utf-8");
   }
   if (suggestions && suggestions.length > 0) {
-    await fs39.writeFile(
-      path91.join(outputDir, "codebase-suggestions.json"),
+    await fs40.writeFile(
+      path95.join(outputDir, "codebase-suggestions.json"),
       JSON.stringify(suggestions, null, 2),
       "utf-8"
     );
@@ -25690,7 +26229,7 @@ async function ciExtractMr(opts) {
   const result = await importFromMR({
     url: opts.url,
     all: true,
-    learningsDir: opts.teamRepo ? path91.join(opts.teamRepo, "learnings") : void 0,
+    learningsDir: opts.teamRepo ? path95.join(opts.teamRepo, "learnings") : void 0,
     dryRun: true
     // 不让 importFromMR 自己写文件，我们自己控制写入
   });
@@ -25799,21 +26338,21 @@ ${affectedModules.map((m) => `- \`${m}\` (evidence + G-document)`).join("\n")}`
           const projectName = parsed.repo;
           await extractCodebase2({ path: businessRepo, project: projectName });
           const fse9 = await import("fs-extra");
-          const srcWiki = path91.join(businessRepo, "teamwiki");
-          const teamWikiRoot = path91.join(path91.resolve(opts.teamRepo), "teamwiki");
+          const srcWiki = path95.join(businessRepo, "teamwiki");
+          const teamWikiRoot = path95.join(path95.resolve(opts.teamRepo), "teamwiki");
           try {
             if (await fse9.pathExists(srcWiki)) {
-              const evidenceSrc = path91.join(srcWiki, "evidence", "code", projectName);
-              const evidenceDest = path91.join(teamWikiRoot, "evidence", "code", projectName);
+              const evidenceSrc = path95.join(srcWiki, "evidence", "code", projectName);
+              const evidenceDest = path95.join(teamWikiRoot, "evidence", "code", projectName);
               if (await fse9.pathExists(evidenceSrc)) {
                 await fse9.ensureDir(evidenceDest);
                 await fse9.copy(evidenceSrc, evidenceDest, { overwrite: true });
               }
-              const srcGraph = path91.join(srcWiki, ".indices", "graph-index.json");
+              const srcGraph = path95.join(srcWiki, ".indices", "graph-index.json");
               if (await fse9.pathExists(srcGraph)) {
-                const destGraphDir = path91.join(evidenceDest, ".indices");
+                const destGraphDir = path95.join(evidenceDest, ".indices");
                 await fse9.ensureDir(destGraphDir);
-                await fse9.copy(srcGraph, path91.join(destGraphDir, "graph-index.json"));
+                await fse9.copy(srcGraph, path95.join(destGraphDir, "graph-index.json"));
               }
               const { aggregateGlobalGraph: aggregateGlobalGraph2 } = await Promise.resolve().then(() => (init_graph_aggregate(), graph_aggregate_exports));
               await aggregateGlobalGraph2(teamWikiRoot);
@@ -25868,6 +26407,440 @@ var init_extract_mr = __esm({
   }
 });
 
+// src/maintenance/prune.ts
+import path96 from "path";
+import matter11 from "gray-matter";
+async function findPruneCandidates(learningsDir, votesDir, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  const confidenceMap = await computeAllConfidence(votesDir);
+  const candidates = [];
+  const files = await listFiles(learningsDir);
+  const now = Date.now();
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const docId = file.replace(/\.md$/i, "");
+    const absPath = path96.join(learningsDir, file);
+    const content = await readFileSafe(absPath);
+    if (!content) continue;
+    let date = "";
+    try {
+      const { data } = matter11(content);
+      date = typeof data.date === "string" ? data.date : "";
+    } catch {
+      continue;
+    }
+    const confidence = confidenceMap.get(docId);
+    if (confidence === void 0) continue;
+    const daysSinceCreate = date ? (now - new Date(date).getTime()) / (1e3 * 60 * 60 * 24) : Infinity;
+    if (confidence < threshold) {
+      candidates.push({
+        filename: file,
+        path: absPath,
+        confidence,
+        lastActivity: date,
+        reason: `confidence ${confidence.toFixed(2)} < ${threshold}`
+      });
+    } else if (daysSinceCreate > STALE_DAYS && confidence < 0.3) {
+      candidates.push({
+        filename: file,
+        path: absPath,
+        confidence,
+        lastActivity: date,
+        reason: `inactive ${isFinite(daysSinceCreate) ? Math.round(daysSinceCreate) + "d" : "no-date"}, confidence ${confidence.toFixed(2)}`
+      });
+    }
+  }
+  return candidates.sort((a, b) => a.confidence - b.confidence);
+}
+async function executePrune(repoPath, candidates, options = {}) {
+  let archived = 0;
+  let removed = 0;
+  if (options.dryRun) {
+    log.info(`[dry-run] Would ${options.archive ? "archive" : "remove"} ${candidates.length} file(s)`);
+    return { archived: 0, removed: 0 };
+  }
+  for (const candidate of candidates) {
+    if (options.archive) {
+      const archiveDir = path96.join(repoPath, "learnings", "_archive");
+      await ensureDir(archiveDir);
+      await copyFile(candidate.path, path96.join(archiveDir, candidate.filename));
+      await remove(candidate.path);
+      archived++;
+    } else {
+      await remove(candidate.path);
+      removed++;
+    }
+  }
+  if (archived > 0) log.success(`Archived ${archived} learning(s)`);
+  if (removed > 0) log.success(`Removed ${removed} learning(s)`);
+  return { archived, removed };
+}
+var DEFAULT_THRESHOLD, STALE_DAYS;
+var init_prune = __esm({
+  "src/maintenance/prune.ts"() {
+    "use strict";
+    init_fs();
+    init_logger();
+    init_confidence();
+    DEFAULT_THRESHOLD = 0.15;
+    STALE_DAYS = 180;
+  }
+});
+
+// src/maintenance/quality-update.ts
+import path97 from "path";
+async function findStaleEntries(votesDir, knowledgeDirs, options = {}) {
+  const minRecalled = options.minRecalled ?? DEFAULT_MIN_RECALLED;
+  const maxUpvoted = options.maxUpvoted ?? DEFAULT_MAX_UPVOTED;
+  const minUsers = options.minUsers ?? DEFAULT_MIN_USERS;
+  const perDoc = /* @__PURE__ */ new Map();
+  const voteFiles = await listFiles(votesDir);
+  for (const file of voteFiles) {
+    if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
+    const username = file.replace(/\.(yaml|yml)$/, "");
+    const filePath = path97.join(votesDir, file);
+    try {
+      const data = await loadUserVotes(filePath);
+      for (const [docId, entry] of Object.entries(data.votes)) {
+        const existing = perDoc.get(docId) ?? { recalled: 0, upvoted: 0, users: /* @__PURE__ */ new Set() };
+        existing.recalled += entry.recalled_count ?? 0;
+        existing.upvoted += entry.upvoted_count ?? 0;
+        if ((entry.recalled_count ?? 0) > 0) existing.users.add(username);
+        perDoc.set(docId, existing);
+      }
+    } catch {
+      continue;
+    }
+  }
+  const candidates = [];
+  for (const [docId, data] of perDoc) {
+    if (data.recalled < minRecalled) continue;
+    if (data.upvoted > maxUpvoted) continue;
+    if (data.users.size < minUsers) continue;
+    const entryPath = await resolveDocPath(docId, knowledgeDirs);
+    if (!entryPath) continue;
+    const type = entryPath.includes("/docs/") ? "docs" : entryPath.includes("/rules/") ? "rules" : entryPath.includes("/skills/") ? "skills" : "unknown";
+    candidates.push({
+      docId,
+      path: entryPath,
+      recalledCount: data.recalled,
+      upvotedCount: data.upvoted,
+      userCount: data.users.size,
+      type
+    });
+  }
+  return candidates.sort((a, b) => b.recalledCount - a.recalledCount);
+}
+async function resolveDocPath(docId, dirs) {
+  const filename = docId.endsWith(".md") ? docId : `${docId}.md`;
+  for (const dir of [dirs.docs, dirs.rules, dirs.skills]) {
+    if (!dir) continue;
+    const candidate = path97.join(dir, filename);
+    if (await pathExists(candidate)) return candidate;
+  }
+  return null;
+}
+function reportStaleEntries(entries) {
+  if (entries.length === 0) {
+    log.info("No stale entries found that need quality updates.");
+    return;
+  }
+  log.info(`Found ${entries.length} entry(ies) recalled often but rarely adopted:`);
+  for (const entry of entries) {
+    log.info(
+      `  - [${entry.type}] ${entry.docId}: recalled ${entry.recalledCount}x by ${entry.userCount} users, adopted ${entry.upvotedCount}x`
+    );
+  }
+}
+async function findRelatedAdoptedLearnings(staleEntry, votesDir, learningsDir, limit = 5) {
+  const perDoc = /* @__PURE__ */ new Map();
+  const voteFiles = await listFiles(votesDir);
+  for (const file of voteFiles) {
+    if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
+    try {
+      const data = await loadUserVotes(path97.join(votesDir, file));
+      for (const [docId, entry] of Object.entries(data.votes)) {
+        if (docId === staleEntry.docId) continue;
+        if ((entry.upvoted_count ?? 0) > 0) {
+          perDoc.set(docId, (perDoc.get(docId) ?? 0) + (entry.upvoted_count ?? 0));
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  const sorted = [...perDoc.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit);
+  const contents = [];
+  for (const [docId] of sorted) {
+    const filename = docId.endsWith(".md") ? docId : `${docId}.md`;
+    const filePath = path97.join(learningsDir, filename);
+    const content = await readFileSafe(filePath);
+    if (content) contents.push(content);
+  }
+  return contents;
+}
+async function generateUpdateDraft(staleEntry, relatedLearnings) {
+  const currentContent = await readFileSafe(staleEntry.path);
+  if (!currentContent) return null;
+  const { callClaude: callClaude2 } = await Promise.resolve().then(() => (init_ai_client(), ai_client_exports));
+  const learningContext = relatedLearnings.length > 0 ? `
+
+The following learnings were actually adopted by team members (these represent what the team found more useful):
+
+${relatedLearnings.map((l, i) => `--- Learning ${i + 1} ---
+${l}`).join("\n\n")}` : "";
+  const prompt = `You are a technical writer updating a team knowledge base entry.
+
+The following ${staleEntry.type} entry has been recalled ${staleEntry.recalledCount} times by ${staleEntry.userCount} team members but was adopted only ${staleEntry.upvotedCount} time(s). This indicates the content is relevant to common queries but not actionable enough to be directly useful.
+
+Current content:
+---
+${currentContent}
+---
+${learningContext}
+
+Please rewrite this entry to be more actionable and directly useful. Keep the same topic but:
+1. Add concrete examples or commands where applicable
+2. Remove outdated or vague information
+3. Incorporate relevant insights from the adopted learnings above
+4. Keep the same YAML frontmatter format (update the date field to today)
+5. Be concise \u2014 aim for the same or shorter length
+
+Output ONLY the updated markdown file content (including frontmatter).`;
+  try {
+    const draft = await callClaude2(prompt);
+    return draft.trim();
+  } catch (e) {
+    log.error(`AI update generation failed: ${e.message}`);
+    return null;
+  }
+}
+var DEFAULT_MIN_RECALLED, DEFAULT_MAX_UPVOTED, DEFAULT_MIN_USERS;
+var init_quality_update = __esm({
+  "src/maintenance/quality-update.ts"() {
+    "use strict";
+    init_fs();
+    init_votes();
+    init_logger();
+    DEFAULT_MIN_RECALLED = 5;
+    DEFAULT_MAX_UPVOTED = 1;
+    DEFAULT_MIN_USERS = 2;
+  }
+});
+
+// src/maintenance/promote.ts
+import path98 from "path";
+import matter12 from "gray-matter";
+async function findPromotionCandidates(learningsDir, votesDir) {
+  const confidenceMap = await computeAllConfidence(votesDir);
+  const candidates = [];
+  const perDoc = await aggregatePerDocVotes(votesDir);
+  const files = await listFiles(learningsDir);
+  const now = Date.now();
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const docId = file.replace(/\.md$/i, "");
+    const confidence = confidenceMap.get(docId) ?? 0;
+    if (confidence < MIN_CONFIDENCE) continue;
+    const docVotes = perDoc.get(docId);
+    if (!docVotes) continue;
+    if (docVotes.upvoted < MIN_UPVOTED) continue;
+    if (docVotes.users.size < MIN_USERS) continue;
+    const absPath = path98.join(learningsDir, file);
+    const content = await readFileSafe(absPath);
+    if (!content) continue;
+    let title = docId;
+    let date = "";
+    try {
+      const { data } = matter12(content);
+      title = typeof data.title === "string" ? data.title : docId;
+      date = typeof data.date === "string" ? data.date : "";
+      if (data.promoted_to) continue;
+    } catch {
+      continue;
+    }
+    if (date) {
+      const ageInDays = (now - new Date(date).getTime()) / (1e3 * 60 * 60 * 24);
+      if (ageInDays < MIN_AGE_DAYS) continue;
+    }
+    const suggestedCategory = await inferCategory(content, title);
+    candidates.push({
+      docId,
+      filename: file,
+      path: absPath,
+      confidence,
+      upvotedCount: docVotes.upvoted,
+      userCount: docVotes.users.size,
+      title,
+      suggestedCategory
+    });
+  }
+  return candidates.sort((a, b) => b.confidence - a.confidence);
+}
+async function generatePromotedContent(originalContent, category, title) {
+  const categoryGuide = {
+    skills: `a reusable skill/SOP. Format it with:
+- A clear "when to use" trigger description
+- Step-by-step numbered procedure
+- Expected outcome
+- Common pitfalls to avoid
+Remove any references to specific dates, people, or one-off incidents. Make it timeless and reusable.`,
+    rules: `a team rule/constraint. Format it with:
+- A one-line rule statement (imperative: "Always X" / "Never Y")
+- Rationale: why this matters (1-2 sentences)
+- Examples of correct and incorrect usage
+Remove anecdotal context. State the constraint as an absolute standard.`,
+    docs: `a reference document. Format it with:
+- Context: what system/component this describes
+- Key concepts and their relationships
+- Architecture decisions and their rationale
+- Current state (as of promotion date)
+Remove personal narrative. Write as objective technical documentation.`
+  };
+  try {
+    const { callClaude: callClaude2 } = await Promise.resolve().then(() => (init_ai_client(), ai_client_exports));
+    const prompt = `You are a technical knowledge engineer promoting a team learning into formal knowledge.
+
+The following "learning" has been repeatedly validated by the team (high confidence, adopted by multiple members). Transform it into ${categoryGuide[category]}
+
+Original learning (title: "${title}"):
+---
+${originalContent}
+---
+
+Output ONLY the transformed markdown content (including YAML frontmatter with title, tags, date set to today). Do NOT include the original learning's confidence or vote-related fields in the frontmatter.`;
+    const result = await callClaude2(prompt, { timeout: 6e4 });
+    return result.trim();
+  } catch (e) {
+    log.warn(`AI content generation failed, using original content: ${e.message}`);
+    return originalContent;
+  }
+}
+async function executePromotion(candidate, repoPath, options = {}) {
+  const category = options.category ?? candidate.suggestedCategory;
+  const targetDir = path98.join(repoPath, category);
+  await ensureDir(targetDir);
+  const targetPath = path98.join(targetDir, candidate.filename);
+  if (options.dryRun) {
+    log.info(`[dry-run] Would promote ${candidate.docId} -> ${category}/${candidate.filename}`);
+    return targetPath;
+  }
+  const originalContent = await readFileSafe(candidate.path);
+  if (!originalContent) {
+    log.error(`Cannot read source file: ${candidate.path}`);
+    return targetPath;
+  }
+  const promotedContent = await generatePromotedContent(originalContent, category, candidate.title);
+  await writeFile(targetPath, promotedContent);
+  const { data, content: body } = matter12(originalContent);
+  data.promoted_to = `${category}/${candidate.filename}`;
+  const updated = matter12.stringify(body, data);
+  await writeFile(candidate.path, updated);
+  log.success(`Promoted: ${candidate.docId} -> ${category}/${candidate.filename}`);
+  return targetPath;
+}
+function inferCategoryByKeywords(content, title) {
+  const lower = (content + " " + title).toLowerCase();
+  const skillSignals = ["command", "cli", "workflow", "step-by-step", "procedure", "how to", "recipe"];
+  const ruleSignals = ["must", "never", "always", "constraint", "convention", "standard", "rule"];
+  const docSignals = ["architecture", "design", "overview", "background", "decision", "context"];
+  const skillScore = skillSignals.filter((s) => lower.includes(s)).length;
+  const ruleScore = ruleSignals.filter((s) => lower.includes(s)).length;
+  const docScore = docSignals.filter((s) => lower.includes(s)).length;
+  if (ruleScore >= skillScore && ruleScore >= docScore) return "rules";
+  if (skillScore >= docScore) return "skills";
+  return "docs";
+}
+async function inferCategory(content, title) {
+  try {
+    const { callClaude: callClaude2 } = await Promise.resolve().then(() => (init_ai_client(), ai_client_exports));
+    const prompt = `Classify the following team knowledge entry into exactly ONE category. Reply with ONLY the category name (no explanation):
+
+- "skills" \u2014 reusable workflows, SOPs, step-by-step procedures, CLI recipes, operational playbooks
+- "rules" \u2014 mandatory constraints, coding standards, conventions, best practices that MUST be followed
+- "docs" \u2014 architecture decisions, system design, background context, reference documentation
+
+Title: ${title}
+
+Content:
+${content.slice(0, 2e3)}
+
+Category:`;
+    const result = await callClaude2(prompt, { timeout: 3e4 });
+    const category = result.trim().toLowerCase().replace(/[^a-z]/g, "");
+    if (category === "skills" || category === "rules" || category === "docs") {
+      return category;
+    }
+  } catch {
+  }
+  return inferCategoryByKeywords(content, title);
+}
+async function aggregatePerDocVotes(votesDir) {
+  const perDoc = /* @__PURE__ */ new Map();
+  const { loadUserVotes: loadUserVotes2 } = await Promise.resolve().then(() => (init_votes(), votes_exports));
+  const voteFiles = await listFiles(votesDir);
+  for (const file of voteFiles) {
+    if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
+    const username = file.replace(/\.(yaml|yml)$/, "");
+    const filePath = path98.join(votesDir, file);
+    try {
+      const data = await loadUserVotes2(filePath);
+      for (const [docId, entry] of Object.entries(data.votes)) {
+        const existing = perDoc.get(docId) ?? { recalled: 0, upvoted: 0, users: /* @__PURE__ */ new Set() };
+        existing.recalled += entry.recalled_count ?? 0;
+        existing.upvoted += entry.upvoted_count ?? 0;
+        if ((entry.upvoted_count ?? 0) > 0) existing.users.add(username);
+        perDoc.set(docId, existing);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return perDoc;
+}
+var MIN_CONFIDENCE, MIN_UPVOTED, MIN_USERS, MIN_AGE_DAYS;
+var init_promote = __esm({
+  "src/maintenance/promote.ts"() {
+    "use strict";
+    init_fs();
+    init_logger();
+    init_confidence();
+    MIN_CONFIDENCE = 0.9;
+    MIN_UPVOTED = 5;
+    MIN_USERS = 2;
+    MIN_AGE_DAYS = 14;
+  }
+});
+
+// src/maintenance/index.ts
+var maintenance_exports = {};
+__export(maintenance_exports, {
+  COLD_PENALTY: () => COLD_PENALTY,
+  HOT_THRESHOLD: () => HOT_THRESHOLD,
+  annotateHotness: () => annotateHotness,
+  computeAllConfidence: () => computeAllConfidence,
+  computeConfidence: () => computeConfidence,
+  executePromotion: () => executePromotion,
+  executePrune: () => executePrune,
+  findPromotionCandidates: () => findPromotionCandidates,
+  findPruneCandidates: () => findPruneCandidates,
+  findRelatedAdoptedLearnings: () => findRelatedAdoptedLearnings,
+  findStaleEntries: () => findStaleEntries,
+  generateUpdateDraft: () => generateUpdateDraft,
+  reportStaleEntries: () => reportStaleEntries,
+  writeBackConfidence: () => writeBackConfidence
+});
+var init_maintenance = __esm({
+  "src/maintenance/index.ts"() {
+    "use strict";
+    init_confidence();
+    init_prune();
+    init_hot_cold();
+    init_quality_update();
+    init_promote();
+  }
+});
+
 // src/index.ts
 init_logger();
 import { createRequire as createRequire2 } from "module";
@@ -25879,7 +26852,7 @@ program.name("teamai").description("TeamAI \u2014 The team harness for AI agents
   const opts = thisCommand.opts();
   if (opts.verbose) setVerbose(true);
 });
-program.command("init").description("Initialize teamai (configure TGit, clone repo, register member)").option("--repo <repo>", "Team repo (owner/repo or full URL)").option("--http <url>", "Git-free HTTP team repo (read-only consumer; only needs an API key)").option("--token <key>", "API key for HTTP team repo / status reporting (stored 0600, never committed). Also reads TEAMAI_API_TOKEN.").option("--scope <scope>", "Scope: user (default) or project").option("--role <id>", "Primary role ID (e.g. hai_dev) for non-interactive setup").option("--force", "Overwrite existing config without confirmation").action(async (cmdOpts) => {
+program.command("init").description("Initialize teamai (configure TGit, clone repo, register member)").option("--repo <repo>", "Team repo (owner/repo or full URL)").option("--http <url>", "Git-free HTTP team repo (read-only consumer; only needs an API key)").option("--token <key>", "API key for HTTP team repo / status reporting (stored 0600, never committed). Also reads TEAMAI_API_TOKEN.").option("--scope <scope>", "Scope: user (default) or project").option("--role <id>", "Primary role ID (e.g. hai_dev) for non-interactive setup").option("--agent <name>", "Only inject hooks into this agent (e.g. claude, codebuddy, workbuddy). Additive on repeated runs.").option("--force", "Overwrite existing config without confirmation").action(async (cmdOpts) => {
   const globalOpts = program.opts();
   const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
   await init2({ ...globalOpts, ...cmdOpts });
@@ -26220,5 +27193,100 @@ program.command("deep-enrich", { hidden: true }).description("Run deep AI knowle
   const { deepEnrich: deepEnrich2 } = await Promise.resolve().then(() => (init_deep_enrich(), deep_enrich_exports));
   await deepEnrich2({ project: cmdOpts.project, evidenceDir, wikiRoot, maxModules: cmdOpts.maxModules });
 });
+recallCmd.command("feedback").description("Record manual feedback for a recalled document").option("--positive <docId>", "Upvote a document (marks as actually useful)").option("--negative <docId>", "Record negative signal for a document").action(async (cmdOpts) => {
+  const { recallFeedback: recallFeedback2 } = await Promise.resolve().then(() => (init_votes(), votes_exports));
+  await recallFeedback2({ positive: cmdOpts.positive, negative: cmdOpts.negative });
+});
+recallCmd.command("maintenance").description("Automatic maintenance of team knowledge base").option("--prune", "Remove low-confidence learnings").option("--threshold <n>", "Confidence threshold for pruning (default 0.15)", parseFloat).option("--archive", "Move to archive/ instead of deleting").option("--confidence-writeback", "Update frontmatter confidence scores").option("--update-quality", "Find stale docs/rules/skills and suggest updates").option("--dry-run", "Show what would be done without making changes").action(async (cmdOpts) => {
+  const { requireInit: requireInit3 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { localConfig } = await requireInit3();
+  const repoPath = localConfig.repo.localPath;
+  const votesDir = `${repoPath}/votes`;
+  const learningsDir = `${repoPath}/learnings`;
+  if (cmdOpts.confidenceWriteback) {
+    const { computeAllConfidence: computeAllConfidence2, writeBackConfidence: writeBackConfidence2 } = await Promise.resolve().then(() => (init_maintenance(), maintenance_exports));
+    const map = await computeAllConfidence2(votesDir);
+    await writeBackConfidence2(learningsDir, map);
+    return;
+  }
+  if (cmdOpts.prune) {
+    const { findPruneCandidates: findPruneCandidates2, executePrune: executePrune2 } = await Promise.resolve().then(() => (init_maintenance(), maintenance_exports));
+    const candidates = await findPruneCandidates2(learningsDir, votesDir, {
+      threshold: cmdOpts.threshold
+    });
+    if (candidates.length === 0) {
+      const { log: log4 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+      log4.info("No learnings below threshold. Knowledge base is healthy.");
+      return;
+    }
+    const { log: log3 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+    log3.info(`Found ${candidates.length} candidate(s) for pruning:`);
+    for (const c of candidates) {
+      log3.info(`  - ${c.filename} (confidence: ${c.confidence.toFixed(2)}, reason: ${c.reason})`);
+    }
+    await executePrune2(repoPath, candidates, {
+      dryRun: cmdOpts.dryRun,
+      archive: cmdOpts.archive
+    });
+    return;
+  }
+  if (cmdOpts.updateQuality) {
+    const { findStaleEntries: findStaleEntries2, reportStaleEntries: reportStaleEntries2, findRelatedAdoptedLearnings: findRelatedAdoptedLearnings2, generateUpdateDraft: generateUpdateDraft2 } = await Promise.resolve().then(() => (init_maintenance(), maintenance_exports));
+    const { writeFile: writeFile12 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+    const { log: log3 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+    const entries = await findStaleEntries2(votesDir, {
+      docs: `${repoPath}/docs`,
+      rules: `${repoPath}/rules`,
+      skills: `${repoPath}/skills`
+    });
+    reportStaleEntries2(entries);
+    if (entries.length === 0 || cmdOpts.dryRun) return;
+    log3.info("\nGenerating AI-powered update drafts...");
+    for (const entry of entries) {
+      const related = await findRelatedAdoptedLearnings2(entry, votesDir, learningsDir);
+      const draft = await generateUpdateDraft2(entry, related);
+      if (draft) {
+        const draftPath = `${entry.path}.draft.md`;
+        await writeFile12(draftPath, draft);
+        log3.success(`  Draft written: ${draftPath}`);
+      }
+    }
+    log3.info("\nReview drafts, then rename .draft.md -> .md to apply updates.");
+    return;
+  }
+  const { log: log2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+  log2.info("Usage: teamai recall maintenance --prune | --confidence-writeback | --update-quality");
+});
+recallCmd.command("promote [learningId]").description("Promote a high-confidence learning to formal knowledge (docs/skills/rules)").option("--category <cat>", "Target category: skills | rules | docs").option("--dry-run", "Show what would be done without making changes").action(async (learningId, cmdOpts) => {
+  const { requireInit: requireInit3 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { localConfig } = await requireInit3();
+  const repoPath = localConfig.repo.localPath;
+  const votesDir = `${repoPath}/votes`;
+  const learningsDir = `${repoPath}/learnings`;
+  const { findPromotionCandidates: findPromotionCandidates2, executePromotion: executePromotion2 } = await Promise.resolve().then(() => (init_maintenance(), maintenance_exports));
+  const { log: log2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+  const candidates = await findPromotionCandidates2(learningsDir, votesDir);
+  if (candidates.length === 0) {
+    log2.info("No learnings eligible for promotion yet.");
+    return;
+  }
+  if (!learningId) {
+    log2.info(`${candidates.length} learning(s) eligible for promotion:`);
+    for (const c of candidates) {
+      log2.info(`  - ${c.docId} (confidence: ${c.confidence.toFixed(2)}, suggested: ${c.suggestedCategory})`);
+    }
+    log2.info("\nRun: teamai recall promote <learning-id> [--category <cat>]");
+    return;
+  }
+  const candidate = candidates.find((c) => c.docId === learningId);
+  if (!candidate) {
+    log2.error(`Learning "${learningId}" not found or not eligible for promotion.`);
+    return;
+  }
+  await executePromotion2(candidate, repoPath, {
+    category: cmdOpts.category,
+    dryRun: cmdOpts.dryRun
+  });
+});
 program.parse();
 //# sourceMappingURL=index.js.map