bazilion 0.6.0 → 0.8.0

package/dist/daemon.js

@@ -12518,11 +12518,11 @@ var require_util = __commonJS({
       return false;
     }
     exports.schemaHasRules = schemaHasRules;
-    function schemaHasRulesButRef(schema, RULES) {
+    function schemaHasRulesButRef(schema, RULES2) {
       if (typeof schema == "boolean")
         return !schema;
       for (const key2 in schema)
-        if (key2 !== "$ref" && RULES.all[key2])
+        if (key2 !== "$ref" && RULES2.all[key2])
           return true;
       return false;
     }
@@ -13916,17 +13916,17 @@ var require_validate = __commonJS({
     }
     function schemaKeywords(it, types, typeErrors, errsCount) {
       const { gen, schema, data, allErrors, opts, self } = it;
-      const { RULES } = self;
-      if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
-        gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
+      const { RULES: RULES2 } = self;
+      if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES2))) {
+        gen.block(() => keywordCode(it, "$ref", RULES2.all.$ref.definition));
         return;
       }
       if (!opts.jtd)
         checkStrictTypes(it, types);
       gen.block(() => {
-        for (const group of RULES.rules)
+        for (const group of RULES2.rules)
           groupKeywords(group);
-        groupKeywords(RULES.post);
+        groupKeywords(RULES2.post);
       });
       function groupKeywords(group) {
         if (!(0, applicability_1.shouldUseGroup)(schema, group))
@@ -15715,10 +15715,10 @@ var require_core = __commonJS({
       }
       // Remove keyword
       removeKeyword(keyword) {
-        const { RULES } = this;
-        delete RULES.keywords[keyword];
-        delete RULES.all[keyword];
-        for (const group of RULES.rules) {
+        const { RULES: RULES2 } = this;
+        delete RULES2.keywords[keyword];
+        delete RULES2.all[keyword];
+        for (const group of RULES2.rules) {
           const i = group.rules.findIndex((rule) => rule.keyword === keyword);
           if (i >= 0)
             group.rules.splice(i, 1);
@@ -15886,9 +15886,9 @@ var require_core = __commonJS({
     }
     var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
     function checkKeyword(keyword, def) {
-      const { RULES } = this;
+      const { RULES: RULES2 } = this;
       (0, util_1.eachItem)(keyword, (kwd) => {
-        if (RULES.keywords[kwd])
+        if (RULES2.keywords[kwd])
           throw new Error(`Keyword ${kwd} is already defined`);
         if (!KEYWORD_NAME.test(kwd))
           throw new Error(`Keyword ${kwd} has invalid name`);
@@ -15904,13 +15904,13 @@ var require_core = __commonJS({
       const post = definition === null || definition === void 0 ? void 0 : definition.post;
       if (dataType && post)
         throw new Error('keyword with "post" flag cannot have "type"');
-      const { RULES } = this;
-      let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
+      const { RULES: RULES2 } = this;
+      let ruleGroup = post ? RULES2.post : RULES2.rules.find(({ type: t }) => t === dataType);
       if (!ruleGroup) {
         ruleGroup = { type: dataType, rules: [] };
-        RULES.rules.push(ruleGroup);
+        RULES2.rules.push(ruleGroup);
       }
-      RULES.keywords[keyword] = true;
+      RULES2.keywords[keyword] = true;
       if (!definition)
         return;
       const rule = {
@@ -15925,7 +15925,7 @@ var require_core = __commonJS({
         addBeforeRule.call(this, ruleGroup, rule, definition.before);
       else
         ruleGroup.rules.push(rule);
-      RULES.all[keyword] = rule;
+      RULES2.all[keyword] = rule;
       (_a3 = definition.implements) === null || _a3 === void 0 ? void 0 : _a3.forEach((kwd) => this.addKeyword(kwd));
     }
     function addBeforeRule(ruleGroup, rule, before) {
@@ -20747,9 +20747,16 @@ var SERVICES = [
     id: "moonshotai",
     displayName: "Moonshot AI",
     category: "provider",
-    hint: "Kimi K2/K2.5/K2.6 \xB7 platform.moonshot.ai",
+    hint: "Kimi K2/K2.5/K2.6/K2.7 \xB7 platform.moonshot.ai",
     fields: [{ envVar: "MOONSHOT_API_KEY", kind: "secret", label: "API key" }]
   },
+  {
+    id: "moonshotai-cn",
+    displayName: "Moonshot AI (CN)",
+    category: "provider",
+    hint: "Kimi models via the China endpoint \xB7 platform.moonshot.cn",
+    fields: [{ envVar: "MOONSHOT_CN_API_KEY", kind: "secret", label: "API key" }]
+  },
   {
     id: "kimi-coding",
     displayName: "Kimi Coding",
@@ -20761,9 +20768,16 @@ var SERVICES = [
     id: "minimax",
     displayName: "MiniMax",
     category: "provider",
-    hint: "MiniMax M2 family \xB7 platform.minimaxi.com",
+    hint: "MiniMax M2/M3 family \xB7 platform.minimaxi.com",
     fields: [{ envVar: "MINIMAX_API_KEY", kind: "secret", label: "API key" }]
   },
+  {
+    id: "minimax-cn",
+    displayName: "MiniMax (CN)",
+    category: "provider",
+    hint: "MiniMax M2/M3 family via the China endpoint",
+    fields: [{ envVar: "MINIMAX_CN_API_KEY", kind: "secret", label: "API key" }]
+  },
   {
     id: "xiaomi",
     displayName: "Xiaomi MiMo",
@@ -20771,12 +20785,54 @@ var SERVICES = [
     hint: "API billing endpoint \xB7 platform.xiaomimimo.com",
     fields: [{ envVar: "XIAOMI_API_KEY", kind: "secret", label: "API key" }]
   },
+  {
+    id: "xiaomi-token-plan-ams",
+    displayName: "Xiaomi MiMo Token Plan (AMS)",
+    category: "provider",
+    hint: "MiMo token-plan endpoint in Amsterdam",
+    fields: [{ envVar: "XIAOMI_TOKEN_PLAN_AMS_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "xiaomi-token-plan-cn",
+    displayName: "Xiaomi MiMo Token Plan (CN)",
+    category: "provider",
+    hint: "MiMo token-plan endpoint in China",
+    fields: [{ envVar: "XIAOMI_TOKEN_PLAN_CN_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "xiaomi-token-plan-sgp",
+    displayName: "Xiaomi MiMo Token Plan (SGP)",
+    category: "provider",
+    hint: "MiMo token-plan endpoint in Singapore",
+    fields: [{ envVar: "XIAOMI_TOKEN_PLAN_SGP_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "ant-ling",
+    displayName: "Ant Ling",
+    category: "provider",
+    hint: "Ling/Ring models \xB7 api.ant-ling.com",
+    fields: [{ envVar: "ANT_LING_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "nvidia",
+    displayName: "NVIDIA NIM",
+    category: "provider",
+    hint: "NVIDIA hosted models \xB7 build.nvidia.com",
+    fields: [{ envVar: "NVIDIA_API_KEY", kind: "secret", label: "API key" }]
+  },
   {
     id: "zai",
     displayName: "zAI",
     category: "provider",
     fields: [{ envVar: "ZAI_API_KEY", kind: "secret", label: "API key" }]
   },
+  {
+    id: "zai-coding-cn",
+    displayName: "zAI Coding (CN)",
+    category: "provider",
+    hint: "GLM coding endpoint \xB7 open.bigmodel.cn",
+    fields: [{ envVar: "ZAI_CODING_CN_API_KEY", kind: "secret", label: "API key" }]
+  },
   {
     id: "huggingface",
     displayName: "Hugging Face",
@@ -20835,6 +20891,13 @@ var SERVICES = [
     hint: "OpenAI-compatible proxy from the OpenCode CLI",
     fields: [{ envVar: "OPENCODE_API_KEY", kind: "secret", label: "API key" }]
   },
+  {
+    id: "opencode-go",
+    displayName: "OpenCode Go",
+    category: "provider",
+    hint: "OpenCode hosted Go endpoint",
+    fields: [{ envVar: "OPENCODE_GO_API_KEY", kind: "secret", label: "API key" }]
+  },
   {
     id: "lmstudio",
     displayName: "LM Studio",
@@ -21675,7 +21738,74 @@ function parseSkillFile(path) {
   return parseSkillContent(raw);
 }
 
+// ../daemon/src/core/skills/scan.ts
+var SECRET_ENV_RE = /\b(ANTHROPIC_API_KEY|OPENAI_API_KEY|OPENAI_CODEX_OAUTH|GEMINI_API_KEY|GOOGLE_API_KEY|AWS_ACCESS_KEY_ID|AWS_SECRET_ACCESS_KEY|AZURE_OPENAI_API_KEY|MISTRAL_API_KEY|GROQ_API_KEY|BRAVE_API_KEY|SEARXNG_URL)\b/i;
+var SENSITIVE_PATH_RE = /(~\/\.(ssh|aws|gnupg|config)|\b(auth\.json|bazilion\.db)\b)/i;
+var SECRET_TARGET_RE = /(secret|credential|token|api[-_\s]?key|env(?:ironment)?(?: variable)?|private key|ssh key|auth\.json|bazilion\.db|~\/\.(ssh|aws|gnupg))/i;
+var EXFIL_VERB_RE = /(exfiltrat|send|upload|post|curl|webhook|pastebin|remote server|external server|http endpoint)/i;
+var UNICODE_STEALTH_RE = /[\u200B-\u200F\u202A-\u202E\u2060-\u206F\uFEFF]/;
+var RULES = [
+  {
+    code: "sensitive-reference",
+    severity: "danger",
+    message: "Mentions a sensitive path, database, auth file, or credential environment variable.",
+    test: (line) => SENSITIVE_PATH_RE.test(line) || SECRET_ENV_RE.test(line)
+  },
+  {
+    code: "secret-exfiltration",
+    severity: "danger",
+    message: "Combines secret/env/file access with exfiltration-style language.",
+    test: (line) => SECRET_TARGET_RE.test(line) && EXFIL_VERB_RE.test(line)
+  },
+  {
+    code: "instruction-hijack",
+    severity: "danger",
+    message: "Contains instruction-hijacking language such as ignoring prior instructions.",
+    test: (line) => /ignore (all )?(previous|prior|system|developer|user) instructions/i.test(line) || /override (the )?(system|developer) (prompt|instructions)/i.test(line) || /bypass (safety|security|policy|guardrails)/i.test(line) || /you are now (root|unrestricted|in developer mode)/i.test(line)
+  },
+  {
+    code: "unicode-stealth",
+    severity: "warning",
+    message: "Contains zero-width, bidi, or byte-order characters that can hide prompt text.",
+    test: (line) => UNICODE_STEALTH_RE.test(line)
+  }
+];
+function addFinding(findings, seen, finding) {
+  const key2 = `${finding.code}:${finding.line ?? 0}`;
+  if (seen.has(key2)) return;
+  seen.add(key2);
+  findings.push(finding);
+}
+function scanSkillContent(raw) {
+  const findings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = raw.split(/\r?\n/);
+  lines.forEach((line, index) => {
+    for (const rule of RULES) {
+      if (!rule.test(line)) continue;
+      addFinding(findings, seen, {
+        code: rule.code,
+        severity: rule.severity,
+        message: rule.message,
+        line: index + 1
+      });
+    }
+  });
+  return findings;
+}
+
 // ../daemon/src/core/skills/import.ts
+var SkillScanBlockedError = class extends Error {
+  findings;
+  constructor(findings) {
+    const names = Object.keys(findings).sort();
+    super(
+      `skill scan blocked import: ${names.join(", ")} ${names.length === 1 ? "has" : "have"} findings (rerun with --force to confirm)`
+    );
+    this.name = "SkillScanBlockedError";
+    this.findings = findings;
+  }
+};
 function extractZipSafely(zipPath) {
   const root = mkdtempSync(join10(tmpdir(), "bazilion-skill-zip-"));
   try {
@@ -21742,8 +21872,14 @@ function importSkillsFromDir(paths, source, input) {
   if (candidates.length === 0) {
     throw new Error(`no skills found in ${source}`);
   }
+  const findingsBySkill = {};
   for (const c of candidates) {
-    parseSkillFile(join10(c.dir, "SKILL.md"));
+    const parsed = parseSkillFile(join10(c.dir, "SKILL.md"));
+    const findings = scanSkillContent(parsed.raw);
+    if (findings.length > 0) findingsBySkill[c.name] = findings;
+  }
+  if (Object.keys(findingsBySkill).length > 0 && !input.force) {
+    throw new SkillScanBlockedError(findingsBySkill);
   }
   const imported = [];
   const skipped = [];
@@ -21752,14 +21888,19 @@ function importSkillsFromDir(paths, source, input) {
     if (existsSync8(target) && !input.force) {
       skipped.push({
         name: c.name,
-        reason: "already exists (use --force to overwrite)"
+        reason: "already exists (use --force to overwrite)",
+        findings: findingsBySkill[c.name]
       });
       continue;
     }
     cpSync(c.dir, target, { recursive: true, force: !!input.force });
     imported.push(c.name);
   }
-  return { imported, skipped };
+  return {
+    imported,
+    skipped,
+    findings: Object.keys(findingsBySkill).length > 0 ? findingsBySkill : void 0
+  };
 }
 
 // ../daemon/src/core/skills/resolve.ts
@@ -22488,10 +22629,25 @@ function loadProviderConfigFromEnv(env = process.env, oauth) {
   if (env.FIREWORKS_API_KEY) config2.fireworks = { apiKey: env.FIREWORKS_API_KEY };
   if (env.TOGETHER_API_KEY) config2.together = { apiKey: env.TOGETHER_API_KEY };
   if (env.MOONSHOT_API_KEY) config2.moonshotai = { apiKey: env.MOONSHOT_API_KEY };
+  if (env.MOONSHOT_CN_API_KEY) config2.moonshotaiCn = { apiKey: env.MOONSHOT_CN_API_KEY };
   if (env.KIMI_API_KEY) config2.kimiCoding = { apiKey: env.KIMI_API_KEY };
   if (env.MINIMAX_API_KEY) config2.minimax = { apiKey: env.MINIMAX_API_KEY };
+  if (env.MINIMAX_CN_API_KEY) config2.minimaxCn = { apiKey: env.MINIMAX_CN_API_KEY };
   if (env.XIAOMI_API_KEY) config2.xiaomi = { apiKey: env.XIAOMI_API_KEY };
+  if (env.XIAOMI_TOKEN_PLAN_AMS_API_KEY) {
+    config2.xiaomiTokenPlanAms = { apiKey: env.XIAOMI_TOKEN_PLAN_AMS_API_KEY };
+  }
+  if (env.XIAOMI_TOKEN_PLAN_CN_API_KEY) {
+    config2.xiaomiTokenPlanCn = { apiKey: env.XIAOMI_TOKEN_PLAN_CN_API_KEY };
+  }
+  if (env.XIAOMI_TOKEN_PLAN_SGP_API_KEY) {
+    config2.xiaomiTokenPlanSgp = { apiKey: env.XIAOMI_TOKEN_PLAN_SGP_API_KEY };
+  }
+  if (env.ANT_LING_API_KEY) config2.antLing = { apiKey: env.ANT_LING_API_KEY };
+  if (env.NVIDIA_API_KEY) config2.nvidia = { apiKey: env.NVIDIA_API_KEY };
   if (env.OPENCODE_API_KEY) config2.opencode = { apiKey: env.OPENCODE_API_KEY };
+  if (env.OPENCODE_GO_API_KEY) config2.opencodeGo = { apiKey: env.OPENCODE_GO_API_KEY };
+  if (env.ZAI_CODING_CN_API_KEY) config2.zaiCodingCn = { apiKey: env.ZAI_CODING_CN_API_KEY };
   if (env.COPILOT_GITHUB_TOKEN) config2.githubCopilot = { apiKey: env.COPILOT_GITHUB_TOKEN };
   if (env.CLOUDFLARE_API_KEY && env.CLOUDFLARE_ACCOUNT_ID) {
     config2.cloudflareWorkersAi = {
@@ -22704,6 +22860,16 @@ var PROVIDERS = {
     }),
     hint: "MOONSHOT_API_KEY"
   },
+  "moonshotai-cn": {
+    configured: (c) => !!c.moonshotaiCn,
+    build: (c) => piProvider({
+      providerName: "moonshotai-cn",
+      fallbackApi: "openai-completions",
+      apiKey: c.moonshotaiCn?.apiKey,
+      baseUrl: c.moonshotaiCn?.baseURL
+    }),
+    hint: "MOONSHOT_CN_API_KEY"
+  },
   "kimi-coding": {
     configured: (c) => !!c.kimiCoding,
     build: (c) => piProvider({
@@ -22724,6 +22890,16 @@ var PROVIDERS = {
     }),
     hint: "MINIMAX_API_KEY"
   },
+  "minimax-cn": {
+    configured: (c) => !!c.minimaxCn,
+    build: (c) => piProvider({
+      providerName: "minimax-cn",
+      fallbackApi: "anthropic-messages",
+      apiKey: c.minimaxCn?.apiKey,
+      baseUrl: c.minimaxCn?.baseURL
+    }),
+    hint: "MINIMAX_CN_API_KEY"
+  },
   xiaomi: {
     configured: (c) => !!c.xiaomi,
     build: (c) => piProvider({
@@ -22734,6 +22910,56 @@ var PROVIDERS = {
     }),
     hint: "XIAOMI_API_KEY"
   },
+  "xiaomi-token-plan-ams": {
+    configured: (c) => !!c.xiaomiTokenPlanAms,
+    build: (c) => piProvider({
+      providerName: "xiaomi-token-plan-ams",
+      fallbackApi: "openai-completions",
+      apiKey: c.xiaomiTokenPlanAms?.apiKey,
+      baseUrl: c.xiaomiTokenPlanAms?.baseURL
+    }),
+    hint: "XIAOMI_TOKEN_PLAN_AMS_API_KEY"
+  },
+  "xiaomi-token-plan-cn": {
+    configured: (c) => !!c.xiaomiTokenPlanCn,
+    build: (c) => piProvider({
+      providerName: "xiaomi-token-plan-cn",
+      fallbackApi: "openai-completions",
+      apiKey: c.xiaomiTokenPlanCn?.apiKey,
+      baseUrl: c.xiaomiTokenPlanCn?.baseURL
+    }),
+    hint: "XIAOMI_TOKEN_PLAN_CN_API_KEY"
+  },
+  "xiaomi-token-plan-sgp": {
+    configured: (c) => !!c.xiaomiTokenPlanSgp,
+    build: (c) => piProvider({
+      providerName: "xiaomi-token-plan-sgp",
+      fallbackApi: "openai-completions",
+      apiKey: c.xiaomiTokenPlanSgp?.apiKey,
+      baseUrl: c.xiaomiTokenPlanSgp?.baseURL
+    }),
+    hint: "XIAOMI_TOKEN_PLAN_SGP_API_KEY"
+  },
+  "ant-ling": {
+    configured: (c) => !!c.antLing,
+    build: (c) => piProvider({
+      providerName: "ant-ling",
+      fallbackApi: "openai-completions",
+      apiKey: c.antLing?.apiKey,
+      baseUrl: c.antLing?.baseURL
+    }),
+    hint: "ANT_LING_API_KEY"
+  },
+  nvidia: {
+    configured: (c) => !!c.nvidia,
+    build: (c) => piProvider({
+      providerName: "nvidia",
+      fallbackApi: "openai-completions",
+      apiKey: c.nvidia?.apiKey,
+      baseUrl: c.nvidia?.baseURL
+    }),
+    hint: "NVIDIA_API_KEY"
+  },
   opencode: {
     configured: (c) => !!c.opencode,
     build: (c) => piProvider({
@@ -22744,6 +22970,26 @@ var PROVIDERS = {
     }),
     hint: "OPENCODE_API_KEY"
   },
+  "opencode-go": {
+    configured: (c) => !!c.opencodeGo,
+    build: (c) => piProvider({
+      providerName: "opencode-go",
+      fallbackApi: "openai-completions",
+      apiKey: c.opencodeGo?.apiKey,
+      baseUrl: c.opencodeGo?.baseURL
+    }),
+    hint: "OPENCODE_GO_API_KEY"
+  },
+  "zai-coding-cn": {
+    configured: (c) => !!c.zaiCodingCn,
+    build: (c) => piProvider({
+      providerName: "zai-coding-cn",
+      fallbackApi: "openai-completions",
+      apiKey: c.zaiCodingCn?.apiKey,
+      baseUrl: c.zaiCodingCn?.baseURL
+    }),
+    hint: "ZAI_CODING_CN_API_KEY"
+  },
   "github-copilot": {
     configured: (c) => !!c.githubCopilot,
     build: (c) => piProvider({
@@ -24425,6 +24671,22 @@ function liveEndpointFor(providerName, env) {
       return "https://api.x.ai/v1";
     case "mistral":
       return "https://api.mistral.ai/v1";
+    case "ant-ling":
+      return "https://api.ant-ling.com/v1";
+    case "moonshotai-cn":
+      return "https://api.moonshot.cn/v1";
+    case "nvidia":
+      return "https://integrate.api.nvidia.com/v1";
+    case "opencode-go":
+      return "https://opencode.ai/zen/go/v1";
+    case "xiaomi-token-plan-ams":
+      return "https://token-plan-ams.xiaomimimo.com/v1";
+    case "xiaomi-token-plan-cn":
+      return "https://token-plan-cn.xiaomimimo.com/v1";
+    case "xiaomi-token-plan-sgp":
+      return "https://token-plan-sgp.xiaomimimo.com/v1";
+    case "zai-coding-cn":
+      return "https://open.bigmodel.cn/api/coding/paas/v4";
     default:
       return null;
   }
@@ -24470,6 +24732,22 @@ function apiKeyFor(providerName, env) {
       return env.XAI_API_KEY;
     case "mistral":
       return env.MISTRAL_API_KEY;
+    case "ant-ling":
+      return env.ANT_LING_API_KEY;
+    case "moonshotai-cn":
+      return env.MOONSHOT_CN_API_KEY;
+    case "nvidia":
+      return env.NVIDIA_API_KEY;
+    case "opencode-go":
+      return env.OPENCODE_GO_API_KEY;
+    case "xiaomi-token-plan-ams":
+      return env.XIAOMI_TOKEN_PLAN_AMS_API_KEY;
+    case "xiaomi-token-plan-cn":
+      return env.XIAOMI_TOKEN_PLAN_CN_API_KEY;
+    case "xiaomi-token-plan-sgp":
+      return env.XIAOMI_TOKEN_PLAN_SGP_API_KEY;
+    case "zai-coding-cn":
+      return env.ZAI_CODING_CN_API_KEY;
     default:
       return void 0;
   }
@@ -25510,7 +25788,7 @@ function shouldNotifyInboundThrottle(agentId) {
   return true;
 }
 
-// ../../node_modules/.pnpm/marked@18.0.4/node_modules/marked/lib/marked.esm.js
+// ../../node_modules/.pnpm/marked@18.0.5/node_modules/marked/lib/marked.esm.js
 function M() {
   return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null };
 }
@@ -25554,15 +25832,15 @@ var F = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table|
 var $e = /^[^\n]+/;
 var U = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/;
 var Le = d(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", U).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
-var _e = d(/^(bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, j).getRegex();
+var _e = d(/^(bull)([ \t][^\n]*?)?(?:\n|$)/).replace(/bull/g, j).getRegex();
 var H = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
 var K = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
 var ze = d("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$))", "i").replace("comment", K).replace("tag", H).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
-var le = d(F).replace("hr", B).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", H).getRegex();
+var le = d(F).replace("hr", B).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]+[^ \\t\\n]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", H).getRegex();
 var Me = d(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", le).getRegex();
 var W = { blockquote: Me, code: we, def: Le, fences: ye, heading: Pe, hr: B, html: ze, lheading: ae, list: _e, newline: Oe, paragraph: le, table: _, text: $e };
 var se = d("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", B).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}	)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", H).getRegex();
-var Ee = { ...W, lheading: Se, table: se, paragraph: d(F).replace("hr", B).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", se).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", H).getRegex() };
+var Ee = { ...W, lheading: Se, table: se, paragraph: d(F).replace("hr", B).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", se).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]+[^ \\t\\n]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", H).getRegex() };
 var Ie = { ...W, html: d(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", K).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, heading: /^(#{1,6})(.*)(?:\n+|$)/, fences: _, lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, paragraph: d(F).replace("hr", B).replace("heading", ` *#{1,6} *[^
 ]`).replace("lheading", ae).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() };
 var Ae = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
@@ -29758,7 +30036,8 @@ agentsRouter.get("/:id/skills", (c) => {
         name: s.name,
         description: s.parsed.frontmatter.description,
         source: meta2?.source ?? null,
-        importedAt: meta2?.importedAt ?? null
+        importedAt: meta2?.importedAt ?? null,
+        scanFindings: scanSkillContent(s.parsed.raw)
       };
     }),
     missing: set.missing
@@ -29773,6 +30052,24 @@ agentsRouter.post("/:id/skills", async (c) => {
   const { db, paths, authToken } = getCtx();
   const agent = agents_exports.get(db, c.req.param("id"));
   if (!agent) return c.json({ error: `agent not found: ${c.req.param("id")}` }, 404);
+  const discovered = discoverSkills(paths).find((s) => s.name === body.skill);
+  if (discovered) {
+    try {
+      const parsed = parseSkillFile(discovered.skillFile);
+      const findings = scanSkillContent(parsed.raw);
+      if (findings.length > 0 && !body.allowFindings) {
+        return c.json(
+          {
+            error: `skill scan blocked attach: ${body.skill} has findings`,
+            code: "skill_scan_blocked",
+            findings
+          },
+          400
+        );
+      }
+    } catch {
+    }
+  }
   agents_exports.attachSkill(db, agent.id, body.skill);
   return c.body(null, 204);
 });
@@ -31291,6 +31588,7 @@ skillsRouter.get("/", (c) => {
     try {
       const parsed = parseSkillFile(s.skillFile);
       entry.description = parsed.frontmatter.description;
+      entry.scanFindings = scanSkillContent(parsed.raw);
     } catch (err) {
       entry.parseError = err.message;
     }
@@ -31321,14 +31619,36 @@ skillsRouter.post("/import", async (c) => {
     for (const name of result.imported) {
       skillMeta_exports.upsert(db, { name, source: input.sourceLabel, importedAt: now });
     }
-    const res = { imported: result.imported, skipped: result.skipped };
+    const res = {
+      imported: result.imported,
+      skipped: result.skipped,
+      findings: result.findings
+    };
     return c.json(res);
   } catch (err) {
+    if (err instanceof SkillScanBlockedError) {
+      return c.json(
+        {
+          error: err.message,
+          code: "skill_scan_blocked",
+          findings: flattenFindings(err.findings)
+        },
+        400
+      );
+    }
     return c.json({ error: err.message }, 400);
   } finally {
     if (input.tempZipPath) rmSync10(input.tempZipPath, { recursive: true, force: true });
   }
 });
+function flattenFindings(findings) {
+  return Object.entries(findings).flatMap(
+    ([name, items]) => items.map((item) => ({
+      ...item,
+      message: `${name}: ${item.message}`
+    }))
+  );
+}
 async function parseImportInput(request) {
   const contentType = request.headers.get("content-type") ?? "";
   if (contentType.startsWith("multipart/form-data")) {