vet-skills 0.5.2 → 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 SKIP = /* @__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 = SKIP;
+    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 = SKIP;
+    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);
@@ -4011,10 +4011,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep, value } = collItem;
+        const { start, key, sep: sep2, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep?.[0],
+          next: key ?? sep2?.[0],
           offset,
           onError,
           parentIndent: bm.indent,
@@ -4028,7 +4028,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep) {
+          if (!keyProps.anchor && !keyProps.tag && !sep2) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -4052,7 +4052,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep ?? [], {
+        const valueProps = resolveProps.resolveProps(sep2 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -4068,7 +4068,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep2, null, valueProps, onError);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
           offset = valueNode.range[2];
@@ -4159,7 +4159,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep = "";
+        let sep2 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -4173,13 +4173,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep + cb;
-              sep = "";
+                comment += sep2 + cb;
+              sep2 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep += source;
+                sep2 += source;
               hasSpace = true;
               break;
             default:
@@ -4222,18 +4222,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key, sep, value } = collItem;
+        const { start, key, sep: sep2, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep?.[0],
+          next: key ?? sep2?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep && !value) {
+          if (!props.anchor && !props.tag && !sep2 && !value) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -4287,8 +4287,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep, null, props, onError);
+        if (!isMap && !sep2 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep2, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -4300,7 +4300,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep ?? [], {
+          const valueProps = resolveProps.resolveProps(sep2 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -4311,8 +4311,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep)
-                for (const st of sep) {
+              if (sep2)
+                for (const st of sep2) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -4329,7 +4329,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep2, null, valueProps, onError) : null;
           if (valueNode) {
             if (isBlock(value))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -4509,7 +4509,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i + 1;
       }
       let value = "";
-      let sep = "";
+      let sep2 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
         value += lines[i][0].slice(trimIndent) + "\n";
@@ -4526,24 +4526,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep + indent.slice(trimIndent) + content;
-          sep = "\n";
+          value += sep2 + indent.slice(trimIndent) + content;
+          sep2 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep === " ")
-            sep = "\n";
-          else if (!prevMoreIndented && sep === "\n")
-            sep = "\n\n";
-          value += sep + indent.slice(trimIndent) + content;
-          sep = "\n";
+          if (sep2 === " ")
+            sep2 = "\n";
+          else if (!prevMoreIndented && sep2 === "\n")
+            sep2 = "\n\n";
+          value += sep2 + indent.slice(trimIndent) + content;
+          sep2 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep === "\n")
+          if (sep2 === "\n")
             value += "\n";
           else
-            sep = "\n";
+            sep2 = "\n";
         } else {
-          value += sep + content;
-          sep = " ";
+          value += sep2 + content;
+          sep2 = " ";
           prevMoreIndented = false;
         }
       }
@@ -4726,25 +4726,25 @@ var require_resolve_flow_scalar = __commonJS({
         trimBoth = /^[ \t]+|[ \t]+$/g;
       }
       let res = match[1].replace(trimEnd, "");
-      let sep = " ";
+      let sep2 = " ";
       let pos = line.lastIndex;
       while (match = line.exec(source)) {
         const lm = match[1].replace(trimBoth, "");
         if (lm === "") {
-          if (sep === "\n")
-            res += sep;
+          if (sep2 === "\n")
+            res += sep2;
           else
-            sep = "\n";
+            sep2 = "\n";
         } else {
-          res += sep + lm;
-          sep = " ";
+          res += sep2 + lm;
+          sep2 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source);
-      return res + sep + (match?.[1] ?? "");
+      return res + sep2 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError) {
       let res = "";
@@ -5554,14 +5554,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep, value }) {
+    function stringifyItem({ start, key, sep: sep2, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep)
-        for (const st of sep)
+      if (sep2)
+        for (const st of sep2)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -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 SKIP = /* @__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 = SKIP;
+    visit.SKIP = SKIP3;
     visit.REMOVE = REMOVE;
     visit.itemAtPath = (cst, path) => {
       let item = cst;
@@ -6728,18 +6728,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep;
+          let sep2;
           if (scalar.end) {
-            sep = scalar.end;
-            sep.push(this.sourceToken);
+            sep2 = scalar.end;
+            sep2.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep = [this.sourceToken];
+            sep2 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep }]
+            items: [{ start, key: scalar, sep: sep2 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -6892,15 +6892,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep = it.sep;
-                  sep.push(this.sourceToken);
+                  const sep2 = it.sep;
+                  sep2.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key, sep }]
+                    items: [{ start: start2, key, sep: sep2 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -7094,13 +7094,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep = fc.end.splice(1, fc.end.length);
-            sep.push(this.sourceToken);
+            const sep2 = fc.end.splice(1, fc.end.length);
+            sep2.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep }]
+              items: [{ start, key: fc, sep: sep2 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -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 readFileSync3, existsSync as existsSync4 } from "node:fs";
-import { resolve, join as join4, 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 } from "node:crypto";
-import { createInterface } from "node:readline";
+import { createHash as createHash2 } from "node:crypto";
+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.5.2";
+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;
@@ -7805,6 +8086,11 @@ function report(body) {
   if (!org) return Promise.resolve({ ok: false, error: "not joined", offline: false });
   return call(`/api/v1/orgs/${org.slug}/agents/${org.agentId}/report`, { method: "POST", body: JSON.stringify(body), headers: orgHeaders() }, 8e3);
 }
+function runtimeReport(body) {
+  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}/runtime`, { method: "POST", body: JSON.stringify(body), headers: orgHeaders() }, 6e3);
+}
 function confirmRemoval(removalId, body) {
   const org = readOrg();
   if (!org) return Promise.resolve({ ok: false, error: "not joined", offline: false });
@@ -7822,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";
@@ -7864,6 +8155,151 @@ function fmtInstalls(n) {
   return n.toLocaleString("en-US");
 }
 
+// src/attest.ts
+import { createHash, createPublicKey, verify as cryptoVerify } from "node:crypto";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2, relative, resolve, sep } from "node:path";
+var LOCKFILE = "vet-skills.lock";
+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 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()) walk2(p);
+      else if (st.isFile() && st.size <= 2 * 1024 * 1024) {
+        h.update(relative(root, p).split(sep).join("/"));
+        h.update("\0");
+        h.update(readFileSync2(p));
+        h.update("\0");
+      }
+    }
+  };
+  walk2(root);
+  return h.digest("hex");
+}
+function pae(payloadType, payload) {
+  const t = Buffer.from(payloadType);
+  return Buffer.concat([Buffer.from(`DSSEv1 ${t.length} `), t, Buffer.from(` ${payload.length} `), payload]);
+}
+function verifyEnvelope(env, keys) {
+  if (env.payloadType !== PAYLOAD_TYPE) return { ok: false, statement: null, kid: null, reason: `unexpected payload type ${env.payloadType}` };
+  const payload = Buffer.from(env.payload, "base64");
+  const trusted = (process.env.VET_SKILLS_TRUSTED_KEYS ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+  for (const sig of env.signatures) {
+    const k = keys.find((x) => x.kid === sig.keyid);
+    if (!k) continue;
+    if (trusted.length && !trusted.includes(k.kid)) return { ok: false, statement: null, kid: k.kid, reason: `key ${k.kid} is not in VET_SKILLS_TRUSTED_KEYS` };
+    if (k.dev) return { ok: false, statement: null, kid: k.kid, reason: "signed with a development key" };
+    try {
+      const pub = createPublicKey({ key: { kty: k.kty, crv: k.crv, x: k.x }, format: "jwk" });
+      if (cryptoVerify(null, pae(env.payloadType, payload), pub, Buffer.from(sig.sig, "base64"))) return { ok: true, statement: JSON.parse(payload.toString("utf8")), kid: k.kid, reason: "signature valid" };
+      return { ok: false, statement: null, kid: k.kid, reason: "signature does not verify" };
+    } catch (e) {
+      return { ok: false, statement: null, kid: k.kid, reason: e.message };
+    }
+  }
+  return { ok: false, statement: null, kid: env.signatures[0]?.keyid ?? null, reason: "no known key for this signature" };
+}
+async function getJson(url) {
+  try {
+    const r = await fetch(url, { headers: { accept: "application/json", "user-agent": `vet-skills/${VERSION}` }, signal: AbortSignal.timeout(8e3) });
+    return r.ok ? await r.json() : null;
+  } catch {
+    return null;
+  }
+}
+async function fetchKeys() {
+  const r = await getJson(`${API}/.well-known/killerskills-keys.json`);
+  return r?.keys ?? [];
+}
+async function fetchAttestationByHash(hash) {
+  return getJson(`${API}/api/v1/verdicts/${hash}/attestation`);
+}
+function installedSkills() {
+  const out = [];
+  for (const base of [join2(process.cwd(), ".claude", "skills"), join2(homedir2(), ".claude", "skills"), join2(homedir2(), ".claude", "plugins")]) {
+    if (!existsSync2(base)) continue;
+    for (const name of readdirSync(base).sort()) {
+      const p = join2(base, name);
+      if (statSync2(p).isDirectory() && !out.some((x) => x.name === name)) out.push({ name, path: p });
+    }
+  }
+  return out;
+}
+async function verifyOne(target, keys) {
+  const dir = resolve(target);
+  let hash;
+  let subject = target;
+  let page = null;
+  if (existsSync2(dir) && statSync2(dir).isDirectory()) {
+    hash = bundleHash(dir);
+    subject = `${target} (${hash.slice(0, 12)}\u2026)`;
+  } else {
+    const [name, ver] = target.split("@").length > 2 ? [target.slice(0, target.lastIndexOf("@")), target.slice(target.lastIndexOf("@") + 1)] : target.includes("@") && !target.startsWith("@") ? target.split("@") : [target, void 0];
+    const r = await resolveSkill(name);
+    if (!r.ok) return { subject, hash: "", ok: false, detail: r.offline ? "offline" : `not found: ${r.error}`, statement: null };
+    if (ver && r.data.version.semver !== ver) return { subject, hash: "", ok: false, detail: `latest scored version is ${r.data.version.semver}; verify a local checkout of ${ver} with a path instead`, statement: null };
+    hash = r.data.version.artifact_hash;
+    page = r.data.skill.page;
+    subject = `${r.data.skill.name}@${r.data.version.semver}`;
+    const local = installedSkills().find((s) => s.name === r.data.skill.name);
+    if (local) {
+      const lh = bundleHash(local.path);
+      if (lh !== hash) return { subject, hash: lh, ok: false, detail: `installed copy at ${local.path} hashes to ${lh.slice(0, 12)}\u2026, attested version is ${hash.slice(0, 12)}\u2026`, statement: null };
+    }
+  }
+  const env = await fetchAttestationByHash(hash);
+  if (!env) return { subject, hash, ok: false, detail: `no attestation for ${hash.slice(0, 12)}\u2026 (unscored, demo or signing not configured)${page ? ` \xB7 ${API}${page}` : ""}`, statement: null };
+  const v = verifyEnvelope(env, keys);
+  if (!v.ok || !v.statement) return { subject, hash, ok: false, detail: v.reason, statement: null };
+  if (v.statement.subject.artifact_hash !== hash) return { subject, hash, ok: false, detail: "attestation is for a different artifact", statement: v.statement };
+  return { subject, hash, ok: true, detail: `${v.statement.predicate.label} ${v.statement.predicate.score} \xB7 engine ${v.statement.predicate.engine_version} \xB7 signed by ${v.kid}${v.statement.predicate.superseded ? " \xB7 superseded" : ""}`, statement: v.statement };
+}
+async function writeLock(dir = process.cwd()) {
+  const keys = await fetchKeys();
+  const skills = [];
+  const missing = [];
+  for (const s of installedSkills()) {
+    const hash = bundleHash(s.path);
+    const env = await fetchAttestationByHash(hash);
+    const v = env ? verifyEnvelope(env, keys) : null;
+    if (!v?.ok || !v.statement) missing.push(s.name);
+    skills.push({ name: s.name, path: s.path, artifact_hash: hash, verdict: v?.statement ? { id: v.statement.predicate.verdict_id, label: v.statement.predicate.label, score: v.statement.predicate.score, engine_version: v.statement.predicate.engine_version } : null, attestation: v?.ok ? env : null });
+  }
+  const lock = { version: 1, generated_at: (/* @__PURE__ */ new Date()).toISOString(), generated_by: `vet-skills ${VERSION}`, issuer: API, keys: keys.filter((k) => !k.dev), skills };
+  const file = join2(dir, LOCKFILE);
+  writeFileSync2(file, `${JSON.stringify(lock, null, 2)}
+`);
+  return { file, lock, missing };
+}
+function readLock(dir = process.cwd()) {
+  const file = join2(dir, LOCKFILE);
+  if (!existsSync2(file)) return null;
+  try {
+    return JSON.parse(readFileSync2(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function verifyLock(lock) {
+  return lock.skills.map((e) => {
+    const path = existsSync2(e.path) ? e.path : installedSkills().find((s) => s.name === e.name)?.path;
+    if (!path) return { subject: e.name, hash: e.artifact_hash, ok: false, detail: "not installed", statement: null };
+    const hash = bundleHash(path);
+    if (hash !== e.artifact_hash) return { subject: e.name, hash, ok: false, detail: `changed on disk: ${hash.slice(0, 12)}\u2026 (locked ${e.artifact_hash.slice(0, 12)}\u2026)`, statement: null };
+    if (!e.attestation) return { subject: e.name, hash, ok: true, detail: "hash matches \xB7 pinned by hash only (no attestation when locked)", statement: null };
+    const v = verifyEnvelope(e.attestation, lock.keys);
+    if (!v.ok || !v.statement) return { subject: e.name, hash, ok: false, detail: v.reason, statement: null };
+    if (v.statement.subject.artifact_hash !== hash) return { subject: e.name, hash, ok: false, detail: "attestation is for a different artifact", statement: v.statement };
+    return { subject: e.name, hash, ok: true, detail: `${v.statement.predicate.label} ${v.statement.predicate.score} \xB7 engine ${v.statement.predicate.engine_version} \xB7 signed by ${v.kid}`, statement: v.statement };
+  });
+}
+
 // src/check.ts
 function toVerdictInput(r) {
   if (!r.verdict) return null;
@@ -7945,6 +8381,12 @@ async function check(q, opts = {}) {
     if (telemetryNoticePending()) process.stderr.write(c.muted("vet-skills sends anonymous usage (skill name, version, decision, agent type; never code, prompts or paths). Opt out: vet-skills telemetry off") + "\n");
     await sendTelemetry({ skill: resolved?.skill.name ?? q, semver: resolved?.version.semver ?? null, registry: resolved?.skill.registry ?? null, decision: decision.decision, would_be: decision.wouldBe ?? null, agent_kind: opts.agentKind ?? "other", hook_version: VERSION, os: platform(), offline }).catch(() => null);
   }
+  const lock = readLock();
+  const pinned = lock && resolved ? lock.skills.find((e) => e.name === resolved.skill.name) : null;
+  if (pinned && resolved && pinned.artifact_hash !== resolved.version.artifact_hash) {
+    const why = `vet-skills.lock pins ${resolved.skill.name} to ${pinned.artifact_hash.slice(0, 12)}\u2026; registry has ${resolved.version.artifact_hash.slice(0, 12)}\u2026 (${resolved.version.semver}). Run \`vet-skills lock\` to accept it.`;
+    return { resolved, decision: { ...decision, decision: "block", wouldBe: "block", reason: why }, source, cacheAge, remote, offline, policyLabel };
+  }
   return { resolved, decision, source, cacheAge, remote, offline, policyLabel };
 }
 function renderCheck(r) {
@@ -8027,18 +8469,183 @@ function restrictionText(r) {
   return parts.join(" \xB7 ") || "no restrictions";
 }
 
-// src/hook.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+// 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 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 existsSync2, rmSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } 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 [join2(homedir2(), ".claude", "skills", bare), join2(process.cwd(), ".claude", "skills", bare), join2(homedir2(), ".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 = () => {
 }) {
@@ -8049,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) => existsSync2(d));
+      const dirs = skillDirs(it.skill).filter((d) => existsSync4(d));
       if (!dirs.length) {
         detail.push(`${it.skill}: not on disk`);
         continue;
@@ -8200,24 +8807,201 @@ ${out}
   return 0;
 }
 function installClaudeCodeHook() {
-  const dir = join3(homedir3(), ".claude");
-  const path = join3(dir, "settings.json");
-  if (!existsSync3(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 (existsSync3(path)) {
+  if (existsSync5(path)) {
     try {
-      settings = JSON.parse(readFileSync2(path, "utf8"));
+      settings = JSON.parse(readFileSync4(path, "utf8"));
     } catch {
       settings = {};
     }
   }
   const hooks = settings.hooks ??= {};
   const pre = hooks.PreToolUse ??= [];
-  const already = pre.some((h) => h.hooks?.some((x) => /vet-skills hook eval/.test(x.command)));
-  if (already) return { path, changed: false };
-  pre.push({ matcher: "Bash", hooks: [{ type: "command", command: "vet-skills hook eval" }] });
-  writeFileSync2(path, JSON.stringify(settings, null, 2) + "\n");
-  return { path, changed: true };
+  const post = hooks.PostToolUse ??= [];
+  let changed = false;
+  if (!pre.some((h) => h.hooks?.some((x) => /vet-skills hook eval/.test(x.command)))) {
+    pre.push({ matcher: "Bash", hooks: [{ type: "command", command: "vet-skills hook eval" }] });
+    changed = true;
+  }
+  if (!post.some((h) => h.hooks?.some((x) => /vet-skills hook observe/.test(x.command)))) {
+    post.push({ matcher: "Bash|Read|Write|Edit|MultiEdit|NotebookEdit|WebFetch|Skill|mcp__.*", hooks: [{ type: "command", command: "vet-skills hook observe" }] });
+    changed = true;
+  }
+  if (changed) writeFileSync3(path, JSON.stringify(settings, null, 2) + "\n");
+  return { path, changed };
+}
+
+// src/runtime.ts
+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 = join6(HOME, "runtime");
+function sessionFile(id) {
+  return join6(DIR, `${id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 80)}.json`);
+}
+function readSession(id) {
+  try {
+    return JSON.parse(readFileSync5(sessionFile(id), "utf8"));
+  } catch {
+    return { active: null, verdicts: {}, reported: [] };
+  }
+}
+function writeSession(id, s) {
+  if (!existsSync6(DIR)) mkdirSync3(DIR, { recursive: true });
+  writeFileSync4(sessionFile(id), JSON.stringify(s));
+}
+function hostsIn(cmd2) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of cmd2.matchAll(/https?:\/\/([a-zA-Z0-9.-]+\.[a-zA-Z]{2,}|\d{1,3}(?:\.\d{1,3}){3})(?::\d+)?/g)) out.add(m[1].toLowerCase());
+  for (const m of cmd2.matchAll(/\b(?:ssh|scp|sftp|nc|ncat|netcat|telnet)\s+(?:-\S+\s+)*(?:[\w.-]+@)?([a-zA-Z0-9.-]+\.[a-zA-Z]{2,}|\d{1,3}(?:\.\d{1,3}){3})/g)) out.add(m[1].toLowerCase());
+  return [...out];
+}
+function pathsIn(cmd2) {
+  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)) 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(homedir6(), "~");
+function attributed(session, toolName) {
+  const m = toolName.match(/^mcp__([^_]+(?:_[^_]+)*?)__/);
+  if (m) return m[1];
+  if (session.active && Date.now() - session.active.since < ACTIVE_MS) return session.active.skill;
+  return null;
+}
+async function verdictFor(session, skill) {
+  const c2 = session.verdicts[skill];
+  if (c2 && Date.now() - c2.at < 36e5) return c2.r;
+  const r = await resolveSkill(skill).catch(() => null);
+  session.verdicts[skill] = { at: Date.now(), r: r && r.ok ? r.data : null };
+  return session.verdicts[skill].r;
+}
+function parseToolEvent(toolName, input) {
+  const o = { kind: "other", hosts: [], read: [], written: [], skillInvoked: null };
+  if (toolName === "Skill") {
+    o.kind = "Skill";
+    o.skillInvoked = String(input.skill ?? input.name ?? input.command ?? "").replace(/^\//, "").split(/\s/)[0] || null;
+    return o;
+  }
+  if (toolName === "Bash" && typeof input.command === "string") {
+    o.kind = "Bash";
+    o.hosts = hostsIn(input.command);
+    const p = pathsIn(input.command);
+    o.read = p.read;
+    o.written = p.written;
+    return o;
+  }
+  if (toolName === "Read" && typeof input.file_path === "string") {
+    o.kind = "Read";
+    o.read = [tilde(input.file_path)];
+    return o;
+  }
+  if ((toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit" || toolName === "NotebookEdit") && typeof input.file_path === "string") {
+    o.kind = "Write";
+    o.written = [tilde(input.file_path)];
+    return o;
+  }
+  if (toolName === "WebFetch" && typeof input.url === "string") {
+    o.kind = "WebFetch";
+    try {
+      o.hosts = [new URL(input.url).hostname.toLowerCase()];
+    } catch {
+    }
+    return o;
+  }
+  if (toolName.startsWith("mcp__")) o.kind = "mcp";
+  return o;
+}
+function deviations(skill, r, o, tool, session) {
+  const out = [];
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const semver = r?.version.semver ?? null;
+  const page = r?.skill.page ?? null;
+  const trace = r?.trace_summary ?? null;
+  const declared = new Set((r?.version.declared_permissions.network ?? []).map((h) => h.toLowerCase()));
+  const seenHosts = new Set((trace?.egress_hosts ?? []).map((h) => h.host.toLowerCase()));
+  const seenReads = trace?.files_read ?? [];
+  const seenWrites = trace?.files_written ?? [];
+  const mk = (kind, detail) => out.push({ kind, skill, semver, detail, tool, at, session, page });
+  for (const h of o.hosts) if (!declared.has(h) && !seenHosts.has(h) && !/^(localhost|127\.0\.0\.1|registry\.npmjs\.org|pypi\.org|files\.pythonhosted\.org|github\.com|api\.github\.com|raw\.githubusercontent\.com|killerskills\.ai)$/.test(h)) mk("egress_unexpected", `contacted ${h}; the sandbox saw ${seenHosts.size ? [...seenHosts].slice(0, 3).join(", ") : "no network activity"}${declared.size ? ` and it declares ${[...declared].join(", ")}` : ""}`);
+  for (const p of o.read) if (CRED.test(p) && !seenReads.some((s) => s.includes(p.replace(/^~\//, "")))) mk("credential_read", `read ${p}; the sandbox never saw a credential path read`);
+  for (const p of o.written) {
+    if (MEMORY.test(p) && !trace?.memory_writes.length) mk("memory_write", `wrote ${p}; the sandbox saw no memory or instruction-file writes`);
+    else if (isOutsideProject(p) && !CRED.test(p) && !MEMORY.test(p) && !seenWrites.some((s) => s.includes(p.replace(/^~\//, "")))) mk("outside_project_write", `wrote ${p}, outside the project; not seen in the sandbox`);
+  }
+  return out;
+}
+var LOG = join6(HOME, "runtime", "deviations.jsonl");
+function appendDeviations(ds) {
+  if (!ds.length) return;
+  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 (!existsSync6(LOG)) return [];
+  const since = Date.now() - days * 864e5;
+  return readFileSync5(LOG, "utf8").split("\n").filter(Boolean).map((l) => {
+    try {
+      return JSON.parse(l);
+    } catch {
+      return null;
+    }
+  }).filter((d) => !!d && Date.parse(d.at) >= since);
+}
+async function observe(stdin) {
+  let payload = {};
+  try {
+    payload = JSON.parse(stdin);
+  } catch {
+    return { code: 0, lines: [] };
+  }
+  const tool = payload.tool_name ?? "";
+  const input = payload.tool_input ?? {};
+  const sid = payload.session_id ?? "default";
+  const session = readSession(sid);
+  const o = parseToolEvent(tool, input);
+  if (o.kind === "Skill") {
+    if (o.skillInvoked) session.active = { skill: o.skillInvoked, since: Date.now() };
+    writeSession(sid, session);
+    return { code: 0, lines: [] };
+  }
+  const skill = attributed(session, tool);
+  if (!skill || !o.hosts.length && !o.read.length && !o.written.length) return { code: 0, lines: [] };
+  const r = await verdictFor(session, skill);
+  const ds = deviations(skill, r, o, tool, payload.session_id ?? null).filter((d) => {
+    const k = `${d.skill}|${d.kind}|${d.detail.split(";")[0]}`;
+    if (session.reported.includes(k)) return false;
+    session.reported.push(k);
+    return true;
+  });
+  writeSession(sid, session);
+  if (!ds.length) return { code: 0, lines: [] };
+  appendDeviations(ds);
+  if (readOrg()) await runtimeReport({ events: ds.map((d) => ({ skill: d.skill, semver: d.semver, kind: d.kind, detail: d.detail, tool: d.tool, at: d.at, session: d.session })) }).catch(() => null);
+  const lines = ds.map((d) => `vet-skills \u26A0 ${d.skill}${d.semver ? `@${d.semver}` : ""} ${d.detail}. Not what its verdict is based on${d.page ? `: https://killerskills.ai${d.page}` : ""}`);
+  const serious = ds.some((d) => d.kind === "egress_unexpected" || d.kind === "credential_read");
+  return { code: serious ? 2 : 0, lines };
+}
+function pruneSessions() {
+  if (!existsSync6(DIR)) return;
+  for (const f of readdirSync3(DIR)) {
+    if (!f.endsWith(".json")) continue;
+    const p = join6(DIR, f);
+    try {
+      if (Date.now() - statSync4(p).mtimeMs > 864e5) writeFileSync4(p, "{}");
+    } catch {
+    }
+  }
 }
 
 // src/index.ts
@@ -8228,10 +9012,13 @@ var { values, positionals } = parseArgs({
     reason: { type: "string" },
     org: { type: "string" },
     yes: { type: "boolean", short: "y" },
+    lock: { type: "boolean" },
     json: { type: "boolean" },
     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" },
@@ -8240,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];
@@ -8264,9 +9051,15 @@ 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
+  vet-skills verify --lock              offline: installed skills still match the lock and signatures verify
   vet-skills hook install claude-code   register the Claude Code PreToolUse hook
   vet-skills hook eval                  (called by the agent) read hook JSON on stdin
+  vet-skills runtime                    what installed skills did in real sessions that the sandbox never saw
 
 Docs: https://killerskills.ai/docs/cli
 `;
@@ -8344,8 +9137,8 @@ async function main() {
         usage();
         return 1;
       }
-      const dir = resolve(rest[0]);
-      if (!existsSync4(join4(dir, "SKILL.md")) && !existsSync4(join4(dir, "package.json"))) {
+      const dir = resolve2(rest[0]);
+      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;
       }
@@ -8387,8 +9180,8 @@ async function main() {
         console.log(`${c.blocked("\u2717")} not enrolled in an organization. Run ${c.bold("vet-skills join <org> --token \u2026")} first.`);
         return 1;
       }
-      const dir = resolve(rest[0]);
-      if (!existsSync4(join4(dir, "SKILL.md"))) {
+      const dir = resolve2(rest[0]);
+      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;
       }
@@ -8432,7 +9225,7 @@ async function main() {
         console.error("usage: vet-skills join <org> --token <enroll token>");
         return 1;
       }
-      const machineId = createHash("sha256").update(`${hostname()}:${userInfo().username}`).digest("hex");
+      const machineId = createHash2("sha256").update(`${hostname()}:${userInfo().username}`).digest("hex");
       const res = await enroll(slug, values.token, {
         developer_email: values.email,
         machine_id: machineId,
@@ -8480,7 +9273,7 @@ async function main() {
           console.error("usage: vet-skills policy set <file.yaml>");
           return 1;
         }
-        const text = readFileSync3(rest[1], "utf8");
+        const text = readFileSync6(rest[1], "utf8");
         parsePolicyYaml(text);
         writePolicy(text);
         console.log(`${c.verified("\u2713")} Personal policy updated.`);
@@ -8550,6 +9343,99 @@ async function main() {
       }
       return 0;
     }
+    case "verify": {
+      if (values.lock) {
+        const lock = readLock();
+        if (!lock) {
+          console.log(c.caution(`no ${LOCKFILE} in ${process.cwd()}; run \`vet-skills lock\` first`));
+          return 1;
+        }
+        const rs = verifyLock(lock);
+        for (const r2 of rs) console.log(`${r2.ok ? c.verified("\u2713") : c.blocked("\u2717")} ${r2.subject}  ${c.muted(r2.detail)}`);
+        const bad = rs.filter((r2) => !r2.ok).length;
+        console.log(bad ? c.blocked(`${bad} of ${rs.length} failed`) : c.verified(`${rs.length} skill${rs.length === 1 ? "" : "s"} verified against ${LOCKFILE} (offline, ${lock.keys.length} pinned key${lock.keys.length === 1 ? "" : "s"})`));
+        if (values.json) console.log(JSON.stringify(rs, null, 2));
+        return bad ? 1 : 0;
+      }
+      if (!rest[0]) {
+        console.log(c.caution("usage: vet-skills verify <skill>[@version] | <path> | --lock"));
+        return 1;
+      }
+      const keys = await fetchKeys();
+      if (!keys.length) console.log(c.caution(`could not fetch signing keys from ${API}/.well-known/killerskills-keys.json`));
+      const r = await verifyOne(rest[0], keys);
+      console.log(`${r.ok ? c.verified("\u2713 verified") : c.blocked("\u2717 not verified")} ${r.subject}
+  ${r.detail}`);
+      if (values.json) console.log(JSON.stringify(r, null, 2));
+      return r.ok ? 0 : 1;
+    }
+    case "lock": {
+      const { file, lock, missing } = await writeLock();
+      console.log(`${c.verified("\u2713")} wrote ${file}: ${lock.skills.length} skill${lock.skills.length === 1 ? "" : "s"}, ${lock.keys.length} signing key${lock.keys.length === 1 ? "" : "s"} pinned`);
+      for (const s of lock.skills) console.log(`  ${s.attestation ? c.verified("\u2713") : c.caution("\xB7")} ${s.name}  ${c.muted(s.verdict ? `${s.verdict.label} ${s.verdict.score}` : "no attestation (unscored or never crawled)")}`);
+      if (missing.length) console.log(c.muted(`${missing.length} without an attestation are pinned by hash only; \`vet-skills verify --lock\` reports them.`));
+      return 0;
+    }
+    case "runtime": {
+      const ds = readDeviations(7);
+      if (!ds.length) {
+        console.log(c.muted("No deviations in the last 7 days: installed skills behaved the way the sandbox saw them (or no skill ran)."));
+        return 0;
+      }
+      const by = /* @__PURE__ */ new Map();
+      for (const d of ds) by.set(d.skill, [...by.get(d.skill) ?? [], d]);
+      for (const [skill, list] of by) {
+        console.log(`${c.caution("\u26A0")} ${skill}${list[0].semver ? `@${list[0].semver}` : ""}  ${c.muted(`${list.length} deviation${list.length === 1 ? "" : "s"}${list[0].page ? ` \xB7 killerskills.ai${list[0].page}` : ""}`)}`);
+        for (const d of list.slice(-6)) console.log(`   ${d.at.slice(0, 16).replace("T", " ")}  ${d.kind.replace("_", " ")}  ${d.detail}`);
+      }
+      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."));
@@ -8570,6 +9456,18 @@ async function main() {
         for await (const ch of process.stdin) chunks.push(ch);
         return hookEval(Buffer.concat(chunks).toString("utf8"));
       }
+      if (sub === "observe") {
+        const chunks = [];
+        for await (const ch of process.stdin) chunks.push(ch);
+        try {
+          const r = await observe(Buffer.concat(chunks).toString("utf8"));
+          for (const l of r.lines) process.stderr.write(l + "\n");
+          if (Math.random() < 0.02) pruneSessions();
+          return r.code;
+        } catch {
+          return 0;
+        }
+      }
       if (sub === "install") {
         const target = rest[1] ?? "claude-code";
         if (target !== "claude-code") {
@@ -8578,7 +9476,7 @@ async function main() {
         }
         const r = installClaudeCodeHook();
         console.log(r.changed ? `${c.verified("\u2713")} Claude Code hook installed in ${r.path}` : c.muted(`Hook already present in ${r.path}`));
-        console.log(c.muted("Every `skills add`, `claude plugin install`, and `claude mcp add` is now checked before it runs."));
+        console.log(c.muted("Every `skills add`, `claude plugin install`, and `claude mcp add` is now checked before it runs, and what skills do in sessions is compared with their sandbox trace (vet-skills runtime)."));
         return 0;
       }
       usage();