@kenhkl/agent-moss 0.16.7 → 0.16.12

package/dist/engine/coordinator.js

@@ -406,58 +406,57 @@ function parseDirEnv(envName) {
   if (!raw) return [];
   return raw.split(/[,;]/).map((s) => s.trim()).filter(Boolean).map((s) => resolve(s));
 }
-function overrideRulesDirs() {
-  return [...parseDirEnv("AGENT_MOSS_OVERRIDE_RULES_DIR"), resolve(dataRootDir(), "rules")];
-}
-function warnOverride(name, path5, data) {
-  if (warnedOverride.has(path5)) return;
-  warnedOverride.add(path5);
-  console.warn(
-    `[AgentMoss] \u89C4\u5219\u6587\u4EF6\u88AB\u8986\u76D6\u76EE\u5F55\u8986\u76D6: ${path5}\uFF08\u5185\u7F6E\u9ED8\u8BA4\u88AB\u5FFD\u7565\uFF09\u3002\u8BE5\u6587\u4EF6\u7531\u90E8\u7F72\u4FA7\u81EA\u884C\u7EF4\u62A4 \u2014\u2014 **\u5185\u7F6E\u89C4\u5219\u66F4\u65B0\u4E0D\u4F1A\u53CD\u6620\u5230\u5B83\u4E0A\u9762**\uFF1B\u5220\u9664\u8BE5\u6587\u4EF6\uFF08\u6216\u6E05\u7A7A AGENT_MOSS_OVERRIDE_RULES_DIR\uFF09\u5373\u6062\u590D\u5185\u7F6E\u89C4\u5219\u3002\u82E5\u53EA\u60F3\u9010\u6761\u542F\u505C/\u589E\u5220\uFF0C\u8BF7\u6539\u7528 runtime config\uFF08Console\uFF09\u3002`
-  );
-  const missing = (EXPECTED_KEYS[name] || []).filter((k) => !(k in data));
-  if (missing.length > 0) {
-    console.warn(
-      `\u26A0\uFE0F  [AgentMoss] \u8986\u76D6\u6587\u4EF6 ${path5} \u7F3A\u5C11\u9876\u5C42\u952E [${missing.join(", ")}] \u2014\u2014 \u5BF9\u5E94\u7C7B\u522B\u4F1A**\u4E00\u6761\u89C4\u5219\u90FD\u4E0D\u8DD1**\uFF08\u9759\u9ED8\u5931\u6548\uFF09\u3002\u82E5\u53EA\u60F3\u6539\u5176\u4E2D\u4E00\u7C7B\uFF0C\u8BF7\u5148\u62F7\u8D1D\u5B8C\u6574\u7684\u5185\u7F6E\u6587\u4EF6\u518D\u6539\u3002`
-    );
-  }
+function rulesDirs() {
+  const dirs = [];
+  for (const env of RULES_DIR_ENVS) dirs.push(...parseDirEnv(env));
+  dirs.push(resolve(dataRootDir(), "rules"));
+  return [...new Set(dirs)];
 }
 function findRulesFile(name) {
-  for (const dir of overrideRulesDirs()) {
-    const p = resolve(dir, name);
-    if (existsSync(p)) return p;
-  }
   for (const dir of RULES_DIR_CANDS) {
     const p = resolve(dir, name);
     if (existsSync(p)) return p;
   }
   return null;
 }
-function isOverridePath(name, p) {
-  return overrideRulesDirs().some((dir) => resolve(dir, name) === p);
-}
 function loadJson(name) {
   const p = findRulesFile(name);
   if (!p) return {};
-  const isOverride = isOverridePath(name, p);
-  let data;
   try {
-    data = JSON.parse(readFileSync2(p, "utf-8")) || {};
+    return JSON.parse(readFileSync2(p, "utf-8")) || {};
   } catch {
-    if (isOverride) warnOverride(name, p, {});
     return {};
   }
-  if (isOverride) warnOverride(name, p, data);
-  return data;
 }
 function resolveScenarioRulesFile(scenarioId) {
   const rel = join2("scenarios", scenarioId, "rules.json");
-  for (const dir of overrideRulesDirs()) {
+  for (const dir of rulesDirs()) {
     const p = resolve(dir, rel);
-    if (existsSync(p)) return p;
+    if (!existsSync(p)) continue;
+    let reason = "";
+    try {
+      reason = invalidScenarioRulesReason(JSON.parse(readFileSync2(p, "utf-8")) || {});
+    } catch (err) {
+      reason = `\u8BFB\u53D6/\u89E3\u6790\u5931\u8D25: ${String(err)}`;
+    }
+    if (reason) {
+      console.error(
+        `[AgentMoss] \u274C \u573A\u666F\u89C4\u5219\u8986\u76D6\u6587\u4EF6\u7ED3\u6784\u4E0D\u53EF\u7528\uFF0C**\u5DF2\u5FFD\u7565\u5E76\u56DE\u9000\u5185\u7F6E**: ${p}
+    \u539F\u56E0: ${reason}`
+      );
+      return null;
+    }
+    console.warn(`[AgentMoss] \u26A0\uFE0F  \u573A\u666F ${scenarioId} \u89C4\u5219\u88AB\u8986\u76D6: ${p}\uFF08\u5185\u7F6E\u66F4\u65B0\u4E0D\u4F1A\u53CD\u6620\u5230\u5B83\u4E0A\u9762\uFF09`);
+    return p;
   }
   return null;
 }
+function invalidScenarioRulesReason(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return `\u9876\u5C42\u5FC5\u987B\u662F JSON \u5BF9\u8C61\uFF0C\u5B9E\u9645\u662F ${Array.isArray(data) ? "array" : typeof data}`;
+  }
+  return SCENARIO_LIST_KEYS.filter((k) => k in data && !Array.isArray(data[k])).map((k) => `"${k}" \u5E94\u4E3A\u6570\u7EC4\uFF08\u5BF9\u8C61\u6570\u7EC4\uFF09\uFF0C\u5B9E\u9645\u662F ${typeof data[k]}`).join("\uFF1B");
+}
 function loadL1() {
   return loadJson("l1_rules.json");
 }
@@ -465,10 +464,40 @@ function loadL2() {
   return loadJson("l2_rules.json");
 }
 function loadL3() {
-  return loadJson("l3_rules.json");
+  const data = { ...loadJson("l3_rules.json") };
+  try {
+    const ov = loadOverrideRules().skills;
+    const ex = loadExtraRules().skills || {};
+    if (ov && typeof ov === "object") {
+      for (const [cat, skills] of Object.entries(ov)) data[cat] = { ...skills };
+    }
+    if (ex && typeof ex === "object") {
+      for (const [cat, skills] of Object.entries(ex)) data[cat] = { ...data[cat] || {}, ...skills };
+    }
+  } catch {
+  }
+  return data;
+}
+function loadMCRaw() {
+  const mc = { ...loadJson("mc_rules.json") };
+  let rules = [...mc.rules || []];
+  try {
+    const ov = loadOverrideRules().ltl_rules;
+    const ex = loadExtraRules().ltl_rules || [];
+    if (Array.isArray(ov)) rules = [...ov];
+    if (Array.isArray(ex) && ex.length > 0) {
+      const byId = /* @__PURE__ */ new Map();
+      for (const r of rules) if (r && r.id) byId.set(r.id, r);
+      for (const r of ex) if (r && r.id) byId.set(r.id, r);
+      rules = [...byId.values()];
+    }
+  } catch {
+  }
+  mc.rules = rules;
+  return mc;
 }
 function loadMC() {
-  const mc = loadJson("mc_rules.json");
+  const mc = loadMCRaw();
   const rules = mc.rules || [];
   try {
     const rt = runtimeConfigBridge.current;
@@ -488,140 +517,278 @@ function loadMC() {
   return mc;
 }
 function loadToolRegistry() {
-  return loadJson("tool_registry.json");
-}
-function extraRulesDirs() {
-  return parseDirEnv("AGENT_MOSS_EXTRA_RULES_DIR");
-}
-function listJsonFilesDeep(dir) {
-  const out = [];
-  let entries;
+  const data = { ...loadJson("tool_registry.json") };
+  let tools = { ...data.tools || {} };
   try {
-    entries = readdirSync(dir, { withFileTypes: true }).map((d) => d.name);
+    const ov = loadOverrideRules().tools;
+    const ex = loadExtraRules().tools || {};
+    if (ov && typeof ov === "object") tools = { ...ov };
+    if (ex && typeof ex === "object") tools = { ...tools, ...ex };
   } catch {
-    return out;
   }
-  for (const name of entries.sort()) {
-    const p = resolve(dir, name);
-    let isDir = false;
-    try {
-      isDir = statSync(p).isDirectory();
-    } catch {
-      continue;
+  data.tools = tools;
+  return data;
+}
+function scanStructEntry(cat, value, path5) {
+  if (cat === "skills") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      console.error(`[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u7684 skills \u5E94\u4E3A\u5BF9\u8C61\uFF08{\u7C7B\u522B: {\u6280\u80FD\u540D: [\u5173\u952E\u8BCD]}}\uFF09\u2014\u2014 \u5DF2\u8DF3\u8FC7\u3002`);
+      return null;
+    }
+    const out = {};
+    for (const [skCat, skills] of Object.entries(value)) {
+      if (!skills || typeof skills !== "object" || Array.isArray(skills)) {
+        console.error(`[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u7684 skills.${skCat} \u5E94\u4E3A\u5BF9\u8C61\uFF08\u6280\u80FD\u540D \u2192 \u5173\u952E\u8BCD\u6570\u7EC4\uFF09\u2014\u2014 \u5DF2\u8DF3\u8FC7\u8BE5\u7C7B\u522B\u3002`);
+        continue;
+      }
+      const keep = {};
+      for (const [name, kws] of Object.entries(skills)) {
+        if (Array.isArray(kws)) keep[name] = kws;
+        else console.warn(`[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u7684 skills.${skCat}.${name} \u5173\u952E\u8BCD\u4E0D\u662F\u6570\u7EC4 \u2014\u2014 \u5DF2\u8DF3\u8FC7\u8BE5\u6761\u3002`);
+      }
+      if (Object.keys(keep).length > 0) out[skCat] = keep;
     }
-    if (isDir) out.push(...listJsonFilesDeep(p));
-    else if (name.toLowerCase().endsWith(".json")) out.push(p);
+    return Object.keys(out).length > 0 ? out : null;
   }
-  return out;
+  if (cat === "ltl_rules") {
+    if (!Array.isArray(value)) {
+      console.error(`[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u7684 ltl_rules \u5E94\u4E3A\u5BF9\u8C61\u6570\u7EC4 \u2014\u2014 \u5DF2\u8DF3\u8FC7\u3002`);
+      return null;
+    }
+    const keep = value.filter((r) => r && typeof r === "object" && r.id);
+    if (keep.length !== value.length) {
+      console.warn(`[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u7684 ltl_rules \u6709\u6761\u76EE\u7F3A id \u6216\u4E0D\u662F\u5BF9\u8C61 \u2014\u2014 \u5DF2\u8DF3\u8FC7\u8BE5\u6761\u3002`);
+    }
+    return keep.length > 0 ? keep : null;
+  }
+  if (cat === "tools") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      console.error(`[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u7684 tools \u5E94\u4E3A\u5BF9\u8C61\uFF08{\u5DE5\u5177\u540D: {actionClass, ...}}\uFF09\u2014\u2014 \u5DF2\u8DF3\u8FC7\u3002`);
+      return null;
+    }
+    const keep = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (v && typeof v === "object" && !Array.isArray(v)) keep[k] = v;
+      else console.warn(`[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u7684 tools.${k} \u4E0D\u662F\u5BF9\u8C61 \u2014\u2014 \u5DF2\u8DF3\u8FC7\u8BE5\u6761\u3002`);
+    }
+    return Object.keys(keep).length > 0 ? keep : null;
+  }
+  return null;
 }
