vet-skills 0.6.0 → 0.7.0

package/dist/index.js

@@ -111,7 +111,7 @@ var require_visit = __commonJS({
     "use strict";
     var identity = require_identity();
     var BREAK = /* @__PURE__ */ Symbol("break visit");
-    var SKIP2 = /* @__PURE__ */ Symbol("skip children");
+    var SKIP3 = /* @__PURE__ */ Symbol("skip children");
     var REMOVE = /* @__PURE__ */ Symbol("remove node");
     function visit(node, visitor) {
       const visitor_ = initVisitor(visitor);
@@ -123,7 +123,7 @@ var require_visit = __commonJS({
         visit_(null, node, visitor_, Object.freeze([]));
     }
     visit.BREAK = BREAK;
-    visit.SKIP = SKIP2;
+    visit.SKIP = SKIP3;
     visit.REMOVE = REMOVE;
     function visit_(key, node, visitor, path) {
       const ctrl = callVisitor(key, node, visitor, path);
@@ -171,7 +171,7 @@ var require_visit = __commonJS({
         await visitAsync_(null, node, visitor_, Object.freeze([]));
     }
     visitAsync.BREAK = BREAK;
-    visitAsync.SKIP = SKIP2;
+    visitAsync.SKIP = SKIP3;
     visitAsync.REMOVE = REMOVE;
     async function visitAsync_(key, node, visitor, path) {
       const ctrl = await callVisitor(key, node, visitor, path);
@@ -995,13 +995,13 @@ var require_Collection = __commonJS({
 var require_stringifyComment = __commonJS({
   "../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/stringify/stringifyComment.js"(exports) {
     "use strict";
-    var stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, "#");
+    var stringifyComment = (str2) => str2.replace(/^(?!$)(?: $)?/gm, "#");
     function indentComment(comment, indent) {
       if (/^\n+$/.test(comment))
         return comment.substring(1);
       return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;
     }
-    var lineComment = (str, indent, comment) => str.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str.endsWith(" ") ? "" : " ") + comment;
+    var lineComment = (str2, indent, comment) => str2.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str2.endsWith(" ") ? "" : " ") + comment;
     exports.indentComment = indentComment;
     exports.lineComment = lineComment;
     exports.stringifyComment = stringifyComment;
@@ -1155,16 +1155,16 @@ var require_stringifyString = __commonJS({
       lineWidth: ctx.options.lineWidth,
       minContentWidth: ctx.options.minContentWidth
     });
-    var containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str);
-    function lineLengthOverLimit(str, lineWidth, indentLength) {
+    var containsDocumentMarker = (str2) => /^(%|---|\.\.\.)/m.test(str2);
+    function lineLengthOverLimit(str2, lineWidth, indentLength) {
       if (!lineWidth || lineWidth < 0)
         return false;
       const limit = lineWidth - indentLength;
-      const strLen = str.length;
+      const strLen = str2.length;
       if (strLen <= limit)
         return false;
       for (let i = 0, start = 0; i < strLen; ++i) {
-        if (str[i] === "\n") {
+        if (str2[i] === "\n") {
           if (i - start > limit)
             return true;
           start = i + 1;
@@ -1181,11 +1181,11 @@ var require_stringifyString = __commonJS({
       const { implicitKey } = ctx;
       const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;
       const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
-      let str = "";
+      let str2 = "";
       let start = 0;
       for (let i = 0, ch = json[i]; ch; ch = json[++i]) {
         if (ch === " " && json[i + 1] === "\\" && json[i + 2] === "n") {
-          str += json.slice(start, i) + "\\ ";
+          str2 += json.slice(start, i) + "\\ ";
           i += 1;
           start = i;
           ch = "\\";
@@ -1194,38 +1194,38 @@ var require_stringifyString = __commonJS({
           switch (json[i + 1]) {
             case "u":
               {
-                str += json.slice(start, i);
+                str2 += json.slice(start, i);
                 const code = json.substr(i + 2, 4);
                 switch (code) {
                   case "0000":
-                    str += "\\0";
+                    str2 += "\\0";
                     break;
                   case "0007":
-                    str += "\\a";
+                    str2 += "\\a";
                     break;
                   case "000b":
-                    str += "\\v";
+                    str2 += "\\v";
                     break;
                   case "001b":
-                    str += "\\e";
+                    str2 += "\\e";
                     break;
                   case "0085":
-                    str += "\\N";
+                    str2 += "\\N";
                     break;
                   case "00a0":
-                    str += "\\_";
+                    str2 += "\\_";
                     break;
                   case "2028":
-                    str += "\\L";
+                    str2 += "\\L";
                     break;
                   case "2029":
-                    str += "\\P";
+                    str2 += "\\P";
                     break;
                   default:
                     if (code.substr(0, 2) === "00")
-                      str += "\\x" + code.substr(2);
+                      str2 += "\\x" + code.substr(2);
                     else
-                      str += json.substr(i, 6);
+                      str2 += json.substr(i, 6);
                 }
                 i += 5;
                 start = i + 1;
@@ -1235,14 +1235,14 @@ var require_stringifyString = __commonJS({
               if (implicitKey || json[i + 2] === '"' || json.length < minMultiLineLength) {
                 i += 1;
               } else {
-                str += json.slice(start, i) + "\n\n";
+                str2 += json.slice(start, i) + "\n\n";
                 while (json[i + 2] === "\\" && json[i + 3] === "n" && json[i + 4] !== '"') {
-                  str += "\n";
+                  str2 += "\n";
                   i += 2;
                 }
-                str += indent;
+                str2 += indent;
                 if (json[i + 2] === " ")
-                  str += "\\";
+                  str2 += "\\";
                 i += 1;
                 start = i + 1;
               }
@@ -1251,8 +1251,8 @@ var require_stringifyString = __commonJS({
               i += 1;
           }
       }
-      str = start ? str + json.slice(start) : json;
-      return implicitKey ? str : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx, false));
+      str2 = start ? str2 + json.slice(start) : json;
+      return implicitKey ? str2 : foldFlowLines.foldFlowLines(str2, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx, false));
     }
     function singleQuotedString(value, ctx) {
       if (ctx.options.singleQuote === false || ctx.implicitKey && value.includes("\n") || /[ \t]\n|\n[ \t]/.test(value))
@@ -1380,15 +1380,15 @@ ${indent}${start}${value}${end}`;
           return quotedString(value, ctx);
         }
       }
-      const str = value.replace(/\n+/g, `$&
+      const str2 = value.replace(/\n+/g, `$&
 ${indent}`);
       if (actualString) {
-        const test = (tag) => tag.default && tag.tag !== "tag:yaml.org,2002:str" && tag.test?.test(str);
+        const test = (tag) => tag.default && tag.tag !== "tag:yaml.org,2002:str" && tag.test?.test(str2);
         const { compat, tags } = ctx.doc.schema;
         if (tags.some(test) || compat?.some(test))
           return quotedString(value, ctx);
       }
-      return implicitKey ? str : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false));
+      return implicitKey ? str2 : foldFlowLines.foldFlowLines(str2, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false));
     }
     function stringifyString(item, ctx, onComment, onChompKeep) {
       const { implicitKey, inFlow } = ctx;
@@ -1540,11 +1540,11 @@ var require_stringify = __commonJS({
       const props = stringifyProps(node, tagObj, ctx);
       if (props.length > 0)
         ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;
-      const str = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : identity.isScalar(node) ? stringifyString.stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
+      const str2 = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : identity.isScalar(node) ? stringifyString.stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
       if (!props)
-        return str;
-      return identity.isScalar(node) || str[0] === "{" || str[0] === "[" ? `${props} ${str}` : `${props}
-${ctx.indent}${str}`;
+        return str2;
+      return identity.isScalar(node) || str2[0] === "{" || str2[0] === "[" ? `${props} ${str2}` : `${props}
+${ctx.indent}${str2}`;
     }
     exports.createStringifyContext = createStringifyContext;
     exports.stringify = stringify;
@@ -1579,8 +1579,8 @@ var require_stringifyPair = __commonJS({
       });
       let keyCommentDone = false;
       let chompKeep = false;
-      let str = stringify.stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
-      if (!explicitKey && !ctx.inFlow && str.length > 1024) {
+      let str2 = stringify.stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
+      if (!explicitKey && !ctx.inFlow && str2.length > 1024) {
         if (simpleKeys)
           throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
         explicitKey = true;
@@ -1589,27 +1589,27 @@ var require_stringifyPair = __commonJS({
         if (allNullValues || value == null) {
           if (keyCommentDone && onComment)
             onComment();
-          return str === "" ? "?" : explicitKey ? `? ${str}` : str;
+          return str2 === "" ? "?" : explicitKey ? `? ${str2}` : str2;
         }
       } else if (allNullValues && !simpleKeys || value == null && explicitKey) {
-        str = `? ${str}`;
+        str2 = `? ${str2}`;
         if (keyComment && !keyCommentDone) {
-          str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
+          str2 += stringifyComment.lineComment(str2, ctx.indent, commentString(keyComment));
         } else if (chompKeep && onChompKeep)
           onChompKeep();
-        return str;
+        return str2;
       }
       if (keyCommentDone)
         keyComment = null;
       if (explicitKey) {
         if (keyComment)
-          str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
-        str = `? ${str}
+          str2 += stringifyComment.lineComment(str2, ctx.indent, commentString(keyComment));
+        str2 = `? ${str2}
 ${indent}:`;
       } else {
-        str = `${str}:`;
+        str2 = `${str2}:`;
         if (keyComment)
-          str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
+          str2 += stringifyComment.lineComment(str2, ctx.indent, commentString(keyComment));
       }
       let vsb, vcb, valueComment;
       if (identity.isNode(value)) {
@@ -1625,7 +1625,7 @@ ${indent}:`;
       }
       ctx.implicitKey = false;
       if (!explicitKey && !keyComment && identity.isScalar(value))
-        ctx.indentAtStart = str.length + 1;
+        ctx.indentAtStart = str2.length + 1;
       chompKeep = false;
       if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && identity.isSeq(value) && !value.flow && !value.tag && !value.anchor) {
         ctx.indent = ctx.indent.substring(2);
@@ -1669,16 +1669,16 @@ ${ctx.indent}`;
       } else if (valueStr === "" || valueStr[0] === "\n") {
         ws = "";
       }
-      str += ws + valueStr;
+      str2 += ws + valueStr;
       if (ctx.inFlow) {
         if (valueCommentDone && onComment)
           onComment();
       } else if (valueComment && !valueCommentDone) {
-        str += stringifyComment.lineComment(str, ctx.indent, commentString(valueComment));
+        str2 += stringifyComment.lineComment(str2, ctx.indent, commentString(valueComment));
       } else if (chompKeep && onChompKeep) {
         onChompKeep();
       }
-      return str;
+      return str2;
     }
     exports.stringifyPair = stringifyPair;
   }
@@ -1905,31 +1905,31 @@ var require_stringifyCollection = __commonJS({
           }
         }
         chompKeep = false;
-        let str2 = stringify.stringify(item, itemCtx, () => comment2 = null, () => chompKeep = true);
+        let str3 = stringify.stringify(item, itemCtx, () => comment2 = null, () => chompKeep = true);
         if (comment2)
-          str2 += stringifyComment.lineComment(str2, itemIndent, commentString(comment2));
+          str3 += stringifyComment.lineComment(str3, itemIndent, commentString(comment2));
         if (chompKeep && comment2)
           chompKeep = false;
-        lines.push(blockItemPrefix + str2);
+        lines.push(blockItemPrefix + str3);
       }
-      let str;
+      let str2;
       if (lines.length === 0) {
-        str = flowChars.start + flowChars.end;
+        str2 = flowChars.start + flowChars.end;
       } else {
-        str = lines[0];
+        str2 = lines[0];
         for (let i = 1; i < lines.length; ++i) {
           const line = lines[i];
-          str += line ? `
+          str2 += line ? `
 ${indent}${line}` : "\n";
         }
       }
       if (comment) {
-        str += "\n" + stringifyComment.indentComment(commentString(comment), indent);
+        str2 += "\n" + stringifyComment.indentComment(commentString(comment), indent);
         if (onComment)
           onComment();
       } else if (chompKeep && onChompKeep)
         onChompKeep();
-      return str;
+      return str2;
     }
     function stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) {
       const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;
@@ -1972,21 +1972,21 @@ ${indent}${line}` : "\n";
         }
         if (comment)
           reqNewline = true;
-        let str = stringify.stringify(item, itemCtx, () => comment = null);
-        reqNewline || (reqNewline = lines.length > linesAtValue || str.includes("\n"));
+        let str2 = stringify.stringify(item, itemCtx, () => comment = null);
+        reqNewline || (reqNewline = lines.length > linesAtValue || str2.includes("\n"));
         if (i < items.length - 1) {
-          str += ",";
+          str2 += ",";
         } else if (ctx.options.trailingComma) {
           if (ctx.options.lineWidth > 0) {
-            reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > ctx.options.lineWidth);
+            reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str2.length + 2) > ctx.options.lineWidth);
           }
           if (reqNewline) {
-            str += ",";
+            str2 += ",";
           }
         }
         if (comment)
-          str += stringifyComment.lineComment(str, itemIndent, commentString(comment));
-        lines.push(str);
+          str2 += stringifyComment.lineComment(str2, itemIndent, commentString(comment));
+        lines.push(str2);
         linesAtValue = lines.length;
       }
       const { start, end } = flowChars;
@@ -1998,11 +1998,11 @@ ${indent}${line}` : "\n";
           reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;
         }
         if (reqNewline) {
-          let str = start;
+          let str2 = start;
           for (const line of lines)
-            str += line ? `
+            str2 += line ? `
 ${indentStep}${indent}${line}` : "\n";
-          return `${str}
+          return `${str2}
 ${indent}${end}`;
         } else {
           return `${start}${fcPadding}${lines.join(" ")}${fcPadding}${end}`;
@@ -2334,7 +2334,7 @@ var require_string = __commonJS({
       identify: (value) => typeof value === "string",
       default: true,
       tag: "tag:yaml.org,2002:str",
-      resolve: (str) => str,
+      resolve: (str2) => str2,
       stringify(item, ctx, onComment, onChompKeep) {
         ctx = Object.assign({ actualString: true }, ctx);
         return stringifyString.stringifyString(item, ctx, onComment, onChompKeep);
@@ -2372,7 +2372,7 @@ var require_bool = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:bool",
       test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
-      resolve: (str) => new Scalar.Scalar(str[0] === "t" || str[0] === "T"),
+      resolve: (str2) => new Scalar.Scalar(str2[0] === "t" || str2[0] === "T"),
       stringify({ source, value }, ctx) {
         if (source && boolTag.test.test(source)) {
           const sv = source[0] === "t" || source[0] === "T";
@@ -2424,7 +2424,7 @@ var require_float = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
-      resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
+      resolve: (str2) => str2.slice(-3).toLowerCase() === "nan" ? NaN : str2[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
       stringify: stringifyNumber.stringifyNumber
     };
     var floatExp = {
@@ -2433,7 +2433,7 @@ var require_float = __commonJS({
       tag: "tag:yaml.org,2002:float",
       format: "EXP",
       test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
-      resolve: (str) => parseFloat(str),
+      resolve: (str2) => parseFloat(str2),
       stringify(node) {
         const num = Number(node.value);
         return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node);
@@ -2444,11 +2444,11 @@ var require_float = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
-      resolve(str) {
-        const node = new Scalar.Scalar(parseFloat(str));
-        const dot = str.indexOf(".");
-        if (dot !== -1 && str[str.length - 1] === "0")
-          node.minFractionDigits = str.length - dot - 1;
+      resolve(str2) {
+        const node = new Scalar.Scalar(parseFloat(str2));
+        const dot = str2.indexOf(".");
+        if (dot !== -1 && str2[str2.length - 1] === "0")
+          node.minFractionDigits = str2.length - dot - 1;
         return node;
       },
       stringify: stringifyNumber.stringifyNumber
@@ -2465,7 +2465,7 @@ var require_int = __commonJS({
     "use strict";
     var stringifyNumber = require_stringifyNumber();
     var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
-    var intResolve = (str, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix);
+    var intResolve = (str2, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str2) : parseInt(str2.substring(offset), radix);
     function intStringify(node, radix, prefix) {
       const { value } = node;
       if (intIdentify(value) && value >= 0)
@@ -2478,7 +2478,7 @@ var require_int = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "OCT",
       test: /^0o[0-7]+$/,
-      resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),
+      resolve: (str2, _onError, opt) => intResolve(str2, 2, 8, opt),
       stringify: (node) => intStringify(node, 8, "0o")
     };
     var int = {
@@ -2486,7 +2486,7 @@ var require_int = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:int",
       test: /^[-+]?[0-9]+$/,
-      resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
+      resolve: (str2, _onError, opt) => intResolve(str2, 0, 10, opt),
       stringify: stringifyNumber.stringifyNumber
     };
     var intHex = {
@@ -2495,7 +2495,7 @@ var require_int = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "HEX",
       test: /^0x[0-9a-fA-F]+$/,
-      resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
+      resolve: (str2, _onError, opt) => intResolve(str2, 2, 16, opt),
       stringify: (node) => intStringify(node, 16, "0x")
     };
     exports.int = int;
@@ -2548,7 +2548,7 @@ var require_schema2 = __commonJS({
         identify: (value) => typeof value === "string",
         default: true,
         tag: "tag:yaml.org,2002:str",
-        resolve: (str) => str,
+        resolve: (str2) => str2,
         stringify: stringifyJSON
       },
       {
@@ -2565,7 +2565,7 @@ var require_schema2 = __commonJS({
         default: true,
         tag: "tag:yaml.org,2002:bool",
         test: /^true$|^false$/,
-        resolve: (str) => str === "true",
+        resolve: (str2) => str2 === "true",
         stringify: stringifyJSON
       },
       {
@@ -2573,7 +2573,7 @@ var require_schema2 = __commonJS({
         default: true,
         tag: "tag:yaml.org,2002:int",
         test: /^-?(?:0|[1-9][0-9]*)$/,
-        resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),
+        resolve: (str2, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str2) : parseInt(str2, 10),
         stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value)
       },
       {
@@ -2581,7 +2581,7 @@ var require_schema2 = __commonJS({
         default: true,
         tag: "tag:yaml.org,2002:float",
         test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
-        resolve: (str) => parseFloat(str),
+        resolve: (str2) => parseFloat(str2),
         stringify: stringifyJSON
       }
     ];
@@ -2589,9 +2589,9 @@ var require_schema2 = __commonJS({
       default: true,
       tag: "",
       test: /^/,
-      resolve(str, onError) {
-        onError(`Unresolved plain scalar ${JSON.stringify(str)}`);
-        return str;
+      resolve(str2, onError) {
+        onError(`Unresolved plain scalar ${JSON.stringify(str2)}`);
+        return str2;
       }
     };
     var schema = [map.map, seq.seq].concat(jsonScalars, jsonError);
@@ -2623,10 +2623,10 @@ var require_binary = __commonJS({
         if (typeof node_buffer.Buffer === "function") {
           return node_buffer.Buffer.from(src, "base64");
         } else if (typeof atob === "function") {
-          const str = atob(src.replace(/[\n\r]/g, ""));
-          const buffer = new Uint8Array(str.length);
-          for (let i = 0; i < str.length; ++i)
-            buffer[i] = str.charCodeAt(i);
+          const str2 = atob(src.replace(/[\n\r]/g, ""));
+          const buffer = new Uint8Array(str2.length);
+          for (let i = 0; i < str2.length; ++i)
+            buffer[i] = str2.charCodeAt(i);
           return buffer;
         } else {
           onError("This environment does not support reading binary tags; either Buffer or atob is required");
@@ -2637,28 +2637,28 @@ var require_binary = __commonJS({
         if (!value)
           return "";
         const buf = value;
-        let str;
+        let str2;
         if (typeof node_buffer.Buffer === "function") {
-          str = buf instanceof node_buffer.Buffer ? buf.toString("base64") : node_buffer.Buffer.from(buf.buffer).toString("base64");
+          str2 = buf instanceof node_buffer.Buffer ? buf.toString("base64") : node_buffer.Buffer.from(buf.buffer).toString("base64");
         } else if (typeof btoa === "function") {
           let s = "";
           for (let i = 0; i < buf.length; ++i)
             s += String.fromCharCode(buf[i]);
-          str = btoa(s);
+          str2 = btoa(s);
         } else {
           throw new Error("This environment does not support writing binary tags; either Buffer or btoa is required");
         }
         type ?? (type = Scalar.Scalar.BLOCK_LITERAL);
         if (type !== Scalar.Scalar.QUOTE_DOUBLE) {
           const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);
-          const n = Math.ceil(str.length / lineWidth);
+          const n = Math.ceil(str2.length / lineWidth);
           const lines = new Array(n);
           for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {
-            lines[i] = str.substr(o, lineWidth);
+            lines[i] = str2.substr(o, lineWidth);
           }
-          str = lines.join(type === Scalar.Scalar.BLOCK_LITERAL ? "\n" : " ");
+          str2 = lines.join(type === Scalar.Scalar.BLOCK_LITERAL ? "\n" : " ");
         }
-        return stringifyString.stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep);
+        return stringifyString.stringifyString({ comment, type, value: str2 }, ctx, onComment, onChompKeep);
       }
     };
     exports.binary = binary;
@@ -2864,7 +2864,7 @@ var require_float2 = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
-      resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
+      resolve: (str2) => str2.slice(-3).toLowerCase() === "nan" ? NaN : str2[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
       stringify: stringifyNumber.stringifyNumber
     };
     var floatExp = {
@@ -2873,7 +2873,7 @@ var require_float2 = __commonJS({
       tag: "tag:yaml.org,2002:float",
       format: "EXP",
       test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
-      resolve: (str) => parseFloat(str.replace(/_/g, "")),
+      resolve: (str2) => parseFloat(str2.replace(/_/g, "")),
       stringify(node) {
         const num = Number(node.value);
         return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node);
@@ -2884,11 +2884,11 @@ var require_float2 = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
-      resolve(str) {
-        const node = new Scalar.Scalar(parseFloat(str.replace(/_/g, "")));
-        const dot = str.indexOf(".");
+      resolve(str2) {
+        const node = new Scalar.Scalar(parseFloat(str2.replace(/_/g, "")));
+        const dot = str2.indexOf(".");
         if (dot !== -1) {
-          const f = str.substring(dot + 1).replace(/_/g, "");
+          const f = str2.substring(dot + 1).replace(/_/g, "");
           if (f[f.length - 1] === "0")
             node.minFractionDigits = f.length;
         }
@@ -2908,34 +2908,34 @@ var require_int2 = __commonJS({
     "use strict";
     var stringifyNumber = require_stringifyNumber();
     var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
-    function intResolve(str, offset, radix, { intAsBigInt }) {
-      const sign = str[0];
+    function intResolve(str2, offset, radix, { intAsBigInt }) {
+      const sign = str2[0];
       if (sign === "-" || sign === "+")
         offset += 1;
-      str = str.substring(offset).replace(/_/g, "");
+      str2 = str2.substring(offset).replace(/_/g, "");
       if (intAsBigInt) {
         switch (radix) {
           case 2:
-            str = `0b${str}`;
+            str2 = `0b${str2}`;
             break;
           case 8:
-            str = `0o${str}`;
+            str2 = `0o${str2}`;
             break;
           case 16:
-            str = `0x${str}`;
+            str2 = `0x${str2}`;
             break;
         }
-        const n2 = BigInt(str);
+        const n2 = BigInt(str2);
         return sign === "-" ? BigInt(-1) * n2 : n2;
       }
-      const n = parseInt(str, radix);
+      const n = parseInt(str2, radix);
       return sign === "-" ? -1 * n : n;
     }
     function intStringify(node, radix, prefix) {
       const { value } = node;
       if (intIdentify(value)) {
-        const str = value.toString(radix);
-        return value < 0 ? "-" + prefix + str.substr(1) : prefix + str;
+        const str2 = value.toString(radix);
+        return value < 0 ? "-" + prefix + str2.substr(1) : prefix + str2;
       }
       return stringifyNumber.stringifyNumber(node);
     }
@@ -2945,7 +2945,7 @@ var require_int2 = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "BIN",
       test: /^[-+]?0b[0-1_]+$/,
-      resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),
+      resolve: (str2, _onError, opt) => intResolve(str2, 2, 2, opt),
       stringify: (node) => intStringify(node, 2, "0b")
     };
     var intOct = {
@@ -2954,7 +2954,7 @@ var require_int2 = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "OCT",
       test: /^[-+]?0[0-7_]+$/,
-      resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),
+      resolve: (str2, _onError, opt) => intResolve(str2, 1, 8, opt),
       stringify: (node) => intStringify(node, 8, "0")
     };
     var int = {
@@ -2962,7 +2962,7 @@ var require_int2 = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:int",
       test: /^[-+]?[0-9][0-9_]*$/,
-      resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
+      resolve: (str2, _onError, opt) => intResolve(str2, 0, 10, opt),
       stringify: stringifyNumber.stringifyNumber
     };
     var intHex = {
@@ -2971,7 +2971,7 @@ var require_int2 = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "HEX",
       test: /^[-+]?0x[0-9a-fA-F_]+$/,
-      resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
+      resolve: (str2, _onError, opt) => intResolve(str2, 2, 16, opt),
       stringify: (node) => intStringify(node, 16, "0x")
     };
     exports.int = int;
@@ -3075,9 +3075,9 @@ var require_timestamp = __commonJS({
   "../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/yaml-1.1/timestamp.js"(exports) {
     "use strict";
     var stringifyNumber = require_stringifyNumber();
-    function parseSexagesimal(str, asBigInt) {
-      const sign = str[0];
-      const parts = sign === "-" || sign === "+" ? str.substring(1) : str;
+    function parseSexagesimal(str2, asBigInt) {
+      const sign = str2[0];
+      const parts = sign === "-" || sign === "+" ? str2.substring(1) : str2;
       const num = (n) => asBigInt ? BigInt(n) : Number(n);
       const res = parts.replace(/_/g, "").split(":").reduce((res2, p) => res2 * num(60) + num(p), num(0));
       return sign === "-" ? num(-1) * res : res;
@@ -3114,7 +3114,7 @@ var require_timestamp = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "TIME",
       test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
-      resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),
+      resolve: (str2, _onError, { intAsBigInt }) => parseSexagesimal(str2, intAsBigInt),
       stringify: stringifySexagesimal
     };
     var floatTime = {
@@ -3123,7 +3123,7 @@ var require_timestamp = __commonJS({
       tag: "tag:yaml.org,2002:float",
       format: "TIME",
       test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
-      resolve: (str) => parseSexagesimal(str, false),
+      resolve: (str2) => parseSexagesimal(str2, false),
       stringify: stringifySexagesimal
     };
     var timestamp = {
@@ -3134,8 +3134,8 @@ var require_timestamp = __commonJS({
       // may be omitted altogether, resulting in a date format. In such a case, the time part is
       // assumed to be 00:00:00Z (start of day, UTC).
       test: RegExp("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?$"),
-      resolve(str) {
-        const match = str.match(timestamp.test);
+      resolve(str2) {
+        const match = str2.match(timestamp.test);
         if (!match)
           throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd");
         const [, year, month, day, hour, minute, second] = match.map(Number);
@@ -5576,7 +5576,7 @@ var require_cst_visit = __commonJS({
   "../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/parse/cst-visit.js"(exports) {
     "use strict";
     var BREAK = /* @__PURE__ */ Symbol("break visit");
-    var SKIP2 = /* @__PURE__ */ Symbol("skip children");
+    var SKIP3 = /* @__PURE__ */ Symbol("skip children");
     var REMOVE = /* @__PURE__ */ Symbol("remove item");
     function visit(cst, visitor) {
       if ("type" in cst && cst.type === "document")
@@ -5584,7 +5584,7 @@ var require_cst_visit = __commonJS({
       _visit(Object.freeze([]), cst, visitor);
     }
     visit.BREAK = BREAK;
-    visit.SKIP = SKIP2;
+    visit.SKIP = SKIP3;
     visit.REMOVE = REMOVE;
     visit.itemAtPath = (cst, path) => {
       let item = cst;
@@ -7378,37 +7378,317 @@ var require_dist = __commonJS({
   }
 });
 
+// ../policy/dist/discover.js
+function isAgentConfigPath(path) {
+  return PROJECT_FILES.some((f) => f.re.test(path));
+}
+function agentFor(path) {
+  const p = PROJECT_FILES.find((f) => f.re.test(path));
+  if (p)
+    return p.agent;
+  const u = USER_CONFIG_FILES.find((f) => path.endsWith(f.path));
+  return u?.agent ?? "any";
+}
+function parseJsonc(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+  }
+  const noComments = text.replace(/("(?:\\.|[^"\\])*")|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (_m, s1) => s1 ?? "");
+  try {
+    return JSON.parse(noComments.replace(/,(\s*[}\]])/g, "$1"));
+  } catch {
+    return null;
+  }
+}
+function stdioPackage(command, args) {
+  const bin = command.split(/[\\/]/).pop()?.replace(/\.(cmd|exe)$/i, "") ?? "";
+  const strip = (s) => s.replace(/(.)@[^@/]+$/, "$1");
+  if (/^(npx|bunx|pnpx)$/.test(bin) || bin === "pnpm" && args[0] === "dlx") {
+    const pkg = args.find((a) => !a.startsWith("-") && a !== "dlx" && a !== "exec");
+    return pkg && /^(@[\w.-]+\/)?[\w.-]+(@[\w.^~<>=*-]+)?$/.test(pkg) ? { registry: "npm", name: strip(pkg) } : void 0;
+  }
+  if (/^(uvx|pipx)$/.test(bin) || bin === "uv" && args[0] === "tool") {
+    const pkg = args.find((a) => !a.startsWith("-") && !["run", "tool"].includes(a));
+    return pkg && /^[\w.\-[\]]+(==[\w.]+)?$/.test(pkg) ? { registry: "pypi", name: pkg.toLowerCase().replace(/\[.*\]$/, "").replace(/==.*$/, "").replace(/_/g, "-") } : void 0;
+  }
+  if (bin === "docker") {
+    const img = args.find((a, i) => i > 0 && !a.startsWith("-") && /^([\w.-]+\.[\w]+\/)?[\w.-]+\/[\w.-]+(:[\w.-]+)?$/.test(a) && !/^-/.test(args[i - 1] ?? ""));
+    if (!img)
+      return void 0;
+    return { registry: "docker", name: img.replace(/:[\w.-]+$/, "").replace(/^(docker\.io|ghcr\.io)\//, "") };
+  }
+  return void 0;
+}
+function hostOf(u) {
+  if (!u)
+    return void 0;
+  try {
+    return new URL(u).host.toLowerCase();
+  } catch {
+    return void 0;
+  }
+}
+function serverComponents(servers, path, scope, agent) {
+  if (!isObj(servers))
+    return [];
+  const out = [];
+  for (const [name, raw] of Object.entries(servers).slice(0, 200)) {
+    if (!isObj(raw))
+      continue;
+    const url = str(raw.url) ?? str(raw.serverUrl) ?? str(raw.httpUrl);
+    const command = str(raw.command);
+    const args = Array.isArray(raw.args) ? raw.args.filter((a) => typeof a === "string") : [];
+    const envKeys = keysOf(raw.env);
+    const headerKeys = keysOf(raw.headers);
+    if (url)
+      out.push({ kind: "mcp_server", name, path, scope, agent, transport: "http", urlHost: hostOf(url), envKeys, headerKeys });
+    else if (command) {
+      const parts = args.length ? [command, ...args] : command.split(/\s+/);
+      const bin = parts[0];
+      out.push({ kind: "mcp_server", name, path, scope, agent, transport: "stdio", command: bin.split(/[\\/]/).pop(), package: stdioPackage(bin, parts.slice(1)), envKeys, headerKeys });
+    }
+  }
+  return out;
+}
+function claudeSettings(j, path, scope) {
+  const out = [];
+  const agent = "claude_code";
+  if (isObj(j.enabledPlugins)) {
+    for (const [id, on2] of Object.entries(j.enabledPlugins).slice(0, 200)) {
+      if (on2 === false)
+        continue;
+      const [plugin, marketplace] = id.split("@");
+      out.push({ kind: "plugin", name: plugin, path, scope, agent, envKeys: [], headerKeys: [], detail: marketplace ? `from ${marketplace}` : void 0 });
+    }
+  }
+  if (isObj(j.hooks)) {
+    for (const [event, groups] of Object.entries(j.hooks)) {
+      if (!Array.isArray(groups))
+        continue;
+      for (const g of groups) {
+        if (!isObj(g) || !Array.isArray(g.hooks))
+          continue;
+        for (const h of g.hooks) {
+          if (!isObj(h))
+            continue;
+          const cmd2 = str(h.command);
+          if (!cmd2)
+            continue;
+          const bin = cmd2.trim().split(/\s+/)[0];
+          out.push({ kind: "hook", name: event, path, scope, agent, command: bin.split(/[\\/]/).pop(), envKeys: [], headerKeys: [], detail: str(g.matcher) ? `on ${str(g.matcher)}` : "on every tool call" });
+        }
+      }
+    }
+  }
+  out.push(...serverComponents(j.mcpServers, path, scope, agent));
+  return out;
+}
+function codexToml(text, path, scope) {
+  const out = [];
+  const blocks = text.split(/^\s*\[/m).slice(1);
+  for (const b of blocks) {
+    const head = b.match(/^mcp_servers\.("?)([\w.-]+)\1\]/);
+    if (head) {
+      const body = b.slice(b.indexOf("]") + 1);
+      const command = body.match(/^\s*command\s*=\s*"([^"]+)"/m)?.[1];
+      const args = [...(body.match(/^\s*args\s*=\s*\[([^\]]*)\]/m)?.[1] ?? "").matchAll(/"([^"]*)"/g)].map((m) => m[1]);
+      const url = body.match(/^\s*url\s*=\s*"([^"]+)"/m)?.[1] ?? null;
+      const envKeys = [...(body.match(/^\s*env\s*=\s*\{([^}]*)\}/m)?.[1] ?? "").matchAll(/([\w.-]+)\s*=/g)].map((m) => m[1]);
+      if (url)
+        out.push({ kind: "mcp_server", name: head[2], path, scope, agent: "codex", transport: "http", urlHost: hostOf(url), envKeys, headerKeys: [] });
+      else if (command)
+        out.push({ kind: "mcp_server", name: head[2], path, scope, agent: "codex", transport: "stdio", command: command.split(/[\\/]/).pop(), package: stdioPackage(command, args), envKeys, headerKeys: [] });
+    }
+    const envTable = b.match(/^mcp_servers\.("?)([\w.-]+)\1\.env\]/);
+    if (envTable) {
+      const target = out.find((c2) => c2.name === envTable[2]);
+      if (target)
+        target.envKeys.push(...[...b.slice(b.indexOf("]") + 1).matchAll(/^\s*([\w.-]+)\s*=/gm)].map((m) => m[1]));
+    }
+  }
+  return out;
+}
+function skillName(path, text) {
+  const fm = text.match(/^---\s*\n([\s\S]*?)\n---/);
+  const n = fm?.[1].match(/^name:\s*["']?([^"'\n]+)["']?\s*$/m)?.[1]?.trim();
+  return n || path.split("/").slice(-2, -1)[0] || "skill";
+}
+function parseAgentConfig(path, text, scope = "project") {
+  const p = path.replace(/\\/g, "/");
+  const agent = agentFor(p);
+  const base = p.split("/").pop() ?? p;
+  if (/\/SKILL\.md$/i.test(p))
+    return [{ kind: "skill", name: skillName(p, text), path: p, scope, agent: "claude_code", envKeys: [], headerKeys: [] }];
+  if (/\.(md|mdc)$/i.test(p) || /^\.(cursorrules|windsurfrules|clinerules)$/.test(base)) {
+    const kind = /\/\.claude\/commands\//.test(`/${p}`) ? "slash command" : /\/\.claude\/agents\//.test(`/${p}`) ? "subagent" : "instructions";
+    return [{ kind: "instructions", name: kind === "instructions" ? base : `${kind}: ${base.replace(/\.md$/i, "")}`, path: p, scope, agent, envKeys: [], headerKeys: [], detail: `${text.length.toLocaleString("en-US")} characters` }];
+  }
+  if (/config\.toml$/.test(p))
+    return codexToml(text, p, scope);
+  const j = parseJsonc(text);
+  if (!isObj(j))
+    return [];
+  if (/\.claude\/settings(\.local)?\.json$/.test(p))
+    return claudeSettings(j, p, scope);
+  if (/\.vscode\/mcp\.json$/.test(p))
+    return serverComponents(j.servers, p, scope, "vscode");
+  if (base === ".claude.json") {
+    const out = serverComponents(j.mcpServers, p, scope, "claude_code");
+    if (isObj(j.projects)) {
+      for (const [proj, cfg] of Object.entries(j.projects).slice(0, 100))
+        if (isObj(cfg))
+          for (const c2 of serverComponents(cfg.mcpServers, p, "project", "claude_code"))
+            out.push({ ...c2, detail: `project ${proj.split(/[\\/]/).slice(-2).join("/")}` });
+    }
+    return out;
+  }
+  return serverComponents(j.mcpServers ?? j.servers, p, scope, agent);
+}
+function classifyCredential(name) {
+  for (const [re, c2] of CRED_RULES)
+    if (re.test(name))
+      return c2;
+  return null;
+}
+function blastRadius({ component: c2, verdict, trace }) {
+  const reasons = [];
+  const credentials = [...c2.envKeys, ...c2.headerKeys].map((name) => ({ name, class: classifyCredential(name) })).filter((x) => !!x.class);
+  const hosts = /* @__PURE__ */ new Set();
+  if (c2.urlHost)
+    hosts.add(c2.urlHost);
+  for (const h of trace?.egressHosts ?? [])
+    hosts.add(h);
+  let score = 0;
+  const local = c2.transport === "stdio" || c2.kind === "hook";
+  if (c2.kind === "hook") {
+    score += 2;
+    reasons.push(`runs \`${c2.command ?? "a command"}\` ${c2.detail ?? "on agent events"}, as the developer`);
+  } else if (local) {
+    score += 2;
+    reasons.push("runs on the developer's machine with their files, network and shell");
+  }
+  if (c2.kind === "skill" || c2.kind === "plugin") {
+    score += 1;
+    reasons.push("adds instructions and scripts the agent will follow");
+  }
+  const strong = credentials.filter((x) => x.class !== "secret");
+  if (credentials.length) {
+    score += strong.some((x) => ["cloud", "source_control", "payments", "database"].includes(x.class)) ? 3 : 2;
+    reasons.unshift(`is handed ${credentials.length === 1 ? "a credential" : `${credentials.length} credentials`}: ${credentials.slice(0, 4).map((x) => x.name).join(", ")}${credentials.length > 4 ? ", \u2026" : ""}`);
+  }
+  if (c2.transport === "http" && c2.urlHost) {
+    score += 1;
+    reasons.push(`sends the agent's tool calls and their data to ${c2.urlHost}`);
+  }
+  if (verdict?.label === "blocked") {
+    score += 4;
+    reasons.unshift(`its verdict is Blocked (${verdict.score}/100)`);
+  } else if (verdict?.label === "caution") {
+    score += 1;
+    reasons.push(`its verdict is Caution (${verdict.score}/100)`);
+  }
+  if (trace?.credentialPathsRead.length) {
+    score += 3;
+    reasons.unshift(`read ${trace.credentialPathsRead.slice(0, 2).join(", ")} in the honeypot`);
+  }
+  if (trace?.memoryWrites) {
+    score += 2;
+    reasons.push("wrote to the agent's memory or instruction files in the honeypot");
+  }
+  if (c2.kind === "instructions")
+    reasons.push("is read by the agent as instructions on every session");
+  if (!verdict && c2.kind !== "instructions" && c2.kind !== "hook") {
+    score += 1;
+    reasons.push(c2.package || c2.kind !== "mcp_server" ? "has no KillerSkills verdict yet" : "is not a registry package, so there is no verdict to check");
+  }
+  const level = score >= 5 ? "high" : score >= 3 ? "medium" : "low";
+  return { level, reasons, credentials, hosts: [...hosts].slice(0, 10) };
+}
+var PROJECT_FILES, USER_CONFIG_FILES, USER_SKILL_DIRS, isObj, str, keysOf, CRED_RULES;
+var init_discover = __esm({
+  "../policy/dist/discover.js"() {
+    "use strict";
+    PROJECT_FILES = [
+      { re: /(^|\/)\.mcp\.json$/, agent: "claude_code" },
+      { re: /(^|\/)\.claude\/settings(\.local)?\.json$/, agent: "claude_code" },
+      { re: /(^|\/)\.claude\/skills\/[^/]+\/SKILL\.md$/i, agent: "claude_code" },
+      { re: /(^|\/)\.claude\/(commands|agents)\/[^/]+\.md$/i, agent: "claude_code" },
+      { re: /(^|\/)\.cursor\/mcp\.json$/, agent: "cursor" },
+      { re: /(^|\/)\.cursor\/rules\/[^/]+\.mdc?$/, agent: "cursor" },
+      { re: /(^|\/)\.vscode\/mcp\.json$/, agent: "vscode" },
+      { re: /(^|\/)\.gemini\/settings\.json$/, agent: "gemini_cli" },
+      { re: /(^|\/)\.codex\/config\.toml$/, agent: "codex" },
+      { re: /(^|\/)\.github\/copilot-instructions\.md$/, agent: "copilot" },
+      { re: /(^|\/)(CLAUDE|AGENTS|GEMINI)\.md$/, agent: "any" },
+      { re: /(^|\/)\.(cursorrules|windsurfrules|clinerules)$/, agent: "any" }
+    ];
+    USER_CONFIG_FILES = [
+      { path: ".claude.json", agent: "claude_code" },
+      { path: ".claude/settings.json", agent: "claude_code" },
+      { path: ".claude/CLAUDE.md", agent: "claude_code" },
+      { path: ".cursor/mcp.json", agent: "cursor" },
+      { path: ".codeium/windsurf/mcp_config.json", agent: "windsurf" },
+      { path: ".gemini/settings.json", agent: "gemini_cli" },
+      { path: ".codex/config.toml", agent: "codex" },
+      { path: "Library/Application Support/Claude/claude_desktop_config.json", agent: "claude_desktop" },
+      { path: ".config/Claude/claude_desktop_config.json", agent: "claude_desktop" },
+      { path: "AppData/Roaming/Claude/claude_desktop_config.json", agent: "claude_desktop" }
+    ];
+    USER_SKILL_DIRS = [".claude/skills"];
+    isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+    str = (v) => typeof v === "string" ? v : null;
+    keysOf = (v) => isObj(v) ? Object.keys(v).filter((k) => /^[\w.-]{1,120}$/.test(k)).slice(0, 50) : [];
+    CRED_RULES = [
+      [/^(AWS_|AZURE_|ARM_|GOOGLE_|GCP_|GCLOUD|CLOUDFLARE_|DIGITALOCEAN|DO_TOKEN|VERCEL_|NETLIFY_|HEROKU_|FLY_)/i, "cloud"],
+      [/^(GITHUB_|GH_|GITLAB_|GL_|BITBUCKET_|GIT_)/i, "source_control"],
+      [/^(STRIPE_|PAYPAL_|BRAINTREE_|ADYEN_|SQUARE_)/i, "payments"],
+      [/(DATABASE_URL|_DSN$|^POSTGRES|^PG|^MYSQL|^MONGO|^REDIS|^SUPABASE_|^NEON_|^PLANETSCALE|^SNOWFLAKE_|^BIGQUERY)/i, "database"],
+      [/^(OPENAI_|ANTHROPIC_|GEMINI_|MISTRAL_|COHERE_|GROQ_|HF_|HUGGINGFACE)/i, "ai_provider"],
+      [/^(SLACK_|DISCORD_|TWILIO_|SENDGRID_|RESEND_|MAILGUN_|POSTMARK_)/i, "messaging"],
+      [/(TOKEN|SECRET|PASSWORD|PASSWD|API_?KEY|PRIVATE_KEY|CREDENTIAL|AUTH)/i, "secret"]
+    ];
+  }
+});
+
 // ../policy/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   DEFAULT_POLICY: () => DEFAULT_POLICY,
   FLAG_LABEL: () => FLAG_LABEL,
   SOLO_POLICY: () => SOLO_POLICY,
+  USER_CONFIG_FILES: () => USER_CONFIG_FILES,
+  USER_SKILL_DIRS: () => USER_SKILL_DIRS,
+  blastRadius: () => blastRadius,
+  classifyCredential: () => classifyCredential,
   evaluate: () => evaluate,
   flagsFromTrace: () => flagsFromTrace,
+  isAgentConfigPath: () => isAgentConfigPath,
   labelFor: () => labelFor,
+  parseAgentConfig: () => parseAgentConfig,
   parsePolicyYaml: () => parsePolicyYaml,
   serializePolicyYaml: () => serializePolicyYaml,
-  simulate: () => simulate
+  simulate: () => simulate,
+  stdioPackage: () => stdioPackage
 });
 function parsePolicyYaml(text) {
   const y = import_yaml.default.parse(text) ?? {};
   const num = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
-  const str = (v, allowed, d) => allowed.includes(v) ? v : d;
+  const str2 = (v, allowed, d) => allowed.includes(v) ? v : d;
   const list = (v) => Array.isArray(v) ? v.map(String) : [];
   const b = y.behavior ?? {};
   const p = y.publishers ?? {};
   const a = y.approvals ?? {};
   const behavior = { ...DEFAULT_POLICY.behavior };
   for (const f of FLAGS)
-    behavior[f] = str(b[f], ["block", "approval", "warn"], DEFAULT_POLICY.behavior[f]);
+    behavior[f] = str2(b[f], ["block", "approval", "warn"], DEFAULT_POLICY.behavior[f]);
   return {
     name: typeof y.name === "string" ? y.name : DEFAULT_POLICY.name,
     version: num(y.version, 1),
     minScore: Math.min(100, Math.max(0, num(y.min_score, DEFAULT_POLICY.minScore))),
-    cautionAction: str(y.caution, ["sandbox", "approval", "allow", "block"], DEFAULT_POLICY.cautionAction),
-    unknownAction: str(y.unknown, ["detonate", "block", "approval", "allow"], DEFAULT_POLICY.unknownAction),
-    offlineAction: str(y.offline, ["allow", "block", "approval"], DEFAULT_POLICY.offlineAction),
+    cautionAction: str2(y.caution, ["sandbox", "approval", "allow", "block"], DEFAULT_POLICY.cautionAction),
+    unknownAction: str2(y.unknown, ["detonate", "block", "approval", "allow"], DEFAULT_POLICY.unknownAction),
+    offlineAction: str2(y.offline, ["allow", "block", "approval"], DEFAULT_POLICY.offlineAction),
     behavior,
     publishers: {
       allow: list(p.allow),
@@ -7572,6 +7852,7 @@ var init_dist = __esm({
   "../policy/dist/index.js"() {
     "use strict";
     import_yaml = __toESM(require_dist(), 1);
+    init_discover();
     DEFAULT_POLICY = {
       name: "default-strict",
       version: 1,
@@ -7614,11 +7895,11 @@ var init_dist = __esm({
 init_dist();
 import { parseArgs } from "node:util";
 import { spawnSync } from "node:child_process";
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "node:fs";
-import { resolve as resolve2, join as join6, dirname, basename } from "node:path";
+import { readFileSync as readFileSync6, existsSync as existsSync7 } from "node:fs";
+import { resolve as resolve2, join as join7, dirname, basename } from "node:path";
 import { hostname, platform as platform2, userInfo } from "node:os";
 import { createHash as createHash2 } from "node:crypto";
-import { createInterface } from "node:readline";
+import { createInterface as createInterface2 } from "node:readline";
 
 // src/check.ts
 init_dist();
@@ -7629,7 +7910,7 @@ import { mkdirSync, readFileSync, writeFileSync, existsSync, appendFileSync, chm
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
-var VERSION = "0.6.0";
+var VERSION = "0.7.0";
 var HOME = process.env.VET_SKILLS_HOME ?? join(homedir(), ".vet-skills");
 var API = (process.env.KILLERSKILLS_API ?? "https://killerskills.ai").replace(/\/$/, "");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -7827,6 +8108,11 @@ function detonate(tgz, opts = {}) {
 function sendTelemetry(body) {
   return call("/api/v1/telemetry", { method: "POST", body: JSON.stringify(body) }, 1500);
 }
+function discoverReport(components) {
+  const org = readOrg();
+  if (!org) return Promise.resolve({ ok: false, error: "not joined", offline: false });
+  return call(`/api/v1/orgs/${org.slug}/agents/${org.agentId}/discover`, { method: "POST", body: JSON.stringify({ components }), headers: orgHeaders() }, 15e3);
+}
 
 // src/check.ts
 import { platform } from "node:os";
@@ -7879,12 +8165,12 @@ var PAYLOAD_TYPE = "application/vnd.killerskills.verdict+json";
 var SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", ".pglite", ".next", "__pycache__", ".venv"]);
 function bundleHash(root) {
   const h = createHash("sha256");
-  const walk = (dir) => {
+  const walk2 = (dir) => {
     for (const name of readdirSync(dir).sort()) {
       if (SKIP.has(name)) continue;
       const p = join2(dir, name);
       const st = statSync2(p);
-      if (st.isDirectory()) walk(p);
+      if (st.isDirectory()) walk2(p);
       else if (st.isFile() && st.size <= 2 * 1024 * 1024) {
         h.update(relative(root, p).split(sep).join("/"));
         h.update("\0");
@@ -7893,7 +8179,7 @@ function bundleHash(root) {
       }
     }
   };
-  walk(root);
+  walk2(root);
   return h.digest("hex");
 }
 function pae(payloadType, payload) {
@@ -8183,18 +8469,183 @@ function restrictionText(r) {
   return parts.join(" \xB7 ") || "no restrictions";
 }
 
+// src/discover.ts
+init_dist();
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+var MAX_BYTES = 2 * 1024 * 1024;
+function read(path) {
+  try {
+    const st = statSync3(path);
+    if (!st.isFile() || st.size > MAX_BYTES) return null;
+    return readFileSync3(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function discoverLocal(opts = {}) {
+  const home = opts.home ?? homedir3();
+  const out = [];
+  for (const f of USER_CONFIG_FILES) {
+    const text = read(join3(home, f.path));
+    if (text !== null) out.push(...parseAgentConfig(f.path, text, "user"));
+  }
+  for (const dir of USER_SKILL_DIRS) {
+    const abs = join3(home, dir);
+    if (!existsSync3(abs)) continue;
+    for (const name of safeList(abs)) {
+      const rel = `${dir}/${name}/SKILL.md`;
+      const text = read(join3(home, rel));
+      if (text !== null) out.push(...parseAgentConfig(rel, text, "user"));
+    }
+  }
+  if (opts.project) for (const rel of walk(opts.project, "", 0)) {
+    const text = read(join3(opts.project, rel));
+    if (text !== null) out.push(...parseAgentConfig(rel, text, "project"));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return out.filter((c2) => {
+    const k = `${c2.kind}|${c2.name}|${c2.path}`;
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
+function safeList(dir) {
+  try {
+    return readdirSync2(dir);
+  } catch {
+    return [];
+  }
+}
+var SKIP2 = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "vendor", "target", ".venv", "venv"]);
+function walk(root, rel, depth) {
+  if (depth > 6) return [];
+  const out = [];
+  for (const name of safeList(join3(root, rel))) {
+    if (SKIP2.has(name)) continue;
+    const r = rel ? `${rel}/${name}` : name;
+    let st;
+    try {
+      st = statSync3(join3(root, r));
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) out.push(...walk(root, r, depth + 1));
+    else if (isAgentConfigPath(r)) out.push(r);
+    if (out.length > 200) break;
+  }
+  return out;
+}
+
+// src/mcp.ts
+import { createInterface } from "node:readline";
+var TOOLS = [
+  {
+    name: "check_skill",
+    title: "Check a skill or MCP server",
+    description: 'Look up the KillerSkills security verdict for an agent skill, MCP server or plugin BEFORE installing it. Returns the score (0-100), label (verified / caution / blocked), what the sandbox saw it do (network hosts contacted, credential files read, memory writes), the top findings, and the last safe version when the latest is blocked. Use the package name for npm/PyPI MCP servers (e.g. "@modelcontextprotocol/server-github" with registry "npm").',
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: 'Skill or package name: "name", "publisher/name", "@scope/pkg", optionally "@version".' },
+        registry: { type: "string", enum: ["skills_sh", "clawhub", "npm", "pypi", "docker", "plugins", "partner"], description: "Registry, when known. Omit to search all public registries." }
+      },
+      required: ["name"]
+    },
+    annotations: { readOnlyHint: true, openWorldHint: true }
+  },
+  {
+    name: "search_skills",
+    title: "Search vetted skills",
+    description: "Search the KillerSkills index (every public agent skill and MCP server, each detonated in a sandbox) by keyword. Returns the most-installed matches with their verdicts, so you can pick a verified option instead of an unvetted one.",
+    inputSchema: { type: "object", properties: { query: { type: "string", description: 'Keywords, e.g. "postgres", "github mcp", "pdf".' } }, required: ["query"] },
+    annotations: { readOnlyHint: true, openWorldHint: true }
+  }
+];
+async function checkSkill(name, registry) {
+  const r = await resolveSkill(name, registry);
+  if (!r.ok) return r.status === 404 ? `No skill or MCP server named "${name}" is indexed by KillerSkills${registry ? ` in ${registry}` : ""}. Treat it as unvetted.` : `KillerSkills lookup failed (${r.error}). Treat "${name}" as unvetted.`;
+  const d = r.data;
+  const page = `${API}${d.skill.page}`;
+  if (!d.verdict) return `${d.skill.name} (${d.skill.registry_label}, publisher ${d.publisher.handle}) is indexed but not scored yet: unvetted. ${page}`;
+  const lines = [
+    `${d.skill.name}@${d.version.semver} (${d.skill.registry_label}, publisher ${d.publisher.handle}${d.publisher.verified ? ", verified publisher" : ""})`,
+    `Verdict: ${d.verdict.label.toUpperCase()} \xB7 score ${d.verdict.score}/100 \xB7 ${d.verdict.scenarios_run} sandbox scenarios`
+  ];
+  const t = d.trace_summary;
+  if (t) {
+    const undeclared = t.egress_hosts.filter((h) => !h.declared).map((h) => h.host);
+    lines.push(`Sandbox: contacted ${t.egress_hosts.length} host(s)${undeclared.length ? ` (undeclared: ${undeclared.slice(0, 5).join(", ")})` : ""}; read ${t.files_read.length} file(s); ${t.memory_writes.length} memory write(s)${t.tool_shadowing.length ? `; shadows tools: ${t.tool_shadowing.map((x) => x.tool).join(", ")}` : ""}.`);
+  }
+  for (const f of d.findings.slice(0, 5)) lines.push(`- [${f.severity}] ${f.title}`);
+  if (d.verdict.label === "blocked" && d.last_safe_version) lines.push(`Last safe version: ${d.last_safe_version.semver} (score ${d.last_safe_version.score}).`);
+  lines.push(d.verdict.label === "verified" ? "OK to install." : d.verdict.label === "caution" ? "Install only if the findings above are acceptable; tell the user what they are." : "Do not install. Tell the user why.");
+  lines.push(`Evidence: ${page}`);
+  return lines.join("\n");
+}
+async function searchSkills(query) {
+  try {
+    const res = await fetch(`${API}/api/v1/leaderboard?q=${encodeURIComponent(query)}`, { headers: { accept: "application/json", "user-agent": `vet-skills/${VERSION} mcp` }, signal: AbortSignal.timeout(1e4) });
+    if (!res.ok) return `Search failed (HTTP ${res.status}).`;
+    const d = await res.json();
+    if (!d.rows.length) return `Nothing in the KillerSkills index matches "${query}".`;
+    return [`${d.total} match(es) for "${query}", most installed first:`, ...d.rows.slice(0, 15).map((x) => `- ${x.skill.name} (${x.skill.registry}, ${x.skill.publisher}) \xB7 ${x.latest_verdict.label} ${x.latest_verdict.score} \xB7 ${x.install_count.toLocaleString()} installs \xB7 ${API}${x.skill.page}`)].join("\n");
+  } catch (e) {
+    return `Search failed (${e.message}).`;
+  }
+}
+async function serveMcp() {
+  const send = (msg) => process.stdout.write(JSON.stringify(msg) + "\n");
+  const rl = createInterface({ input: process.stdin });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let req;
+    try {
+      req = JSON.parse(line);
+    } catch {
+      send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
+      continue;
+    }
+    if (req.id === void 0) continue;
+    const ok = (result) => send({ jsonrpc: "2.0", id: req.id, result });
+    switch (req.method) {
+      case "initialize":
+        ok({ protocolVersion: req.params?.protocolVersion ?? "2025-06-18", capabilities: { tools: {} }, serverInfo: { name: "killerskills", title: "KillerSkills", version: VERSION }, instructions: "Before installing any agent skill, plugin or MCP server, call check_skill. Do not install anything labelled blocked." });
+        break;
+      case "ping":
+        ok({});
+        break;
+      case "tools/list":
+        ok({ tools: TOOLS });
+        break;
+      case "tools/call": {
+        const name = req.params?.name;
+        const args = req.params?.arguments ?? {};
+        const text = name === "check_skill" ? await checkSkill(String(args.name ?? ""), args.registry || void 0) : name === "search_skills" ? await searchSkills(String(args.query ?? "")) : null;
+        if (text === null) send({ jsonrpc: "2.0", id: req.id, error: { code: -32602, message: `unknown tool ${name}` } });
+        else ok({ content: [{ type: "text", text }], isError: false });
+        break;
+      }
+      default:
+        send({ jsonrpc: "2.0", id: req.id, error: { code: -32601, message: `method not found: ${req.method}` } });
+    }
+  }
+}
+
 // src/hook.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join5 } from "node:path";
 
 // src/sync.ts
-import { existsSync as existsSync3, rmSync } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync4, rmSync } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
 function skillDirs(name) {
   const bare = name.replace(/^.*\//, "").replace(/@.*$/, "");
-  return [join3(homedir3(), ".claude", "skills", bare), join3(process.cwd(), ".claude", "skills", bare), join3(homedir3(), ".claude", "plugins", bare)];
+  return [join4(homedir4(), ".claude", "skills", bare), join4(process.cwd(), ".claude", "skills", bare), join4(homedir4(), ".claude", "plugins", bare)];
 }
 async function applyRemovals(pending, log = () => {
 }) {
@@ -8205,7 +8656,7 @@ async function applyRemovals(pending, log = () => {
     const detail = [];
     let failed = false;
     for (const it of items) {
-      const dirs = skillDirs(it.skill).filter((d) => existsSync3(d));
+      const dirs = skillDirs(it.skill).filter((d) => existsSync4(d));
       if (!dirs.length) {
         detail.push(`${it.skill}: not on disk`);
         continue;
@@ -8356,13 +8807,13 @@ ${out}
   return 0;
 }
 function installClaudeCodeHook() {
-  const dir = join4(homedir4(), ".claude");
-  const path = join4(dir, "settings.json");
-  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+  const dir = join5(homedir5(), ".claude");
+  const path = join5(dir, "settings.json");
+  if (!existsSync5(dir)) mkdirSync2(dir, { recursive: true });
   let settings = {};
-  if (existsSync4(path)) {
+  if (existsSync5(path)) {
     try {
-      settings = JSON.parse(readFileSync3(path, "utf8"));
+      settings = JSON.parse(readFileSync4(path, "utf8"));
     } catch {
       settings = {};
     }
@@ -8384,25 +8835,25 @@ function installClaudeCodeHook() {
 }
 
 // src/runtime.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join6 } from "node:path";
 var ACTIVE_MS = 30 * 6e4;
 var CRED = /(^|\/)(\.ssh|\.aws|\.npmrc|\.netrc|\.config\/gh|\.docker\/config\.json|\.kube\/config|\.gnupg|credentials|\.env(\.|$)|id_(rsa|ed25519|ecdsa)|keychain)/i;
 var MEMORY = /(^|\/)(MEMORY\.md|CLAUDE\.md|AGENTS\.md|\.cursorrules|\.clinerules|\.windsurfrules|GEMINI\.md|\.github\/copilot-instructions\.md)$/i;
-var DIR = join5(HOME, "runtime");
+var DIR = join6(HOME, "runtime");
 function sessionFile(id) {
-  return join5(DIR, `${id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 80)}.json`);
+  return join6(DIR, `${id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 80)}.json`);
 }
 function readSession(id) {
   try {
-    return JSON.parse(readFileSync4(sessionFile(id), "utf8"));
+    return JSON.parse(readFileSync5(sessionFile(id), "utf8"));
   } catch {
     return { active: null, verdicts: {}, reported: [] };
   }
 }
 function writeSession(id, s) {
-  if (!existsSync5(DIR)) mkdirSync3(DIR, { recursive: true });
+  if (!existsSync6(DIR)) mkdirSync3(DIR, { recursive: true });
   writeFileSync4(sessionFile(id), JSON.stringify(s));
 }
 function hostsIn(cmd2) {
@@ -8412,16 +8863,16 @@ function hostsIn(cmd2) {
   return [...out];
 }
 function pathsIn(cmd2) {
-  const read = /* @__PURE__ */ new Set();
+  const read2 = /* @__PURE__ */ new Set();
   const written = /* @__PURE__ */ new Set();
   const norm = (p) => p.replace(/^\$HOME/, "~").replace(/^["']|["']$/g, "");
   for (const m of cmd2.matchAll(/(?:>>?|tee\s+(?:-a\s+)?)\s*["']?((?:~|\/|\$HOME)[^\s"'|;&]+)/g)) written.add(norm(m[1]));
-  for (const m of cmd2.matchAll(/(?:^|[\s|;&(])(?:cat|less|head|tail|grep|cp|scp|base64|xxd|od|strings|python3?|node)\s+(?:-\S+\s+)*["']?((?:~|\/|\$HOME)[^\s"'|;&]+)/g)) read.add(norm(m[1]));
-  for (const m of cmd2.matchAll(/["']?((?:~|\$HOME)\/\.(?:ssh|aws|npmrc|netrc|config\/gh|docker|kube|gnupg)[^\s"'|;&]*)/g)) if (!written.has(norm(m[1]))) read.add(norm(m[1]));
-  return { read: [...read], written: [...written] };
+  for (const m of cmd2.matchAll(/(?:^|[\s|;&(])(?:cat|less|head|tail|grep|cp|scp|base64|xxd|od|strings|python3?|node)\s+(?:-\S+\s+)*["']?((?:~|\/|\$HOME)[^\s"'|;&]+)/g)) read2.add(norm(m[1]));
+  for (const m of cmd2.matchAll(/["']?((?:~|\$HOME)\/\.(?:ssh|aws|npmrc|netrc|config\/gh|docker|kube|gnupg)[^\s"'|;&]*)/g)) if (!written.has(norm(m[1]))) read2.add(norm(m[1]));
+  return { read: [...read2], written: [...written] };
 }
 var isOutsideProject = (p) => (p.startsWith("~") || p.startsWith("/")) && !p.startsWith(process.cwd()) && !p.startsWith("/tmp") && !p.startsWith("/dev");
-var tilde = (p) => p.replace(homedir5(), "~");
+var tilde = (p) => p.replace(homedir6(), "~");
 function attributed(session, toolName) {
   const m = toolName.match(/^mcp__([^_]+(?:_[^_]+)*?)__/);
   if (m) return m[1];
@@ -8490,16 +8941,16 @@ function deviations(skill, r, o, tool, session) {
   }
   return out;
 }
-var LOG = join5(HOME, "runtime", "deviations.jsonl");
+var LOG = join6(HOME, "runtime", "deviations.jsonl");
 function appendDeviations(ds) {
   if (!ds.length) return;
-  if (!existsSync5(DIR)) mkdirSync3(DIR, { recursive: true });
+  if (!existsSync6(DIR)) mkdirSync3(DIR, { recursive: true });
   writeFileSync4(LOG, ds.map((d) => JSON.stringify(d)).join("\n") + "\n", { flag: "a" });
 }
 function readDeviations(days = 7) {
-  if (!existsSync5(LOG)) return [];
+  if (!existsSync6(LOG)) return [];
   const since = Date.now() - days * 864e5;
-  return readFileSync4(LOG, "utf8").split("\n").filter(Boolean).map((l) => {
+  return readFileSync5(LOG, "utf8").split("\n").filter(Boolean).map((l) => {
     try {
       return JSON.parse(l);
     } catch {
@@ -8542,12 +8993,12 @@ async function observe(stdin) {
   return { code: serious ? 2 : 0, lines };
 }
 function pruneSessions() {
-  if (!existsSync5(DIR)) return;
-  for (const f of readdirSync2(DIR)) {
+  if (!existsSync6(DIR)) return;
+  for (const f of readdirSync3(DIR)) {
     if (!f.endsWith(".json")) continue;
-    const p = join5(DIR, f);
+    const p = join6(DIR, f);
     try {
-      if (Date.now() - statSync3(p).mtimeMs > 864e5) writeFileSync4(p, "{}");
+      if (Date.now() - statSync4(p).mtimeMs > 864e5) writeFileSync4(p, "{}");
     } catch {
     }
   }
@@ -8566,6 +9017,8 @@ var { values, positionals } = parseArgs({
     ci: { type: "boolean" },
     email: { type: "string" },
     help: { type: "boolean", short: "h" },
+    project: { type: "boolean" },
+    quiet: { type: "boolean", short: "q" },
     version: { type: "boolean", short: "v" },
     agent: { type: "string" },
     publisher: { type: "string" },
@@ -8574,7 +9027,7 @@ var { values, positionals } = parseArgs({
 });
 var [cmd, ...rest] = positionals;
 async function ask(question, choices) {
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  const rl = createInterface2({ input: process.stdin, output: process.stderr });
   return new Promise((res) => rl.question(question, (a) => {
     rl.close();
     const k = a.trim().toLowerCase()[0];
@@ -8598,6 +9051,8 @@ Get started:
   vet-skills policy show|set <file>     view or replace the local policy
   vet-skills block <skill> [--reason]   add to the personal block list
   vet-skills status                     org, policy version, last report, cache size
+  vet-skills discover [--project] [--json] every MCP server, skill, plugin and hook on this machine, with verdicts
+  vet-skills mcp                        run as an MCP server (check_skill, search_skills) for any agent
   vet-skills sync                       pull the org policy and apply pending removals
   vet-skills verify <skill|path>        check the signed verdict against what is on disk
   vet-skills lock                       pin every installed skill's hash + attestation in vet-skills.lock
@@ -8683,7 +9138,7 @@ async function main() {
         return 1;
       }
       const dir = resolve2(rest[0]);
-      if (!existsSync6(join6(dir, "SKILL.md")) && !existsSync6(join6(dir, "package.json"))) {
+      if (!existsSync7(join7(dir, "SKILL.md")) && !existsSync7(join7(dir, "package.json"))) {
         console.log(`${c.blocked("\u2717")} ${dir} has no SKILL.md or package.json`);
         return 1;
       }
@@ -8726,7 +9181,7 @@ async function main() {
         return 1;
       }
       const dir = resolve2(rest[0]);
-      if (!existsSync6(join6(dir, "SKILL.md"))) {
+      if (!existsSync7(join7(dir, "SKILL.md"))) {
         console.log(`${c.blocked("\u2717")} ${dir} has no SKILL.md (name and version come from its frontmatter)`);
         return 1;
       }
@@ -8818,7 +9273,7 @@ async function main() {
           console.error("usage: vet-skills policy set <file.yaml>");
           return 1;
         }
-        const text = readFileSync5(rest[1], "utf8");
+        const text = readFileSync6(rest[1], "utf8");
         parsePolicyYaml(text);
         writePolicy(text);
         console.log(`${c.verified("\u2713")} Personal policy updated.`);
@@ -8936,6 +9391,51 @@ async function main() {
       if (values.json) console.log(JSON.stringify(ds, null, 2));
       return 0;
     }
+    case "discover": {
+      const comps = discoverLocal({ project: values.project ? process.cwd() : void 0 });
+      if (values.json) {
+        console.log(JSON.stringify(comps, null, 2));
+      } else if (!values.quiet) {
+        if (!comps.length) console.log(c.muted("No agent configuration found in the usual places (~/.claude.json, ~/.cursor/mcp.json, Claude Desktop, Windsurf, Gemini CLI, Codex, ~/.claude/skills)."));
+        const runnable = comps.filter((x) => x.kind === "mcp_server" || x.kind === "skill");
+        const verdicts = /* @__PURE__ */ new Map();
+        await Promise.all(runnable.slice(0, 40).map(async (x) => {
+          const q = x.package ? x.package.name.replace(/^@/, "") : x.name;
+          const r = await resolveSkill(q, x.package?.registry);
+          const v = r.ok ? r.data.verdict : null;
+          verdicts.set(`${x.kind}|${x.name}`, v?.label ? `${v.label} ${v.score ?? ""}`.trim() : "not vetted");
+        }));
+        const kinds = [["mcp_server", "MCP servers"], ["skill", "Skills"], ["plugin", "Plugins"], ["hook", "Hooks"], ["instructions", "Instruction files"]];
+        for (const [k, label] of kinds) {
+          const list = comps.filter((x) => x.kind === k);
+          if (!list.length) continue;
+          console.log(`
+${label} (${list.length})`);
+          for (const x of list) {
+            const v = verdicts.get(`${x.kind}|${x.name}`);
+            const tone = !v ? c.muted : v.startsWith("verified") ? c.verified : v.startsWith("blocked") ? c.blocked : c.caution;
+            const what = x.package ? `${x.package.registry}:${x.package.name}` : x.urlHost ?? x.command ?? x.detail ?? "";
+            const keys = x.envKeys.length || x.headerKeys.length ? c.muted(` \xB7 ${[...x.envKeys, ...x.headerKeys].slice(0, 4).join(", ")}`) : "";
+            console.log(`  ${x.name.padEnd(28)} ${tone((v ?? "").padEnd(14))} ${c.muted(what)}${keys}  ${c.muted(x.path)}`);
+          }
+        }
+      }
+      if (readOrg()) {
+        const r = await discoverReport(comps);
+        if (r.ok) {
+          if (!values.json) console.log(`
+${c.verified("\u2713")} ${r.data.components} component${r.data.components === 1 ? "" : "s"} reported to ${readOrg().slug} (names only) \xB7 ${API}${r.data.dashboard}`);
+        } else {
+          console.error(c.caution(`report failed: ${r.error}`));
+          return 1;
+        }
+      } else if (!values.json && !values.quiet) console.log(c.muted("\nNot enrolled: nothing was sent. `vet-skills join <org> --token <t>` reports this to your team's Discovery page."));
+      return 0;
+    }
+    case "mcp": {
+      await serveMcp();
+      return 0;
+    }
     case "sync": {
       if (!readOrg()) {
         console.log(c.muted("Not joined to an org; nothing to sync."));