vet-skills 0.5.1 → 0.6.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 SKIP2 = /* @__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 = SKIP2;
     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 = SKIP2;
     visitAsync.REMOVE = REMOVE;
     async function visitAsync_(key, node, visitor, path) {
       const ctrl = await callVisitor(key, node, visitor, path);
@@ -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 SKIP2 = /* @__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 = SKIP2;
     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;
@@ -7614,10 +7614,10 @@ 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 readFileSync5, existsSync as existsSync6 } from "node:fs";
+import { resolve as resolve2, join as join6, dirname, basename } from "node:path";
 import { hostname, platform as platform2, userInfo } from "node:os";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { createInterface } from "node:readline";
 
 // src/check.ts
@@ -7629,7 +7629,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.1";
+var VERSION = "0.6.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 +7805,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 });
@@ -7864,6 +7869,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 walk = (dir) => {
+    for (const name of readdirSync(dir).sort()) {
+      if (SKIP.has(name)) continue;
+      const p = join2(dir, name);
+      const st = statSync2(p);
+      if (st.isDirectory()) walk(p);
+      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");
+      }
+    }
+  };
+  walk(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 +8095,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) {
@@ -8028,17 +8184,17 @@ function restrictionText(r) {
 }
 
 // src/hook.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
 
 // 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 existsSync3, rmSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } 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 [join3(homedir3(), ".claude", "skills", bare), join3(process.cwd(), ".claude", "skills", bare), join3(homedir3(), ".claude", "plugins", bare)];
 }
 async function applyRemovals(pending, log = () => {
 }) {
@@ -8049,7 +8205,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) => existsSync3(d));
       if (!dirs.length) {
         detail.push(`${it.skill}: not on disk`);
         continue;
@@ -8200,24 +8356,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 = join4(homedir4(), ".claude");
+  const path = join4(dir, "settings.json");
+  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
   let settings = {};
-  if (existsSync3(path)) {
+  if (existsSync4(path)) {
     try {
-      settings = JSON.parse(readFileSync2(path, "utf8"));
+      settings = JSON.parse(readFileSync3(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 existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join5 } from "node:path";
+var ACTIVE_MS = 30 * 6e4;
+var CRED = /(^|\/)(\.ssh|\.aws|\.npmrc|\.netrc|\.config\/gh|\.docker\/config\.json|\.kube\/config|\.gnupg|credentials|\.env(\.|$)|id_(rsa|ed25519|ecdsa)|keychain)/i;
+var MEMORY = /(^|\/)(MEMORY\.md|CLAUDE\.md|AGENTS\.md|\.cursorrules|\.clinerules|\.windsurfrules|GEMINI\.md|\.github\/copilot-instructions\.md)$/i;
+var DIR = join5(HOME, "runtime");
+function sessionFile(id) {
+  return join5(DIR, `${id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 80)}.json`);
+}
+function readSession(id) {
+  try {
+    return JSON.parse(readFileSync4(sessionFile(id), "utf8"));
+  } catch {
+    return { active: null, verdicts: {}, reported: [] };
+  }
+}
+function writeSession(id, s) {
+  if (!existsSync5(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 read = /* @__PURE__ */ new Set();
+  const written = /* @__PURE__ */ new Set();
+  const norm = (p) => p.replace(/^\$HOME/, "~").replace(/^["']|["']$/g, "");
+  for (const m of cmd2.matchAll(/(?:>>?|tee\s+(?:-a\s+)?)\s*["']?((?:~|\/|\$HOME)[^\s"'|;&]+)/g)) written.add(norm(m[1]));
+  for (const m of cmd2.matchAll(/(?:^|[\s|;&(])(?:cat|less|head|tail|grep|cp|scp|base64|xxd|od|strings|python3?|node)\s+(?:-\S+\s+)*["']?((?:~|\/|\$HOME)[^\s"'|;&]+)/g)) read.add(norm(m[1]));
+  for (const m of cmd2.matchAll(/["']?((?:~|\$HOME)\/\.(?:ssh|aws|npmrc|netrc|config\/gh|docker|kube|gnupg)[^\s"'|;&]*)/g)) if (!written.has(norm(m[1]))) read.add(norm(m[1]));
+  return { read: [...read], written: [...written] };
+}
+var isOutsideProject = (p) => (p.startsWith("~") || p.startsWith("/")) && !p.startsWith(process.cwd()) && !p.startsWith("/tmp") && !p.startsWith("/dev");
+var tilde = (p) => p.replace(homedir5(), "~");
+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 = join5(HOME, "runtime", "deviations.jsonl");
+function appendDeviations(ds) {
+  if (!ds.length) return;
+  if (!existsSync5(DIR)) mkdirSync3(DIR, { recursive: true });
+  writeFileSync4(LOG, ds.map((d) => JSON.stringify(d)).join("\n") + "\n", { flag: "a" });
+}
+function readDeviations(days = 7) {
+  if (!existsSync5(LOG)) return [];
+  const since = Date.now() - days * 864e5;
+  return readFileSync4(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 (!existsSync5(DIR)) return;
+  for (const f of readdirSync2(DIR)) {
+    if (!f.endsWith(".json")) continue;
+    const p = join5(DIR, f);
+    try {
+      if (Date.now() - statSync3(p).mtimeMs > 864e5) writeFileSync4(p, "{}");
+    } catch {
+    }
+  }
 }
 
 // src/index.ts
@@ -8228,6 +8561,7 @@ 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" },
@@ -8265,8 +8599,12 @@ Get started:
   vet-skills block <skill> [--reason]   add to the personal block list
   vet-skills status                     org, policy version, last report, cache size
   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 +8682,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 (!existsSync6(join6(dir, "SKILL.md")) && !existsSync6(join6(dir, "package.json"))) {
         console.log(`${c.blocked("\u2717")} ${dir} has no SKILL.md or package.json`);
         return 1;
       }
@@ -8387,8 +8725,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 (!existsSync6(join6(dir, "SKILL.md"))) {
         console.log(`${c.blocked("\u2717")} ${dir} has no SKILL.md (name and version come from its frontmatter)`);
         return 1;
       }
@@ -8432,7 +8770,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 +8818,7 @@ async function main() {
           console.error("usage: vet-skills policy set <file.yaml>");
           return 1;
         }
-        const text = readFileSync3(rest[1], "utf8");
+        const text = readFileSync5(rest[1], "utf8");
         parsePolicyYaml(text);
         writePolicy(text);
         console.log(`${c.verified("\u2713")} Personal policy updated.`);
@@ -8506,6 +8844,15 @@ async function main() {
       console.log(`${c.verified("\u2713")} ${handle} added to the personal block list${values.reason ? ` (${values.reason})` : ""}.`);
       return 0;
     }
+    case "bug": {
+      const last = readLog().at(-1);
+      const qs = new URLSearchParams({ kind: "bug", source: "cli", cli_version: VERSION, ...last ? { skill: `${last.skill}@${last.semver}`, decision: last.decision } : {} });
+      const url = `${API}/feedback?${qs}`;
+      console.log(`Report a bug: ${url}`);
+      const opener = platform2() === "darwin" ? "open" : platform2() === "win32" ? "start" : "xdg-open";
+      spawnSync(opener, [url], { stdio: "ignore", shell: platform2() === "win32" });
+      return 0;
+    }
     case "telemetry": {
       const sub = rest[0] ?? "status";
       if (sub === "on" || sub === "off") {
@@ -8541,6 +8888,54 @@ 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 "sync": {
       if (!readOrg()) {
         console.log(c.muted("Not joined to an org; nothing to sync."));
@@ -8561,6 +8956,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") {
@@ -8569,7 +8976,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-skills",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Vet agent skills and MCP servers before they run. Verdicts from KillerSkills, policy from your org.",
   "type": "module",
   "bin": {
@@ -10,14 +10,21 @@
     "dist",
     "README.md"
   ],
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --outfile=dist/index.js --banner:js=\"import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);\" && node scripts/shebang.mjs",
+    "dev": "tsx src/index.ts",
+    "test": "node --import tsx --test test/*.test.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "pnpm build && node dist/index.js --version"
+  },
   "dependencies": {},
   "devDependencies": {
+    "@killerskills/policy": "workspace:*",
     "yaml": "^2.6.0",
     "@types/node": "^20",
     "tsx": "^4.19.0",
     "typescript": "^5",
-    "esbuild": "^0.28.2",
-    "@killerskills/policy": "0.1.0"
+    "esbuild": "^0.28.2"
   },
   "engines": {
     "node": ">=20"
@@ -42,11 +49,5 @@
   ],
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --outfile=dist/index.js --banner:js=\"import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);\" && node scripts/shebang.mjs",
-    "dev": "tsx src/index.ts",
-    "test": "node --import tsx --test test/*.test.ts",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
   }
-}
+}