-function scanExtraFiles(files) {
-  const data = {};
-  const loaded = [];
-  const seenIds = /* @__PURE__ */ new Map();
+function scanRulesFile(path5, kind) {
+  const out = {};
+  const label = kind === "override" ? "\u8986\u76D6" : "\u8FFD\u52A0";
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path5, "utf-8"));
+  } catch (e) {
+    console.error(`[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u635F\u574F/\u4E0D\u53EF\u8BFB\uFF0C\u5DF2\u8DF3\u8FC7\uFF08${kind} \u89C4\u5219\u4E0D\u751F\u6548\uFF09: ${e.message}`);
+    return out;
+  }
   const classifyFlat = (r) => {
     for (const [keys, cat] of EXTRA_FLAT_FIELD) {
       if (r && typeof r === "object" && keys.every((k) => r[k])) return cat;
     }
     return null;
   };
-  for (const p of files) {
-    let parsed;
-    try {
-      parsed = JSON.parse(readFileSync2(p, "utf-8"));
-    } catch (e) {
-      console.warn(`[AgentMoss] \u8FFD\u52A0\u89C4\u5219\u6587\u4EF6\u635F\u574F/\u4E0D\u53EF\u8BFB\uFF0C\u5DF2\u8DF3\u8FC7: ${p}\uFF08${e.message}\uFF09`);
+  let pairs = [];
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    pairs = Object.entries(parsed);
+  } else if (Array.isArray(parsed)) {
+    let flatBad = 0;
+    for (const r of parsed) {
+      const cat = classifyFlat(r);
+      if (cat === null) {
+        flatBad += 1;
+        continue;
+      }
+      pairs.push([cat, [r]]);
+    }
+    if (flatBad > 0) {
+      console.warn(
+        `[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u6709 ${flatBad} \u6761\u5E73\u94FA\u6761\u76EE\u65E0\u6CD5\u5F52\u7C7B\uFF08\u88F8 pattern \u4E0D\u5E26 risk_level/risk_type \u65F6\u533A\u5206\u4E0D\u4E86 L1 \u5371\u9669\u547D\u4EE4\u4E0E L2 \u6388\u6743\u7C7B\uFF09\u2014\u2014 \u8BF7\u6539\u7528\u5BF9\u8C61\u5F62\u5F0F\uFF1A{"\u7C7B\u522B\u952E": [\u6761\u76EE...]}\u3002`
+      );
+    }
+  } else {
+    console.error(`[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u9876\u5C42\u5E94\u662F\u5BF9\u8C61\uFF08\u7C7B\u522B\u952E\u2192\u6761\u76EE\u6570\u7EC4\uFF09\u6216\u6570\u7EC4\uFF0C\u5DF2\u8DF3\u8FC7\u3002`);
+    return out;
+  }
+  for (const [cat, rules] of pairs) {
+    if (String(cat).startsWith("_")) continue;
+    if (STRUCT_KEYS.includes(cat)) {
+      const got = scanStructEntry(cat, rules, path5);
+      if (got !== null) out[cat] = got;
       continue;
     }
-    let pairs = [];
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      pairs = Object.entries(parsed);
-    } else if (Array.isArray(parsed)) {
-      let flatBad = 0;
-      for (const r of parsed) {
-        const cat = classifyFlat(r);
-        if (cat === null) {
-          flatBad += 1;
-          continue;
-        }
-        pairs.push([cat, [r]]);
-      }
-      if (flatBad > 0) {
-        console.warn(
-          `[AgentMoss] \u8FFD\u52A0\u89C4\u5219\u6587\u4EF6 ${p} \u6709 ${flatBad} \u6761\u5E73\u94FA\u6761\u76EE\u65E0\u6CD5\u5F52\u7C7B\uFF08\u88F8 pattern \u4E0D\u5E26 risk_level/risk_type \u65F6\u533A\u5206\u4E0D\u4E86 L1 \u5371\u9669\u547D\u4EE4\u4E0E L2 \u6388\u6743\u7C7B\uFF09\u2014\u2014 \u8BF7\u6539\u7528\u5BF9\u8C61\u5F62\u5F0F\uFF1A{"\u7C7B\u522B\u952E": [\u6761\u76EE...]}\u3002`
-        );
-      }
-    } else {
+    const required = EXTRA_CATEGORIES[cat];
+    if (!required) {
       console.warn(
-        `[AgentMoss] \u8FFD\u52A0\u89C4\u5219\u6587\u4EF6 ${p} \u9876\u5C42\u5E94\u662F\u5BF9\u8C61\uFF08\u7C7B\u522B\u952E\u2192\u6761\u76EE\u6570\u7EC4\uFF09\u6216\u6570\u7EC4\uFF0C\u5DF2\u8DF3\u8FC7\u3002`
+        `[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u542B\u672A\u77E5\u7C7B\u522B\u952E "${cat}"\uFF08\u53EF\u7528\uFF1A${Object.keys(EXTRA_CATEGORIES).join(", ")}\uFF09\u2014\u2014 \u5DF2\u8DF3\u8FC7\u8BE5\u7C7B\u522B\u3002`
+      );
+      continue;
+    }
+    if (rules && typeof rules === "object" && !Array.isArray(rules)) {
+      console.error(
+        `[AgentMoss] \u274C \u89C4\u5219\u6587\u4EF6 ${path5} \u7684\u7C7B\u522B "${cat}" \u662F**\u5BF9\u8C61**\uFF0C\u5E94\u4E3A**\u5BF9\u8C61\u6570\u7EC4** \u2014\u2014 \u5DF2\u8DF3\u8FC7\u8BE5\u7C7B\u522B\u3002
+    \u6B63\u786E\u5199\u6CD5: {"${cat}": [{"pattern": "...", "risk_level": "high", ...}]}
+    \u4F60\u5199\u7684\u50CF\u662F runtime config \u7684\u683C\u5F0F\uFF08{"category_enabled": ..., "rules": [...]}\uFF09\u2014\u2014\u90A3\u662F ~/.config/agentmoss/agent_moss_runtime.json \u7684\u683C\u5F0F\uFF0C\u4E0D\u80FD\u76F4\u63A5\u5F53\u89C4\u5219\u6587\u4EF6\u7528\u3002`
       );
       continue;
     }
-    let nLoaded = 0;
-    for (const [cat, rules] of pairs) {
-      const required = EXTRA_CATEGORIES[cat];
-      if (!required) {
+    if (!Array.isArray(rules)) {
+      console.warn(`[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u7684\u7C7B\u522B "${cat}" \u5E94\u4E3A\u6570\u7EC4\uFF0C\u5B9E\u9645\u662F ${typeof rules} \u2014\u2014 \u5DF2\u8DF3\u8FC7\u8BE5\u7C7B\u522B\u3002`);
+      continue;
+    }
+    const items = [];
+    for (const r of rules) {
+      if (!r || typeof r !== "object" || !required.every((k) => r[k])) {
         console.warn(
-          `[AgentMoss] \u8FFD\u52A0\u89C4\u5219\u6587\u4EF6 ${p} \u542B\u672A\u77E5\u7C7B\u522B\u952E "${cat}"\uFF08\u53EF\u7528\uFF1A${Object.keys(EXTRA_CATEGORIES).join(", ")}\uFF09\u2014\u2014 \u5DF2\u8DF3\u8FC7\u8BE5\u7C7B\u522B\u3002`
+          `[AgentMoss] \u89C4\u5219\u6587\u4EF6 ${path5} \u7C7B\u522B ${cat} \u6709\u6761\u76EE\u7F3A\u5FC5\u9700\u5B57\u6BB5 [${required.join(", ")}] \u2014\u2014 \u5DF2\u8DF3\u8FC7\u8BE5\u6761\u3002`
         );
         continue;
       }
-      if (!Array.isArray(rules)) {
-        console.warn(`[AgentMoss] \u8FFD\u52A0\u89C4\u5219\u6587\u4EF6 ${p} \u7C7B\u522B ${cat} \u7684\u503C\u5E94\u662F\u6570\u7EC4 \u2014\u2014 \u5DF2\u8DF3\u8FC7\u3002`);
+      items.push(r);
+    }
+    if (items.length > 0) out[cat] = (out[cat] || []).concat(items);
+  }
+  if (Object.keys(out).length > 0) {
+    console.info(
+      `[AgentMoss] \u5DF2\u52A0\u8F7D${label}\u89C4\u5219\u6587\u4EF6 ${path5}\uFF1A` + Object.entries(out).map(([k, v]) => `${k}\xD7${v.length}`).join(", ")
+    );
+  }
+  return out;
+}
+function scanRuleDirs() {
+  const override = {};
+  const extra = {};
+  const loaded = [];
+  const ignored = [];
+  for (const d of rulesDirs()) {
+    if (!existsSync(d)) continue;
+    let entries = [];
+    try {
+      entries = readdirSync(d).sort();
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      const f = resolve(d, name);
+      try {
+        if (statSync(f).isDirectory()) continue;
+      } catch {
         continue;
       }
-      for (const r of rules) {
-        if (!r || typeof r !== "object" || !required.every((k) => r[k])) {
-          console.warn(
-            `[AgentMoss] \u8FFD\u52A0\u89C4\u5219\u6587\u4EF6 ${p} \u7C7B\u522B ${cat} \u6709\u6761\u76EE\u7F3A\u5FC5\u9700\u5B57\u6BB5 [${required.join(", ")}] \u2014\u2014 \u5DF2\u8DF3\u8FC7\u8BE5\u6761\u3002`
-          );
-          continue;
+      if (name === OVERRIDE_FILENAME) {
+        const got = scanRulesFile(f, "override");
+        if (Object.keys(got).length > 0) loaded.push(f);
+        for (const [cat, items] of Object.entries(got)) {
+          if (Array.isArray(items)) {
+            override[cat] = (override[cat] || []).concat(items);
+          } else {
+            override[cat] = { ...override[cat] || {}, ...items };
+          }
         }
-        const rid = r && typeof r === "object" ? String(r.id || "") : "";
-        if (rid) {
-          if (seenIds.has(rid)) {
-            console.warn(
-              `[AgentMoss] \u8FFD\u52A0\u89C4\u5219 id "${rid}" \u91CD\u590D\uFF08\u5148\u89C1\u4E8E ${seenIds.get(rid)}\uFF0C\u672C\u6761\u6765\u81EA ${p}\uFF09\u2014\u2014 \u5DF2\u8DF3\u8FC7\u672C\u6761\u3002`
-            );
-            continue;
+      } else if (name === EXTRA_FILENAME) {
+        const got = scanRulesFile(f, "extra");
+        if (Object.values(got).some((v) => v.length > 0)) loaded.push(f);
+        for (const [cat, items] of Object.entries(got)) {
+          if (Array.isArray(items)) {
+            extra[cat] = (extra[cat] || []).concat(items);
+          } else {
+            extra[cat] = { ...extra[cat] || {}, ...items };
           }
-          seenIds.set(rid, p);
         }
-        (data[cat] = data[cat] || []).push(r);
-        nLoaded += 1;
+      } else if (name.toLowerCase().endsWith(".json")) {
+        ignored.push(f);
       }
     }
-    if (nLoaded > 0) {
-      loaded.push(p);
-      console.info(`[AgentMoss] \u5DF2\u52A0\u8F7D\u8FFD\u52A0\u89C4\u5219\u6587\u4EF6 ${p}\uFF1A${nLoaded} \u6761`);
+  }
+  if (Object.keys(override).length > 0 && identicalToBuiltin(override)) {
+    const key = "override-identical::" + Object.entries(override).map(([c, v]) => `${c}=${v.length}`).sort().join("|");
+    if (!warnedIgnored.has(key)) {
+      warnedIgnored.add(key);
+      console.warn(
+        `[AgentMoss] \u2139\uFE0F  ${OVERRIDE_FILENAME} \u4E0E**\u5185\u7F6E\u89C4\u5219\u5B8C\u5168\u4E00\u81F4**\uFF08` + Object.entries(override).sort().map(([c, v]) => `${c}\xD7${v.length}`).join(", ") + `\uFF09\u2014\u2014 \u770B\u8D77\u6765\u662F\u6A21\u677F\u539F\u6837\u62F7\u8FDB\u6765\u6CA1\u6539\u3002
+    \u5B83\u73B0\u5728\u7684\u6548\u679C = \u5185\u7F6E\u89C4\u5219\uFF1B\u4F46**\u4EE5\u540E\u5347\u7EA7\u5185\u7F6E\u89C4\u5219\u4E0D\u4F1A\u53CD\u6620\u5230\u8FD9\u4EFD\u4E0A**\uFF08\u88AB\u9489\u4F4F\u4E86\uFF09\u3002
+    \u53EA\u60F3\u8FFD\u52A0\u89C4\u5219\uFF1A\u5220\u6389 ${OVERRIDE_FILENAME}\uFF0C\u6539\u7528 ${EXTRA_FILENAME}\u3002`
+      );
     }
   }
-  return { data, loaded };
+  if (Object.keys(override).length > 0) {
+    const key = "override-summary::" + Object.entries(override).map(([c, v]) => `${c}=${v.length}`).sort().join("|");
+    if (!warnedIgnored.has(key)) {
+      warnedIgnored.add(key);
+      const l1 = loadL1();
+      const l2 = loadL2();
+      const builtinCounts = {
+        dangerous_commands: (l1.dangerous_commands || []).length,
+        injection_detection: (l1.injection_detection || []).length,
+        sensitive_path_access: (l1.sensitive_path_access || []).length,
+        intent_consistency: (l2.intent_consistency || []).length,
+        password_modify_consent: (l2.password_modify_consent || []).length,
+        user_deletion_consent: (l2.user_deletion_consent || []).length
+      };
+      console.warn(`[AgentMoss] \u26A0\uFE0F  ${OVERRIDE_FILENAME} \u751F\u6548\uFF08**\u6574\u4EFD\u66FF\u6362**\uFF0C\u672A\u5217\u51FA\u7684\u5185\u7F6E\u89C4\u5219\u4E0D\u518D\u751F\u6548\uFF09\uFF1A`);
+      for (const [cat, items] of Object.entries(override).sort()) {
+        console.warn(`      \u7C7B\u522B ${cat}\uFF1A\u5185\u7F6E ${builtinCounts[cat] ?? 0} \u6761 \u2192 \u4F60\u7684 ${items.length} \u6761`);
+      }
+      console.warn(`    \u53EA\u60F3**\u8FFD\u52A0**\u89C4\u5219\u8BF7\u6539\u7528 ${EXTRA_FILENAME}\uFF1B\u8981\u6539\u67D0\u4E00\u6761\u5185\u7F6E\u89C4\u5219\uFF0C\u8BF7\u5148\u62F7\u8D1D\u5185\u7F6E\u6587\u4EF6\u518D\u6539\u3002`);
+    }
+  }
+  if (ignored.length > 0) {
+    const key = "ignored::" + ignored.join("|");
+    if (!warnedIgnored.has(key)) {
+      warnedIgnored.add(key);
+      console.warn(
+        `[AgentMoss] \u26A0\uFE0F  \u89C4\u5219\u76EE\u5F55\u91CC\u6709 ${ignored.length} \u4E2A json **\u4E0D\u4F1A\u88AB\u8BFB\u53D6**\uFF08\u53EA\u6709 ${OVERRIDE_FILENAME} \u4E0E ${EXTRA_FILENAME} \u4F1A\u88AB\u8BFB\uFF09: ${ignored.join(", ")}
+    \u8981\u8986\u76D6\u5185\u7F6E\u89C4\u5219 \u2192 \u5185\u5BB9\u653E\u8FDB ${OVERRIDE_FILENAME}\uFF1B\u8981\u8FFD\u52A0 \u2192 \u653E\u8FDB ${EXTRA_FILENAME}\u3002`
+      );
+    }
+  }
+  return { override, extra, loaded, ignored };
 }
-function loadExtraRules() {
-  const raw = (process.env.AGENT_MOSS_EXTRA_RULES_DIR || "").trim();
-  const dirs = extraRulesDirs();
-  let files = [];
+function rulesCached() {
+  const dirs = rulesDirs();
+  const sig = RULES_DIR_ENVS.map((e) => `${e}=${process.env[e] || ""}`).join("|") + "|" + dirs.join("|");
+  const files = [];
   for (const d of dirs) {
-    if (existsSync(d)) files.push(...listJsonFilesDeep(d));
-    else console.warn(`[AgentMoss] \u8FFD\u52A0\u89C4\u5219\u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u5DF2\u8DF3\u8FC7: ${d}\uFF08AGENT_MOSS_EXTRA_RULES_DIR\uFF09`);
+    if (!existsSync(d)) continue;
+    try {
+      for (const name of readdirSync(d).sort()) {
+        if (name.toLowerCase().endsWith(".json")) files.push(resolve(d, name));
+      }
+    } catch {
+    }
   }
-  files = files.sort();
-  const fp = files.map((p) => {
+  const fp = JSON.stringify(files.map((p) => {
     try {
       const st = statSync(p);
       return [p, st.mtimeMs, st.size];
     } catch {
       return [p, -1, -1];
     }
-  });
-  if (extraCache && extraCache.raw === raw && JSON.stringify(extraCache.fp) === JSON.stringify(fp)) {
-    return extraCache.data;
+  }));
+  if (_RULES_CACHE && _RULES_CACHE.sig === sig && _RULES_CACHE.fp === fp) return _RULES_CACHE;
+  _RULES_CACHE = { sig, fp, ...scanRuleDirs() };
+  return _RULES_CACHE;
+}
+function identicalToBuiltin(override) {
+  const l1 = loadL1();
+  const l2 = loadL2();
+  for (const [cat, items] of Object.entries(override)) {
+    const builtin = l1[cat] ?? l2[cat];
+    if (!Array.isArray(builtin) || builtin.length !== items.length) return false;
+    if (JSON.stringify(builtin) !== JSON.stringify(items)) return false;
   }
-  const { data, loaded } = scanExtraFiles(files);
-  extraCache = { raw, fp, data, loaded };
-  return data;
+  return Object.keys(override).length > 0;
+}
+function loadOverrideRules() {
+  return rulesCached().override;
 }
-var __filename2, __dirname2, EXPECTED_KEYS, warnedOverride, RULES_DIR_CANDS, EXTRA_CATEGORIES, EXTRA_FLAT_FIELD, extraCache;
+function loadExtraRules() {
+  return rulesCached().extra;
+}
+var __filename2, __dirname2, OVERRIDE_FILENAME, EXTRA_FILENAME, RULES_DIR_ENVS, RULES_DIR_CANDS, SCENARIO_LIST_KEYS, EXTRA_CATEGORIES, STRUCT_KEYS, EXTRA_FLAT_FIELD, _RULES_CACHE, warnedIgnored;
 var init_rules_loader = __esm({
   "src/infra/rules-loader.ts"() {
     "use strict";
@@ -630,20 +797,13 @@ var init_rules_loader = __esm({
     init_runtime_config_bridge();
     __filename2 = fileURLToPath2(import.meta.url);
     __dirname2 = dirname(__filename2);
-    EXPECTED_KEYS = {
-      "l1_rules.json": ["dangerous_commands", "injection_detection", "sensitive_path_access"],
-      "l2_rules.json": ["intent_consistency", "password_modify_consent", "user_deletion_consent"],
-      "l3_rules.json": [],
-      "mc_rules.json": ["rules"],
-      "tool_registry.json": ["tools"]
-    };
-    warnedOverride = /* @__PURE__ */ new Set();
+    OVERRIDE_FILENAME = "override.json";
+    EXTRA_FILENAME = "extra.json";
+    RULES_DIR_ENVS = ["AGENT_MOSS_EXTRA_RULES_DIR", "AGENT_MOSS_OVERRIDE_RULES_DIR"];
     RULES_DIR_CANDS = (() => {
       const cands = [
-        // 用户数据目录覆盖优先（与 Python rules_loader.resolve_rules_file 的
-        // <data_root>/rules/<name> 优先逻辑对齐）。用户安装 pip/npm 包后把自定义
-        // mc_rules.json 放到 <data_root>/rules/ 即可覆盖内置默认，无需改源码。
-        resolve(dataRootDir(), "rules"),
+        // 注：`<data_root>/rules/` 不再是"按内置文件名覆盖"的查找位 —— 2026-10 起
+        // 规则目录只认 override.json / extra.json（见 rulesDirs()）。
         // dist: __dirname=dist/ → dist/rules；__dirname=dist/engine/ → dist/engine/../rules=dist/rules
         resolve(__dirname2, "../rules"),
         resolve(__dirname2, "rules"),
@@ -656,6 +816,7 @@ var init_rules_loader = __esm({
       ];
       return cands.filter((c) => existsSync(c));
     })();
+    SCENARIO_LIST_KEYS = ["extra_command_patterns", "extra_injection_keywords", "extra_sensitive_paths"];
     EXTRA_CATEGORIES = {
       dangerous_commands: ["pattern"],
       injection_detection: ["keyword", "lang"],
@@ -664,6 +825,7 @@ var init_rules_loader = __esm({
       password_modify_consent: ["pattern"],
       user_deletion_consent: ["pattern"]
     };
+    STRUCT_KEYS = ["skills", "ltl_rules", "tools"];
     EXTRA_FLAT_FIELD = [
       [["path"], "sensitive_path_access"],
       [["keyword", "lang"], "injection_detection"],
@@ -671,7 +833,8 @@ var init_rules_loader = __esm({
       [["pattern", "risk_level"], "dangerous_commands"],
       [["pattern", "risk_type"], "dangerous_commands"]
     ];
-    extraCache = null;
+    _RULES_CACHE = null;
+    warnedIgnored = /* @__PURE__ */ new Set();
   }
 });
 
@@ -2029,18 +2192,34 @@ function _mergeUserCustom(primary, runtime, layers, key) {
   const extra = _userCustomRules(runtime, layers, key);
   return extra.length > 0 ? [...primary, ...extra] : [...primary];
 }
-function _mergeExtraDirRules(primary, category) {
+function _dedup(rules, category) {
+  const keys = _DEDUP_KEYS[category];
+  if (!keys) return rules;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of rules) {
+    const k = keys.map((x) => String(r?.[x] ?? "")).join("\0");
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(r);
+  }
+  return out;
+}
+function _mergeRulesFromDirs(primary, category) {
+  let base = [...primary];
   try {
+    const override = loadOverrideRules()[category];
+    if (override !== void 0 && override !== null) base = [...override];
     const extra = loadExtraRules()[category] || [];
-    return extra.length > 0 ? [...primary, ...extra] : [...primary];
+    return _dedup([...base, ...extra], category);
   } catch {
-    return [...primary];
+    return base;
   }
 }
 function getEnabledL1CommandPatterns(runtime, osType) {
   const cat = runtime.L1_rules?.dangerous_commands || { category_enabled: true, rules: [] };
   let rules = filterEnabledRules(cat.rules || [], cat.category_enabled);
-  rules = _mergeExtraDirRules(rules, "dangerous_commands");
+  rules = _mergeRulesFromDirs(rules, "dangerous_commands");
   rules = _mergeUserCustom(rules, runtime, "L1_rules", "pattern");
   if (osType) rules = _filterRulesByOs(rules, osType);
   return rules.map((r) => ({
@@ -2056,7 +2235,7 @@ function getEnabledL2SensitivePaths(runtime, osType) {
     cat = runtime.L2_rules?.sensitive_path_access || { category_enabled: true, rules: [] };
   }
   let rules = filterEnabledRules(cat.rules || [], cat.category_enabled);
-  rules = _mergeExtraDirRules(rules, "sensitive_path_access");
+  rules = _mergeRulesFromDirs(rules, "sensitive_path_access");
   rules = _mergeUserCustom(rules, runtime, ["L1_rules", "L2_rules"], "path");
   if (osType) rules = _filterRulesByOs(rules, osType);
   return rules.map((r) => {
@@ -2441,25 +2620,11 @@ function generateSourceDefaults() {
   };
 }
 function _ltlRulesToRuntime() {
-  const cands = [
-    getRuntimeConfigDir() && join3(getRuntimeConfigDir(), "rules"),
-    join3(__dirname4, "../rules"),
-    join3(__dirname4, "rules"),
-    join3(__dirname4, "../../../agent_moss/rules"),
-    join3(__dirname4, "../../../../agent_moss/rules"),
-    join3(process.cwd(), "agent_moss/rules")
-  ].filter(Boolean);
   let mc = {};
-  for (const dir of cands) {
-    const p = join3(dir, "mc_rules.json");
-    if (existsSync5(p)) {
-      try {
-        mc = JSON.parse(readFileSync4(p, "utf-8")) || {};
-      } catch {
-        mc = {};
-      }
-      break;
-    }
+  try {
+    mc = loadMCRaw();
+  } catch {
+    mc = {};
   }
   const rules = mc.rules || [];
   return {
@@ -2688,7 +2853,7 @@ function _migrateCategoriesAcrossLayers(cfg, srcLayer, dstLayer, catNames) {
 function getEnabledL1InjectionKeywords(runtime, osType) {
   const cat = runtime.L1_rules?.injection_detection || { category_enabled: true, rules: [] };
   let rules = filterEnabledRules(cat.rules || [], cat.category_enabled);
-  rules = _mergeExtraDirRules(rules, "injection_detection");
+  rules = _mergeRulesFromDirs(rules, "injection_detection");
   rules = _mergeUserCustom(rules, runtime, "L1_rules", "keyword");
   if (osType) rules = _filterRulesByOs(rules, osType);
   return rules.map((r) => ({
@@ -2700,7 +2865,7 @@ function getEnabledL1InjectionKeywords(runtime, osType) {
 function getEnabledL2IntentPatterns(runtime, osType) {
   const cat = runtime.L2_rules?.intent_consistency || { category_enabled: true, rules: [] };
   let rules = filterEnabledRules(cat.rules || [], cat.category_enabled);
-  rules = _mergeExtraDirRules(rules, "intent_consistency");
+  rules = _mergeRulesFromDirs(rules, "intent_consistency");
   rules = _mergeUserCustom(rules, runtime, "L2_rules", "intent_keywords");
   if (osType) rules = _filterRulesByOs(rules, osType);
   return rules.map((r) => ({
@@ -2712,7 +2877,7 @@ function getEnabledL2IntentPatterns(runtime, osType) {
 function getEnabledL2PasswordPatterns(runtime) {
   const cat = runtime.L2_rules?.password_modify_consent || { category_enabled: true, rules: [] };
   const rules = _mergeUserCustom(
-    _mergeExtraDirRules(filterEnabledRules(cat.rules || [], cat.category_enabled), "password_modify_consent"),
+    _mergeRulesFromDirs(filterEnabledRules(cat.rules || [], cat.category_enabled), "password_modify_consent"),
     runtime,
     "L2_rules",
     "pattern"
@@ -2722,7 +2887,7 @@ function getEnabledL2PasswordPatterns(runtime) {
 function getEnabledL2UserDeletionPatterns(runtime) {
   const cat = runtime.L2_rules?.user_deletion_consent || { category_enabled: true, rules: [] };
   const rules = _mergeUserCustom(
-    _mergeExtraDirRules(filterEnabledRules(cat.rules || [], cat.category_enabled), "user_deletion_consent"),
+    _mergeRulesFromDirs(filterEnabledRules(cat.rules || [], cat.category_enabled), "user_deletion_consent"),
     runtime,
     "L2_rules",
     "pattern"
@@ -2759,7 +2924,7 @@ function getEnabledL1CommandPatternsOrDefault(runtime, osType) {
     return getEnabledL1CommandPatterns(runtime, osType);
   }
   return _mergeUserCustom(
-    _mergeExtraDirRules(_filterDefaultsByOs(_l1CommandPatternsToRules(), osType), "dangerous_commands"),
+    _mergeRulesFromDirs(_filterDefaultsByOs(_l1CommandPatternsToRules(), osType), "dangerous_commands"),
     runtime,
     "L1_rules",
     "pattern"
@@ -2771,7 +2936,7 @@ function getEnabledL1InjectionKeywordsOrDefault(runtime, osType) {
     return getEnabledL1InjectionKeywords(runtime, osType);
   }
   return _mergeUserCustom(
-    _mergeExtraDirRules(_l1InjectionKeywordsToRules(), "injection_detection"),
+    _mergeRulesFromDirs(_l1InjectionKeywordsToRules(), "injection_detection"),
     runtime,
     "L1_rules",
     "keyword"
@@ -2783,7 +2948,7 @@ function getEnabledL2SensitivePathsOrDefault(runtime, osType) {
     return getEnabledL2SensitivePaths(runtime, osType);
   }
   return _mergeUserCustom(
-    _mergeExtraDirRules(_filterDefaultsByOs(_l2SensitivePathsToRules(), osType), "sensitive_path_access"),
+    _mergeRulesFromDirs(_filterDefaultsByOs(_l2SensitivePathsToRules(), osType), "sensitive_path_access"),
     runtime,
     ["L1_rules", "L2_rules"],
     "path"
@@ -2795,7 +2960,7 @@ function getEnabledL2IntentPatternsOrDefault(runtime, osType) {
     return getEnabledL2IntentPatterns(runtime, osType);
   }
   return _mergeUserCustom(
-    _mergeExtraDirRules(_filterDefaultsByOs(_l2IntentPatternsToRules(), osType), "intent_consistency"),
+    _mergeRulesFromDirs(_filterDefaultsByOs(_l2IntentPatternsToRules(), osType), "intent_consistency"),
     runtime,
     "L2_rules",
     "intent_keywords"
@@ -3186,7 +3351,7 @@ function updateScenarioCategoryEnabled(scenarioId, category, enabled) {
   saveRuntimeConfig(runtime);
   return runtime;
 }
-var __dirname4, ENV_RUNTIME_CONFIG_PATH, RUNTIME_CONFIG_DIR, RUNTIME_CONFIG_PATH, LAYER_DISABLE_ENV, DEFAULT_LAYERS, DENY_MODE_LABELS, runtimeConfigCache, hasRuntimeConfigCache, _AGENTS_DIR_PROD, _AGENTS_DIR_DEV, _SCENARIOS_DIR_PROD, _SCENARIOS_DIR_DEV, _effectiveCache, SKILL_ID_RE;
+var __dirname4, ENV_RUNTIME_CONFIG_PATH, RUNTIME_CONFIG_DIR, RUNTIME_CONFIG_PATH, LAYER_DISABLE_ENV, DEFAULT_LAYERS, DENY_MODE_LABELS, runtimeConfigCache, _DEDUP_KEYS, hasRuntimeConfigCache, _AGENTS_DIR_PROD, _AGENTS_DIR_DEV, _SCENARIOS_DIR_PROD, _SCENARIOS_DIR_DEV, _effectiveCache, SKILL_ID_RE;
 var init_runtime_config = __esm({
   "src/infra/runtime-config.ts"() {
     "use strict";
@@ -3219,6 +3384,14 @@ var init_runtime_config = __esm({
       deny_both: "\u8BFB\u5199\u5747\u62E6\u622A"
     };
     runtimeConfigCache = null;
+    _DEDUP_KEYS = {
+      dangerous_commands: ["pattern"],
+      password_modify_consent: ["pattern"],
+      user_deletion_consent: ["pattern"],
+      sensitive_path_access: ["path"],
+      injection_detection: ["keyword", "lang"],
+      intent_consistency: ["intent_keywords", "reason"]
+    };
     hasRuntimeConfigCache = /* @__PURE__ */ new Map();
     _AGENTS_DIR_PROD = join3(__dirname4, "agents");
     _AGENTS_DIR_DEV = join3(__dirname4, "..", "..", "..", "agent_moss", "agents");
@@ -3244,6 +3417,8 @@ var init_runtime_config = __esm({
 var config_exports = {};
 __export(config_exports, {
   detectProvider: () => detectProvider,
+  getAgentMossSetting: () => getAgentMossSetting,
+  getCacheOptions: () => getCacheOptions,
   getCustomRules: () => getCustomRules,
   getLLMConfig: () => getLLMConfig,
   getLLMFailMode: () => getLLMFailMode,
@@ -3255,6 +3430,8 @@ __export(config_exports, {
   isHeuristicEnabled: () => isHeuristicEnabled,
   isLLMAvailable: () => isLLMAvailable,
   isLogicRulesEnabled: () => isLogicRulesEnabled,
+  isPolicyGenEnabled: () => isPolicyGenEnabled,
+  isPolicySaveEnabled: () => isPolicySaveEnabled,
   probeLLMConnection: () => probeLLMConnection,
   updateLLMConfig: () => updateLLMConfig,
   userRuleVariantPattern: () => userRuleVariantPattern,
@@ -3277,8 +3454,10 @@ function resolveConfigPath() {
   const userConfig = path2.join(getConfigDir(), "config.json");
   if (fs2.existsSync(userConfig)) return userConfig;
   const defaultCandidates = [
-    path2.join(__dirname, "config.json.example"),
-    path2.join(__dirname, "..", "..", "agent_moss", "infra", "config.json.example")
+    path2.join(__configModuleDir, "config.json.example"),
+    path2.join(__configModuleDir, "..", "config.json.example"),
+    path2.join(__configModuleDir, "..", "..", "agent_moss", "infra", "config.json.example"),
+    path2.join(__configModuleDir, "..", "..", "..", "agent_moss", "infra", "config.json.example")
   ];
   const defaultConfig = defaultCandidates.find((p) => fs2.existsSync(p));
   if (defaultConfig) {
@@ -3287,8 +3466,8 @@ function resolveConfigPath() {
     const pkgConfig = loadConfigFile(defaultConfig);
     const safeConfig = pkgConfig ? { ...pkgConfig, llm: { ...pkgConfig.llm, api_key: "" } } : {};
     fs2.writeFileSync(userConfig, JSON.stringify(safeConfig, null, 4), "utf-8");
-    console.log(`[AgentMoss] \u5DF2\u521B\u5EFA\u7528\u6237\u914D\u7F6E\u6587\u4EF6: ${userConfig}`);
-    console.log(`[AgentMoss] \u8BF7\u7F16\u8F91\u8BE5\u6587\u4EF6\u914D\u7F6E\u4F60\u7684 LLM API Key`);
+    console.error(`[AgentMoss] \u5DF2\u521B\u5EFA\u7528\u6237\u914D\u7F6E\u6587\u4EF6: ${userConfig}`);
+    console.error(`[AgentMoss] \u8BF7\u7F16\u8F91\u8BE5\u6587\u4EF6\u914D\u7F6E\u4F60\u7684 LLM API Key`);
   }
   return userConfig;
 }
@@ -3460,7 +3639,32 @@ function layerEnabledOrDefault(key) {
   }
 }
 function isBrainEnabled() {
-  return process.env.AGENT_MOSS_BRAIN_ENABLED === "1";
+  return getAgentMossSetting("AGENT_MOSS_BRAIN_ENABLED", "") === "1";
+}
+function getAgentMossSetting(key, def = "") {
+  const envValue = process.env[key];
+  if (envValue !== void 0) return envValue;
+  const cfg = loadConfigFile(resolveConfigPath());
+  if (cfg && key in cfg) return String(cfg[key]);
+  return def;
+}
+function isPolicyGenEnabled() {
+  return getAgentMossSetting("AGENT_MOSS_ENABLE_POLICY_GEN", "") === "1";
+}
+function getCacheOptions() {
+  let enabled = true;
+  let maxSize = 1e3;
+  const cfg = loadConfigFile(resolveConfigPath());
+  const cache3 = cfg?.cache;
+  if (cache3 && typeof cache3 === "object") {
+    if (typeof cache3.enabled === "boolean") enabled = cache3.enabled;
+    if (typeof cache3.max_size === "number" && cache3.max_size > 0) maxSize = cache3.max_size;
+  }
+  if (process.env.AGENT_MOSS_DISABLE_CACHE === "1") enabled = false;
+  return { enabled, maxSize };
+}
+function isPolicySaveEnabled() {
+  return getAgentMossSetting("AGENT_MOSS_SAVE_POLICY", "1") !== "0";
 }
 function isLogicRulesEnabled() {
   if (process.env.AGENT_MOSS_DISABLE_LOGIC_RULES === "1") return false;
@@ -3469,13 +3673,20 @@ function isLogicRulesEnabled() {
 function isFormalObserveMode() {
   return process.env.AGENT_MOSS_FORMAL_OBSERVE === "1";
 }
-var timeoutConfig, retryConfig, llmConfig, __configModuleDir, USER_RULES_PATHS, customRules, PROVIDER_HEADERS;
+var __configModuleDir, timeoutConfig, retryConfig, llmConfig, USER_RULES_PATHS, customRules, PROVIDER_HEADERS;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_esm_shims();
     init_paths();
     init_runtime_config();
+    __configModuleDir = (() => {
+      try {
+        return path2.dirname(fileURLToPath5(import.meta.url));
+      } catch {
+        return typeof __dirname !== "undefined" ? __dirname : process.cwd();
+      }
+    })();
     llmConfig = (() => {
       const configPath = resolveConfigPath();
       const fileConfig = fs2.existsSync(configPath) ? loadLLMConfigFromFile(configPath) : {};
@@ -3493,13 +3704,6 @@ var init_config = __esm({
         timeout: parseInt(process.env.AGENT_MOSS_LLM_TIMEOUT || String(fileConfig.timeout ?? String(tr.timeout.prompt1Timeout)), 10)
       };
     })();
-    __configModuleDir = (() => {
-      try {
-        return path2.dirname(fileURLToPath5(import.meta.url));
-      } catch {
-        return typeof __dirname !== "undefined" ? __dirname : process.cwd();
-      }
-    })();
     USER_RULES_PATHS = [
       path2.join(__configModuleDir, "rules", "user_rules.json"),
       // 源在 ts/src/rules（一般不存在）
@@ -7286,6 +7490,56 @@ var BrainRuleStore = class {
   getRule(ruleId) {
     return this.data.rules.find((r) => r.id === ruleId);
   }
+  /** 质疑：active → disputed，并把 disputed_count +1（镜像 Python dispute_rule）。 */
+  disputeRule(ruleId, _reason = "") {
+    const rule = this.getRule(ruleId);
+    if (!rule) throw new Error(`\u89C4\u5219\u4E0D\u5B58\u5728: ${ruleId}`);
+    if (rule.status !== STATUS_ACTIVE) throw new Error(`\u53EA\u6709 active \u72B6\u6001\u53EF\u8D28\u7591\uFF0C\u5F53\u524D: ${rule.status}`);
+    rule.status = STATUS_DISPUTED;
+    rule.disputedCount += 1;
+    this.save();
+  }
+  // ==================== 生命周期（curator 用，镜像 Python rule_store） ====================
+  /** 长期未触发的 active/disputed 规则 → stale。 */
+  markStale(staleDays = 30) {
+    const cutoff = Date.now() - staleDays * 864e5;
+    for (const r of this.data.rules) {
+      if ((r.status === STATUS_ACTIVE || r.status === STATUS_DISPUTED) && r.lastTriggeredAt > 0 && r.lastTriggeredAt < cutoff) {
+        r.status = STATUS_STALE;
+      }
+    }
+    this.save();
+  }
+  /** 长期 stale 的规则 → archived。 */
+  markArchived(archiveDays = 90) {
+    const cutoff = Date.now() - archiveDays * 864e5;
+    for (const r of this.data.rules) {
+      if (r.status === STATUS_STALE && r.lastTriggeredAt > 0 && r.lastTriggeredAt < cutoff) {
+        r.status = STATUS_ARCHIVED;
+      }
+    }
+    this.save();
+  }
+  /** disputed 次数达阈值 → 自动降级 stale（自动纠错闭环）。 */
+  autoDemoteDisputed(disputeThreshold = 3) {
+    for (const r of this.data.rules) {
+      if (r.status === STATUS_DISPUTED && r.disputedCount >= disputeThreshold) {
+        r.status = STATUS_STALE;
+      }
+    }
+    this.save();
+  }
+  // ==================== 中心化预留（镜像 Python） ====================
+  /** 导出本地新增（非 central 来源）的 active 规则。 */
+  getRulesForExport() {
+    return this.data.rules.filter((r) => r.source !== "central" && r.status === STATUS_ACTIVE);
+  }
+  /** 导入中心下发规则（强制标 central 来源，避免被再次回流）。 */
+  importRules(rules) {
+    for (const rule of rules) {
+      this.addRule({ ...rule, source: "central", originNode: "central" });
+    }
+  }
   getActiveRules(layer) {
     return this.data.rules.filter((r) => r.status === STATUS_ACTIVE && (layer === void 0 || r.layer === layer));
   }
@@ -7386,12 +7640,14 @@ var PatternExtractor = class {
   minOccurrences;
   builtinPatterns;
   reviewFn;
+  skillManager;
   constructor(ruleStore, opts) {
     this.ruleStore = ruleStore;
     this.minConfidence = opts?.minConfidence ?? 0.9;
     this.minOccurrences = opts?.minOccurrences ?? 3;
     this.builtinPatterns = opts?.builtinPatterns ?? [];
     this.reviewFn = opts?.review ?? null;
+    this.skillManager = opts?.skillManager ?? null;
   }
   async extract(event, llmResult) {
     const result = { rulesCreated: 0, patternsRecorded: 0, skippedReason: "", deduped: [] };
@@ -7480,8 +7736,96 @@ var PatternExtractor = class {
         result.rulesCreated += 1;
       }
     }
+    if (this.skillManager) {
+      const skill = this.buildSkill(actionDetail, reason, riskType, eventId);
+      if (skill) {
+        const id = this.skillManager.addSkill(skill);
+        if (id) {
+          result.skillsCreated = (result.skillsCreated ?? 0) + 1;
+        }
+      }
+    }
     return result;
   }
+  /**
+   * 生成候选 Skill；不值得沉淀时返回 null（镜像 Python `_extract_skill` 的三道价值评估）。
+   *
+   * 评估 1：reason 太短（<50 字）说明没有可复用的判断逻辑，不沉淀；
+   * 评估 2：同名 skill 已存在 → 跳过；
+   * 评估 3：与已有 active skill 关键词重叠 >= 2 → 跳过（防同类案例重复沉淀，
+   *        如 cat /etc/shadow 与 cat /etc/sudoers 生成两个近乎重复的 skill）。
+   */
+  buildSkill(actionDetail, reason, riskType, eventId) {
+    if (!reason || reason.length < 50) return null;
+    if (!riskType) return null;
+    const detailWords = (actionDetail.toLowerCase().match(/[a-z]+/g) || []).slice(0, 3);
+    const name = detailWords.length > 0 ? `brain_${riskType}_${detailWords.join("_")}` : `brain_${riskType}`;
+    if (this.skillManager.getSkillMeta(name)) return null;
+    const keywords = this.extractSkillKeywords(actionDetail, reason, riskType);
+    if (this.isCoveredByExistingSkill(keywords)) return null;
+    return {
+      name,
+      category: this.categorizeRisk(riskType),
+      content: this.generateSkillContent(name, actionDetail, reason, riskType),
+      keywords,
+      sourceEventIds: eventId ? [eventId] : [],
+      status: "active"
+    };
+  }
+  /** 关键词提取（镜像 Python `_extract_keywords`）。 */
+  extractSkillKeywords(actionDetail, reason, riskType) {
+    const keywords = /* @__PURE__ */ new Set();
+    if (riskType) keywords.add(riskType);
+    for (const w of (actionDetail.toLowerCase().match(/[a-z_]{3,}/g) || []).slice(0, 10)) keywords.add(w);
+    for (const w of (reason.toLowerCase().match(/[a-z_]{3,}/g) || []).slice(0, 5)) keywords.add(w);
+    return [...keywords];
+  }
+  /** 与已有 active skill 关键词重叠 >= 2 → 视为已覆盖（镜像 `_is_covered_by_existing_skill`）。 */
+  isCoveredByExistingSkill(keywords) {
+    if (keywords.length === 0) return false;
+    let existing = [];
+    try {
+      existing = this.skillManager.getActiveSkills();
+    } catch {
+      return false;
+    }
+    const cand = new Set(keywords.map((k) => k.toLowerCase()));
+    for (const meta of existing) {
+      const metaKeywords = (meta.keywords || []).map((k) => String(k).toLowerCase());
+      if (metaKeywords.length === 0) continue;
+      const overlap = metaKeywords.filter((k) => cand.has(k)).length;
+      if (overlap >= 2) return true;
+    }
+    return false;
+  }
+  /** 风险类型 → skill 分类（镜像 Python `_categorize_risk`）。 */
+  categorizeRisk(riskType) {
+    if (!riskType) return "edge_case";
+    if (["inject", "backdoor", "persist"].some((k) => riskType.includes(k))) return "attack_pattern";
+    if (["exfil", "leak", "export"].some((k) => riskType.includes(k))) return "attack_pattern";
+    return "defense_strategy";
+  }
+  /** skill 正文（与 Python `_generate_skill_content` 同结构，便于双端对拍）。 */
+  generateSkillContent(name, actionDetail, reason, riskType) {
+    return `# ${name}
+
+## \u6765\u6E90
+Brain \u81EA\u52A8\u63D0\u53D6\uFF08LLM \u5206\u6790\u6C89\u6DC0\uFF09
+
+## \u573A\u666F
+\u5F53 Agent \u6267\u884C\u4EE5\u4E0B\u7C7B\u578B\u64CD\u4F5C\u65F6\u89E6\u53D1\uFF1A
+- \u98CE\u9669\u7C7B\u578B: ${riskType}
+- \u64CD\u4F5C\u7279\u5F81: ${actionDetail.slice(0, 200)}
+
+## \u5224\u65AD\u4F9D\u636E
+${reason.slice(0, 500)}
+
+## \u5904\u7406\u5EFA\u8BAE
+- \u4F18\u5148\u68C0\u67E5\u64CD\u4F5C\u7684\u4E0A\u4E0B\u6587\u548C\u610F\u56FE
+- \u7ED3\u5408 action_history \u5224\u65AD\u662F\u5426\u5B58\u5728\u6076\u610F\u94FE
+- \u5FC5\u8981\u65F6 Deny \u5E76\u8BB0\u5F55\u539F\u56E0
+`;
+  }
   extractPatterns(actionDetail, reason, riskType) {
     const patterns = [];
     const detailLower = actionDetail.toLowerCase();
@@ -7669,6 +8013,209 @@ function parseReview(content) {
   };
 }
 
+// src/brain/skill-manager.ts
+init_esm_shims();
+import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync13, renameSync, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join8 } from "path";
+import { randomUUID } from "crypto";
+var DEFAULT_SKILL_META_PATH = join8(homedir5(), ".agentmoss", "brain", "skill_meta.json");
+var ENV_SKILL_META_PATH = "AGENT_MOSS_BRAIN_SKILL_META_PATH";
+function getMetaPath(override) {
+  return override || process.env[ENV_SKILL_META_PATH] || DEFAULT_SKILL_META_PATH;
+}
+var BrainSkillManager = class {
+  constructor(skillsDir, metaPath) {
+    this.skillsDir = skillsDir;
+    this.metaPath = getMetaPath(metaPath);
+    try {
+      mkdirSync4(join8(this.metaPath, ".."), { recursive: true });
+    } catch {
+    }
+    this.load();
+    this.cleanupGhostSkills();
+  }
+  skillsDir;
+  skills = [];
+  metaPath;
+  load() {
+    if (!existsSync13(this.metaPath)) return;
+    try {
+      const data = JSON.parse(readFileSync13(this.metaPath, "utf-8"));
+      this.skills = data.skills || [];
+    } catch {
+      this.skills = [];
+    }
+  }
+  save() {
+    const out = { version: 1, skills: this.skills };
+    const tmp = `${this.metaPath}.tmp`;
+    try {
+      writeFileSync4(tmp, JSON.stringify(out, null, 2), "utf-8");
+      renameSync(tmp, this.metaPath);
+    } catch {
+    }
+  }
+  /**
+   * 清理"幽灵 skill"：meta 记 active 但磁盘 .md 已不存在。
+   * （沿用 Python 的处理：置 stale，避免污染关键词表并阻塞同名新 skill 生成。）
+   */
+  cleanupGhostSkills() {
+    let changed = false;
+    for (const sk of this.skills) {
+      if (sk.status !== "active") continue;
+      if (!existsSync13(join8(this.skillsDir, `${sk.name}.md`))) {
+        sk.status = "stale";
+        changed = true;
+      }
+    }
+    if (changed) this.save();
+  }
+  /** 新增 Skill：写 .md + 记元数据。目录缺失或同名已存在时跳过（返回 ""）。 */
+  addSkill(skill) {
+    const id = skill.id || randomUUID();
+    const name = skill.name || `brain_${id.slice(0, 8)}`;
+    if (!existsSync13(this.skillsDir)) return "";
+    const mdPath = join8(this.skillsDir, `${name}.md`);
+    if (existsSync13(mdPath)) return "";
+    try {
+      writeFileSync4(mdPath, skill.content, "utf-8");
+    } catch {
+      return "";
+    }
+    this.skills.push({
+      id,
+      name,
+      category: skill.category || "",
+      keywords: skill.keywords || [],
+      source_event_ids: skill.sourceEventIds || [],
+      status: skill.status || "draft",
+      created_at: skill.createdAt || Date.now() / 1e3,
+      usage_count: skill.usageCount || 0,
+      origin_node: skill.originNode || "local"
+    });
+    this.save();
+    return id;
+  }
+  getSkillMeta(name) {
+    return this.skills.find((s) => s.name === name);
+  }
+  getActiveSkills() {
+    return this.skills.filter((s) => s.status === "active").sort((a, b) => (b.created_at || 0) - (a.created_at || 0));
+  }
+  recordUsage(name) {
+    const sk = this.getSkillMeta(name);
+    if (!sk) return;
+    sk.usage_count = (sk.usage_count || 0) + 1;
+    this.save();
+  }
+  /** 长期未使用（usage_count=0）且创建超过 staleDays 的 active skill → stale。 */
+  markStale(staleDays = 60) {
+    const cutoff = Date.now() / 1e3 - staleDays * 86400;
+    let changed = false;
+    for (const sk of this.skills) {
+      if (sk.status === "active" && (sk.usage_count || 0) === 0 && (sk.created_at || 0) < cutoff) {
+        sk.status = "stale";
+        changed = true;
+      }
+    }
+    if (changed) this.save();
+  }
+  /** 导出本地 active skill（含正文），供回流中心。 */
+  exportSkills() {
+    const out = [];
+    for (const sk of this.skills) {
+      if (sk.origin_node !== "local" || sk.status !== "active") continue;
+      const mdPath = join8(this.skillsDir, `${sk.name}.md`);
+      if (!existsSync13(mdPath)) continue;
+      out.push({
+        name: sk.name,
+        category: sk.category || "",
+        content: readFileSync13(mdPath, "utf-8"),
+        keywords: sk.keywords || []
+      });
+    }
+    return out;
+  }
+  /** 导入中心下发 skill（标 central，避免被再次回流）。 */
+  importSkills(skills) {
+    for (const s of skills) {
+      this.addSkill({
+        name: s.name,
+        category: s.category || "",
+        content: s.content,
+        keywords: s.keywords || [],
+        status: "active",
+        originNode: "central"
+      });
+    }
+  }
+  /** 保留 close 签名（JSON 落盘已逐次持久化）。 */
+  close() {
+    this.save();
+  }
+};
+
+// src/brain/curator.ts
+init_esm_shims();
+var BrainCurator = class {
+  constructor(ruleStore, skillManager) {
+    this.ruleStore = ruleStore;
+    this.skillManager = skillManager;
+  }
+  ruleStore;
+  skillManager;
+  /**
+   * 执行一次维护，返回报告。
+   *
+   * autoApprove 默认 true：brain 提取的规则达阈值后自动生效（学习闭环）；
+   * 需人工审核时设 false（由 Console 手动 approve）。
+   */
+  runMaintenance(opts = {}) {
+    const {
+      staleRuleDays = 30,
+      archiveRuleDays = 90,
+      staleSkillDays = 60,
+      disputeThreshold = 3,
+      autoApprove = true
+    } = opts;
+    const autoApproved = autoApprove ? this.autoApproveDrafts() : [];
+    this.ruleStore.markStale(staleRuleDays);
+    this.ruleStore.markArchived(archiveRuleDays);
+    this.ruleStore.autoDemoteDisputed(disputeThreshold);
+    this.skillManager.markStale(staleSkillDays);
+    return {
+      rule_stats: this.ruleStore.getStats(),
+      auto_approved: autoApproved
+    };
+  }
+  /** draft → active（仅未 disputed 的 draft）。返回被激活规则的 pattern 前缀。 */
+  autoApproveDrafts() {
+    const approved = [];
+    let drafts;
+    try {
+      drafts = this.ruleStore.getDraftRules();
+    } catch {
+      return approved;
+    }
+    for (const rule of drafts) {
+      try {
+        this.ruleStore.approveRule(rule.id);
+        approved.push(rule.pattern.slice(0, 60));
+      } catch {
+      }
+    }
+    return approved;
+  }
+};
+
+// src/brain/contributor.ts
+init_esm_shims();
+init_asset_dir();
+import { dirname as dirname9 } from "path";
+import { fileURLToPath as fileURLToPath9 } from "url";
+var __dirname8 = dirname9(fileURLToPath9(import.meta.url));
+
 // src/brain/index.ts
 function checkBrainRules(store, opts) {
   if (!store) return null;
@@ -7715,6 +8262,10 @@ function checkLayer2Context(pattern, actionHistory, actionDetail) {
   return true;
 }
 
+// src/engine/coordinator.ts
+init_asset_dir();
+init_runtime_config_bridge();
+
 // src/engine/formal-engine/index.ts
 init_esm_shims();
 
@@ -8684,20 +9235,69 @@ function matchesAny(cmd, patterns) {
 }
 var _brainStore = null;
 var _brainExtractor = null;
+var _brainSkillManager = null;
+var _brainCurator = null;
 var _brainInitialized = false;
-function getBrainStore() {
+var _brainLastMaintenance = 0;
+var BRAIN_MAINT_INTERVAL_MS = 3e5;
+function getBrainStore(osType) {
   if (!isBrainEnabled()) return null;
   if (!_brainInitialized) {
     _brainStore = new BrainRuleStore();
-    _brainExtractor = new PatternExtractor(_brainStore, { review: createBrainReviewer() });
+    const skillsDir = resolveAssetDir(__dirname, "skills");
+    _brainSkillManager = skillsDir ? new BrainSkillManager(skillsDir) : null;
+    _brainExtractor = new PatternExtractor(_brainStore, {
+      review: createBrainReviewer(),
+      // 内置规则去重集（对齐 Python coordinator._ensure_brain 收集的 builtin_patterns）：
+      // 危险命令正则 + 敏感路径（deny_* 或 credential）。
+      // 历史 bug：TS 这里只传 review，不传 builtinPatterns → 提取器拿不到内置规则，
+      // `isCoveredByBuiltin` 恒 False → 把 L1/L2 本来就能拦的案例重复沉淀成 Brain 规则。
+      builtinPatterns: collectBrainBuiltinPatterns(osType),
+      skillManager: _brainSkillManager
+    });
+    if (_brainSkillManager) {
+      _brainCurator = new BrainCurator(_brainStore, _brainSkillManager);
+    }
     _brainInitialized = true;
   }
+  const now = Date.now();
+  if (_brainCurator && now - _brainLastMaintenance >= BRAIN_MAINT_INTERVAL_MS) {
+    try {
+      _brainCurator.runMaintenance({ autoApprove: true });
+    } catch {
+    }
+    _brainLastMaintenance = now;
+  }
   return _brainStore;
 }
+function collectBrainBuiltinPatterns(osType) {
+  const bridge = runtimeConfigBridge.current;
+  if (!bridge) return [];
+  const out = [];
+  try {
+    for (const cp of bridge.effectiveDangerousPatterns(osType)) {
+      if (cp?.pattern?.source) out.push(cp.pattern.source);
+    }
+  } catch {
+  }
+  try {
+    for (const sp of bridge.effectiveSensitivePaths(osType)) {
+      const denyMode = String(sp?.denyMode || "");
+      if (["deny_both", "deny_write", "deny_read"].includes(denyMode) || sp?.credential) {
+        if (sp?.path) out.push(sp.path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+      }
+    }
+  } catch {
+  }
+  return out.filter(Boolean);
+}
 function _resetBrainForTest() {
   _brainStore = null;
   _brainExtractor = null;
+  _brainSkillManager = null;
+  _brainCurator = null;
   _brainInitialized = false;
+  _brainLastMaintenance = 0;
 }
 var formalEngine = new FormalEngine();
 async function runAnalysis(input) {
@@ -8750,7 +9350,7 @@ async function runAnalysis(input) {
       }
     }
   }
-  const brainStore = getBrainStore();
+  const brainStore = getBrainStore(input.osType);
   if (brainStore) {
     const brainL1 = checkBrainRules(brainStore, {
       layer: 1,