@rhize/skill-forge 0.11.0 → 0.11.2

package/dist/cli.js

@@ -5,7 +5,7 @@ import { Command } from "commander";
 import { createRequire } from "module";
 
 // src/commands/add.ts
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
@@ -131,7 +131,32 @@ function collectNpxPackageSpecs(args) {
   }
   return { packageFlagSpecs, positionalSpec };
 }
+var ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+var PATH_SEGMENT_RE = /^[A-Za-z0-9._-]+$/;
+function looksLikeFsPath(v) {
+  if (!/^(?:\/|~\/|\.\.?\/)/.test(v)) return false;
+  const segments = v.replace(/^~/, "").split("/").filter(Boolean);
+  return segments.length >= 2 && segments.every((seg) => PATH_SEGMENT_RE.test(seg));
+}
+function looksLikeBareUrl(v) {
+  let url;
+  try {
+    url = new URL(v);
+  } catch {
+    return false;
+  }
+  if (!["http:", "https:", "ws:", "wss:", "file:"].includes(url.protocol)) return false;
+  if (url.username !== "" || url.password !== "") return false;
+  if (url.search !== "") return false;
+  return true;
+}
+function looksStructuredNonSecret(value) {
+  const v = value.trim().replace(/^[[\s'"]+/, "").replace(/[\]\s'",]+$/, "");
+  if (v === "") return false;
+  return ISO_TIMESTAMP_RE.test(v) || looksLikeBareUrl(v) || looksLikeFsPath(v);
+}
 function looksHighEntropy(value) {
+  if (looksStructuredNonSecret(value)) return false;
   if (/\s/.test(value)) return false;
   if (value.length < 20) return false;
   const hasLower = /[a-z]/.test(value);
@@ -143,6 +168,9 @@ function looksHighEntropy(value) {
 }
 
 // src/preferences.ts
+function markAccepted(value) {
+  return value;
+}
 var PREFERENCE_KEY_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
 var MAX_PREFERENCE_VALUE_LENGTH = 500;
 var MAX_PENDING_PROPOSALS = 50;
@@ -208,7 +236,7 @@ function setPreference(config, key, value, options = {}) {
   validateProvenanceText("origin", options.origin);
   validateProvenanceText("note", options.note);
   const entry = {
-    value,
+    value: markAccepted(value),
     source: options.source ?? "user",
     updatedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
     origin: options.origin,
@@ -285,7 +313,9 @@ function normalizePreferences(raw) {
       continue;
     }
     out[key] = {
-      value: entry.value,
+      // Re-minted only after `validatePreference` passed above: a hand-edited config.json cannot
+      // smuggle in a value that would fail today's rules.
+      value: markAccepted(entry.value),
       source: entry.source === "agent" ? "agent" : "user",
       updatedAt: typeof entry.updatedAt === "string" ? entry.updatedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
       origin,
@@ -625,19 +655,117 @@ function defaultExec(command, args, options) {
 
 // src/install/promote.ts
 import { cpSync as cpSync2, existsSync as existsSync4, mkdirSync as mkdirSync4, renameSync as renameSync2, rmSync as rmSync2 } from "fs";
-import { basename as basename3, join as join5 } from "path";
+import { basename as basename3, join as join6 } from "path";
+
+// src/install/fingerprint.ts
+import { createHash } from "crypto";
+import { lstatSync, readFileSync as readFileSync3, readdirSync as readdirSync3, readlinkSync, realpathSync } from "fs";
+import { isAbsolute, join as join5, relative, sep } from "path";
+var SKIP_DIRS3 = /* @__PURE__ */ new Set([".git", "node_modules"]);
+function isInside(child, root) {
+  const rel = relative(root, child);
+  return rel === "" || !rel.startsWith(".." + sep) && rel !== ".." && !isAbsolute(rel);
+}
+function fingerprintTree(root) {
+  const hash = createHash("sha256");
+  const symlinks = [];
+  const escaping = [];
+  const realRoot = realpathSync(root);
+  function walk2(dir) {
+    const entries = readdirSync3(dir, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const entry of entries) {
+      const full = join5(dir, entry.name);
+      const rel = relative(root, full);
+      if (entry.isSymbolicLink()) {
+        const target = readlinkSync(full);
+        symlinks.push(`${rel} -> ${target}`);
+        hash.update(`L	${rel}	${target}
+`);
+        try {
+          if (!isInside(realpathSync(full), realRoot)) escaping.push(rel);
+        } catch {
+          escaping.push(rel);
+        }
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS3.has(entry.name)) continue;
+        hash.update(`D	${rel}
+`);
+        walk2(full);
+        continue;
+      }
+      if (entry.isFile()) {
+        const contentHash = createHash("sha256").update(readFileSync3(full)).digest("hex");
+        hash.update(`F	${rel}	${contentHash}
+`);
+        continue;
+      }
+      hash.update(`O	${rel}
+`);
+    }
+  }
+  walk2(root);
+  return { digest: hash.digest("hex"), symlinks, escaping };
+}
+function fingerprintDirs(dirs) {
+  const hash = createHash("sha256");
+  const symlinks = [];
+  const escaping = [];
+  for (const dir of [...dirs].sort()) {
+    let result;
+    try {
+      result = fingerprintTree(dir);
+    } catch (err) {
+      hash.update(`MISSING	${dir}	${err.message}
+`);
+      continue;
+    }
+    hash.update(`DIR	${dir}	${result.digest}
+`);
+    symlinks.push(...result.symlinks.map((s) => `${dir}: ${s}`));
+    escaping.push(...result.escaping.map((s) => `${dir}: ${s}`));
+  }
+  return { digest: hash.digest("hex"), symlinks, escaping };
+}
+function isRealDirectory(path) {
+  try {
+    return lstatSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/install/promote.ts
 function promote(entry, targetSkillsRoot, options = {}) {
   const force = options.force ?? false;
   for (const skillDir of entry.skillDirs) {
-    const dest = join5(targetSkillsRoot, basename3(skillDir));
+    if (!isRealDirectory(skillDir)) {
+      throw new UserError(
+        `refusing to promote ${skillDir}: it is no longer a real directory (a symlink or a deleted path) \u2014 re-run the gate on this candidate`
+      );
+    }
+    const dest = join6(targetSkillsRoot, basename3(skillDir));
     if (existsSync4(dest) && !force) {
       throw new Error(`Refusing to overwrite existing skill dir: ${dest} (pass force to override)`);
     }
   }
+  const fingerprint = fingerprintDirs(entry.skillDirs);
+  if (fingerprint.escaping.length > 0) {
+    throw new UserError(
+      `refusing to promote ${entry.id}: ${fingerprint.escaping.length} symlink(s) inside the candidate resolve outside the quarantine sandbox, and would land in your skills root still pointing there:
+  ` + fingerprint.escaping.join("\n  ")
+    );
+  }
+  if (options.expectedFingerprint !== void 0 && options.expectedFingerprint !== fingerprint.digest) {
+    throw new UserError(
+      `refusing to promote ${entry.id}: the candidate's contents changed after it was gated \u2014 what was scanned is not what would be installed. Re-run \`skill-forge scan\` on the source.`
+    );
+  }
   mkdirSync4(targetSkillsRoot, { recursive: true });
   const promoted = [];
   for (const skillDir of entry.skillDirs) {
-    const dest = join5(targetSkillsRoot, basename3(skillDir));
+    const dest = join6(targetSkillsRoot, basename3(skillDir));
     if (existsSync4(dest)) {
       rmSync2(dest, { recursive: true, force: true });
     }
@@ -666,7 +794,7 @@ function moveDir(src, dest) {
 }
 
 // src/install/promoteMcp.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname2 } from "path";
 function promoteMcp(_entry, profile, targetConfigPath, options = {}) {
   const force = options.force ?? false;
@@ -675,7 +803,7 @@ function promoteMcp(_entry, profile, targetConfigPath, options = {}) {
   let config = {};
   let rawExisting;
   if (existsSync5(targetConfigPath)) {
-    rawExisting = readFileSync3(targetConfigPath, "utf-8");
+    rawExisting = readFileSync4(targetConfigPath, "utf-8");
     try {
       config = JSON.parse(rawExisting);
     } catch (err) {
@@ -759,11 +887,11 @@ function deriveServerEntry(profile) {
 }
 
 // src/install/mcpCandidate.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname3, join as join6 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname3, join as join7 } from "path";
 function readPackageInfo(pkgPath) {
   try {
-    const pkg2 = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    const pkg2 = JSON.parse(readFileSync5(pkgPath, "utf-8"));
     return {
       name: typeof pkg2.name === "string" ? pkg2.name : void 0,
       version: typeof pkg2.version === "string" ? pkg2.version : void 0
@@ -774,7 +902,7 @@ function readPackageInfo(pkgPath) {
 }
 function readConfigEntry(configPath, name) {
   try {
-    const cfg = JSON.parse(readFileSync4(configPath, "utf-8"));
+    const cfg = JSON.parse(readFileSync5(configPath, "utf-8"));
     const servers = cfg.mcpServers ?? cfg.servers ?? {};
     const raw = servers[name] ?? {};
     return {
@@ -792,7 +920,7 @@ function resolveMcpCandidateDetail(profile) {
     return { name, version: readPackageInfo(profile.config).version };
   }
   const entry = readConfigEntry(profile.config, name);
-  const sidecar = readPackageInfo(join6(dirname3(profile.config), "package.json"));
+  const sidecar = readPackageInfo(join7(dirname3(profile.config), "package.json"));
   return {
     name,
     command: entry?.command,
@@ -804,8 +932,8 @@ function resolveMcpCandidateDetail(profile) {
 }
 
 // src/provenance.ts
-import { appendFileSync, existsSync as existsSync6, readFileSync as readFileSync5, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7 } from "path";
+import { appendFileSync, existsSync as existsSync6, readFileSync as readFileSync6, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
 var FORGE_VERBS = ["DEFER", "ABSORB", "FORK", "REJECT", "WATCH"];
 var LEDGER_HEADER = "# Skill Forge \u2014 Provenance Ledger\n\nOne entry per external-skill ingestion decision.\n";
 function todayLocalIsoDate() {
@@ -836,7 +964,7 @@ function appendProvenance(entry, skillsRoot) {
 - **Drift check:** \`${driftCheck}\`
 - **Notes:** ${entry.notes ?? ""}
 `;
-  const ledgerPath = join7(skillsRoot, "SOURCES.md");
+  const ledgerPath = join8(skillsRoot, "SOURCES.md");
   if (!existsSync6(ledgerPath)) {
     writeFileSync4(ledgerPath, LEDGER_HEADER, "utf-8");
   }
@@ -884,41 +1012,41 @@ function parseProvenanceLedger(text) {
   return { entries, warnings };
 }
 function readProvenanceLedger(skillsRoot) {
-  const ledgerPath = join7(skillsRoot, "SOURCES.md");
+  const ledgerPath = join8(skillsRoot, "SOURCES.md");
   if (!existsSync6(ledgerPath)) {
     return { ledgerPath, exists: false, entries: [], warnings: [] };
   }
-  const text = readFileSync5(ledgerPath, "utf-8");
+  const text = readFileSync6(ledgerPath, "utf-8");
   const parsed = parseProvenanceLedger(text);
   return { ledgerPath, exists: true, ...parsed };
 }
 
 // src/commands/gatePipeline.ts
-import { readdirSync as readdirSync6 } from "fs";
+import { readdirSync as readdirSync7 } from "fs";
 
 // src/auditState.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
-import { basename as basename7, dirname as dirname5, join as join11 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { basename as basename7, dirname as dirname5, join as join12 } from "path";
 
 // src/audit.ts
 import {
   existsSync as existsSync8,
-  lstatSync,
+  lstatSync as lstatSync2,
   mkdtempSync,
-  readFileSync as readFileSync7,
-  readdirSync as readdirSync4,
-  realpathSync,
+  readFileSync as readFileSync8,
+  readdirSync as readdirSync5,
+  realpathSync as realpathSync2,
   renameSync as renameSync3,
   rmSync as rmSync3,
   statSync as statSync6,
   writeFileSync as writeFileSync5
 } from "fs";
-import { basename as basename6, delimiter as delimiter3, extname as extname3, join as join10, resolve as resolvePath2 } from "path";
+import { basename as basename6, delimiter as delimiter3, extname as extname3, join as join11, resolve as resolvePath2 } from "path";
 
 // src/gate/safety.ts
 import { statSync as statSync4 } from "fs";
 import { execFile } from "child_process";
-import { delimiter as delimiter2, join as join8 } from "path";
+import { delimiter as delimiter2, join as join9 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var DENY_RULES = [
@@ -1017,7 +1145,7 @@ function which(cmd) {
   const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
   for (const dir of dirs) {
     for (const ext of exts) {
-      const candidate = join8(dir, cmd + ext);
+      const candidate = join9(dir, cmd + ext);
       try {
         if (statSync4(candidate).isFile()) return candidate;
       } catch {
@@ -1140,14 +1268,22 @@ function scanJsonConfig(file, parsed) {
     }
     if (node.env && typeof node.env === "object" && !Array.isArray(node.env)) {
       for (const [key, value] of Object.entries(node.env)) {
-        if (typeof value !== "string" || isPlaceholderValue(value)) continue;
-        if (looksCredentialKey(key) || looksHighEntropy(value)) {
+        if (typeof value !== "string") continue;
+        const kind = classifyCredentialAssignment(key, value);
+        if (kind === "inline-secret") {
           findings.push({
             severity: "HIGH",
             rule: "mcp-inline-credential-value",
             file,
             detail: `env.${key} has an inline credential value \u2014 emit an empty string and document that the user must fill it in`
           });
+        } else if (kind === "file-path") {
+          findings.push({
+            severity: "LOW",
+            rule: "mcp-credential-file-path",
+            file,
+            detail: `env.${key} points at a credential file rather than an inline secret \u2014 the value leaks nothing, but keep that file out of version control`
+          });
         }
       }
     }
@@ -1159,15 +1295,29 @@ var DANGEROUS_FLAG_RE = /--dangerously-[\w-]+|--no-sandbox\b/g;
 var CREDENTIAL_ASSIGNMENT_RE = /["']?([A-Za-z][A-Za-z0-9_]*)["']?\s*[:=]\s*["']([^"']{6,})["']/g;
 var CREDENTIAL_ASSIGNMENT_UNQUOTED_RE = /^\s*(?:export\s+|-\s+)?([A-Za-z][A-Za-z0-9_]*)\s*[:=]\s*(\S+)/;
 var LEADING_QUOTE_RE = /^["']/;
+function classifyCredentialAssignment(key, value) {
+  if (isPlaceholderValue(value)) return "none";
+  const credentialKey = looksCredentialKey(key);
+  if (credentialKey && looksStructuredNonSecret(value) && !/^[a-z]+:\/\//i.test(value.trim())) return "file-path";
+  if (credentialKey || looksHighEntropy(value)) return "inline-secret";
+  return "none";
+}
 function pushCredentialFinding(findings, file, lineNo, varName, value) {
-  if (isPlaceholderValue(value)) return;
-  if (looksCredentialKey(varName) || looksHighEntropy(value)) {
+  const kind = classifyCredentialAssignment(varName, value);
+  if (kind === "inline-secret") {
     findings.push({
       severity: "HIGH",
       rule: "mcp-inline-credential-value",
       file,
       detail: `line ${lineNo}: inline credential value assigned to ${varName}`
     });
+  } else if (kind === "file-path") {
+    findings.push({
+      severity: "LOW",
+      rule: "mcp-credential-file-path",
+      file,
+      detail: `line ${lineNo}: ${varName} points at a credential file rather than an inline secret \u2014 the value leaks nothing, but keep that file out of version control`
+    });
   }
 }
 function scanTextFile(file, content, allowCredentialCheck) {
@@ -1243,8 +1393,8 @@ async function mcpScan(targetPath, strictness = DEFAULT_STRICTNESS) {
 }
 
 // src/gate/overlap.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync3 } from "fs";
-import { basename as basename5, dirname as dirname4, join as join9, resolve as resolve2 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "fs";
+import { basename as basename5, dirname as dirname4, join as join10, resolve as resolve2 } from "path";
 var STOPWORDS = new Set(
   `
 a an the and or of to for in on with use used using when whether this that these those is are be
@@ -1253,20 +1403,20 @@ skill skills user claude code based comprehensive enhanced practical including i
 `.split(/\s+/).filter(Boolean)
 );
 var DEFAULT_SET_THRESHOLD = 0.45;
-function splitLimited(text, sep4, maxSplit) {
+function splitLimited(text, sep5, maxSplit) {
   const parts = [];
   let rest = text;
   for (let i = 0; i < maxSplit; i++) {
-    const idx = rest.indexOf(sep4);
+    const idx = rest.indexOf(sep5);
     if (idx === -1) break;
     parts.push(rest.slice(0, idx));
-    rest = rest.slice(idx + sep4.length);
+    rest = rest.slice(idx + sep5.length);
   }
   parts.push(rest);
   return parts;
 }
 function readFrontmatter(skillMdPath) {
-  const text = readFileSync6(skillMdPath, "utf-8");
+  const text = readFileSync7(skillMdPath, "utf-8");
   const meta = { name: basename5(dirname4(skillMdPath)), description: "" };
   if (text.startsWith("---\n")) {
     const block = splitLimited(text, "---", 2)[1] ?? "";
@@ -1364,25 +1514,25 @@ function listSubdirs(dir) {
   if (!existsSync7(dir)) return [];
   let entries;
   try {
-    entries = readdirSync3(dir, { withFileTypes: true });
+    entries = readdirSync4(dir, { withFileTypes: true });
   } catch {
     return [];
   }
-  return entries.filter((e) => e.isDirectory()).map((e) => join9(dir, e.name));
+  return entries.filter((e) => e.isDirectory()).map((e) => join10(dir, e.name));
 }
 function findSkillMdFiles(root) {
   const found = /* @__PURE__ */ new Set();
   for (const dir of listSubdirs(root)) {
-    const candidate = join9(dir, "SKILL.md");
+    const candidate = join10(dir, "SKILL.md");
     if (existsSync7(candidate)) found.add(resolve2(candidate));
   }
-  for (const dir of listSubdirs(join9(root, "skills"))) {
-    const candidate = join9(dir, "SKILL.md");
+  for (const dir of listSubdirs(join10(root, "skills"))) {
+    const candidate = join10(dir, "SKILL.md");
     if (existsSync7(candidate)) found.add(resolve2(candidate));
   }
   for (const topDir of listSubdirs(root)) {
-    for (const dir of listSubdirs(join9(topDir, "skills"))) {
-      const candidate = join9(dir, "SKILL.md");
+    for (const dir of listSubdirs(join10(topDir, "skills"))) {
+      const candidate = join10(dir, "SKILL.md");
       if (existsSync7(candidate)) found.add(resolve2(candidate));
     }
   }
@@ -1395,7 +1545,7 @@ function scanOverlap(candidatePath, skillsRoot) {
   }
   let cpath = resolve2(expandHome(candidatePath));
   if (isDir(cpath)) {
-    cpath = join9(cpath, "SKILL.md");
+    cpath = join10(cpath, "SKILL.md");
   }
   if (!existsSync7(cpath)) {
     throw new Error(`candidate SKILL.md not found: ${cpath}`);
@@ -1547,13 +1697,13 @@ function isDirFollowingSymlink(p) {
 function listSubdirsFollowingSymlinks(dir) {
   let entries;
   try {
-    entries = readdirSync4(dir, { withFileTypes: true });
+    entries = readdirSync5(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const entry of entries) {
-    const full = join10(dir, entry.name);
+    const full = join11(dir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink() && isDirFollowingSymlink(full)) {
       out.push(full);
     }
@@ -1563,24 +1713,24 @@ function listSubdirsFollowingSymlinks(dir) {
 function listSubdirsNoSymlinks(dir) {
   let entries;
   try {
-    entries = readdirSync4(dir, { withFileTypes: true });
+    entries = readdirSync5(dir, { withFileTypes: true });
   } catch {
     return [];
   }
-  return entries.filter((e) => e.isDirectory()).map((e) => join10(dir, e.name));
+  return entries.filter((e) => e.isDirectory()).map((e) => join11(dir, e.name));
 }
 function findSkillDirsUnderRoot(root) {
   const found = /* @__PURE__ */ new Set();
   const rootSubdirs = listSubdirsFollowingSymlinks(root);
   for (const dir of rootSubdirs) {
-    if (existsSync8(join10(dir, "SKILL.md"))) found.add(dir);
+    if (existsSync8(join11(dir, "SKILL.md"))) found.add(dir);
   }
-  for (const dir of listSubdirsFollowingSymlinks(join10(root, "skills"))) {
-    if (existsSync8(join10(dir, "SKILL.md"))) found.add(dir);
+  for (const dir of listSubdirsFollowingSymlinks(join11(root, "skills"))) {
+    if (existsSync8(join11(dir, "SKILL.md"))) found.add(dir);
   }
   for (const topDir of rootSubdirs) {
-    for (const dir of listSubdirsNoSymlinks(join10(topDir, "skills"))) {
-      if (existsSync8(join10(dir, "SKILL.md"))) found.add(dir);
+    for (const dir of listSubdirsNoSymlinks(join11(topDir, "skills"))) {
+      if (existsSync8(join11(dir, "SKILL.md"))) found.add(dir);
     }
   }
   return Array.from(found).filter((p) => !p.includes("/.git/"));
@@ -1594,7 +1744,7 @@ function collectSkillCandidates(roots) {
     let realPath;
     if (exists) {
       try {
-        realPath = realpathSync(resolvedRoot);
+        realPath = realpathSync2(resolvedRoot);
       } catch {
         realPath = void 0;
       }
@@ -1613,7 +1763,7 @@ function dedupeSkillCandidates(candidates, findings) {
   for (const candidate of candidates) {
     let realPath;
     try {
-      realPath = realpathSync(candidate.configuredPath);
+      realPath = realpathSync2(candidate.configuredPath);
     } catch (err) {
       findings.push({
         severity: "MEDIUM",
@@ -1676,7 +1826,7 @@ function estimateTokens(text) {
   return Math.ceil(Buffer.byteLength(text, "utf-8") / 4);
 }
 function profileAuditedSkill(group, findings, unreadableSkillMdPaths) {
-  const skillMdPath = join10(group.canonicalPath, "SKILL.md");
+  const skillMdPath = join11(group.canonicalPath, "SKILL.md");
   const base = {
     path: group.canonicalPath,
     skillMdPath,
@@ -1687,7 +1837,7 @@ function profileAuditedSkill(group, findings, unreadableSkillMdPaths) {
   let sizeBytes;
   try {
     sizeBytes = statSync6(skillMdPath).size;
-    text = readFileSync7(skillMdPath, "utf-8");
+    text = readFileSync8(skillMdPath, "utf-8");
   } catch (err) {
     findings.push({
       severity: "MEDIUM",
@@ -1765,7 +1915,7 @@ function auditMcpTarget(targetPath, notices) {
   }
   if (isToml) {
     try {
-      readFileSync7(targetPath, "utf-8");
+      readFileSync8(targetPath, "utf-8");
     } catch (err) {
       findings.push({
         severity: "MEDIUM",
@@ -1780,7 +1930,7 @@ function auditMcpTarget(targetPath, notices) {
   }
   let raw;
   try {
-    raw = readFileSync7(targetPath, "utf-8");
+    raw = readFileSync8(targetPath, "utf-8");
   } catch (err) {
     findings.push({
       severity: "MEDIUM",
@@ -1856,7 +2006,7 @@ function defaultWhich(cmd) {
   const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
   for (const dir of dirs) {
     for (const ext of exts) {
-      const candidate = join10(dir, cmd + ext);
+      const candidate = join11(dir, cmd + ext);
       try {
         if (statSync6(candidate).isFile()) return candidate;
       } catch {
@@ -2208,10 +2358,10 @@ async function scaffoldFoundationSkill(config, profile, targetRoot) {
   if (!isDir(resolvedRoot)) {
     throw new UserError(`skills root does not exist: ${resolvedRoot}`);
   }
-  const destDir = join10(resolvedRoot, "business-foundation");
+  const destDir = join11(resolvedRoot, "business-foundation");
   let destLstat;
   try {
-    destLstat = lstatSync(destDir);
+    destLstat = lstatSync2(destDir);
   } catch {
     destLstat = void 0;
   }
@@ -2222,9 +2372,9 @@ async function scaffoldFoundationSkill(config, profile, targetRoot) {
     throw new UserError(`refusing to scaffold a foundation skill at ${destDir}: already exists`);
   }
   const content = renderFoundationSkillMd(profile);
-  const tempDir = mkdtempSync(join10(resolvedRoot, ".business-foundation-"));
+  const tempDir = mkdtempSync(join11(resolvedRoot, ".business-foundation-"));
   try {
-    writeFileSync5(join10(tempDir, "SKILL.md"), content, { flag: "wx", mode: 384 });
+    writeFileSync5(join11(tempDir, "SKILL.md"), content, { flag: "wx", mode: 384 });
     const safety = await scanSafety(tempDir, config.strictness);
     if (safety.verdict === "block") {
       throw new UserError(
@@ -2258,7 +2408,7 @@ async function scaffoldFoundationSkill(config, profile, targetRoot) {
 
 // src/auditState.ts
 function getAuditStatePath() {
-  return join11(getHomeDir(), "audit-state.json");
+  return join12(getHomeDir(), "audit-state.json");
 }
 function emptyCounts() {
   return { CRITICAL: 0, HIGH: 0, MEDIUM: 0, LOW: 0 };
@@ -2315,7 +2465,7 @@ function readAuditState() {
   const path = getAuditStatePath();
   if (!existsSync9(path)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync9(path, "utf-8"));
     if (parsed.schemaVersion !== 1 || typeof parsed.lastRunAt !== "string") return void 0;
     return {
       schemaVersion: 1,
@@ -2376,7 +2526,7 @@ function formatAuditAdvisory(state, options = {}) {
 }
 
 // src/commands/gatePipeline.ts
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 
 // src/gate/profile.ts
 import { execFileSync } from "child_process";
@@ -2385,23 +2535,23 @@ import {
   existsSync as existsSync11,
   mkdtempSync as mkdtempSync2,
   openSync,
-  readFileSync as readFileSync10,
-  readdirSync as readdirSync5,
+  readFileSync as readFileSync11,
+  readdirSync as readdirSync6,
   readSync,
   rmSync as rmSync4,
   statSync as statSync7
 } from "fs";
 import { tmpdir } from "os";
-import { basename as basename8, dirname as dirname6, extname as extname5, join as join13, resolve as resolve3 } from "path";
+import { basename as basename8, dirname as dirname6, extname as extname5, join as join14, resolve as resolve3 } from "path";
 
 // src/gate/mcpCapabilities.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import { extname as extname4, join as join12 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
+import { extname as extname4, join as join13 } from "path";
 var SOURCE_EXT = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var MAX_ITEMS_PER_CATEGORY = 200;
 function readJsonSafe(file) {
   try {
-    return JSON.parse(readFileSync9(file, "utf-8"));
+    return JSON.parse(readFileSync10(file, "utf-8"));
   } catch {
     return void 0;
   }
@@ -2502,7 +2652,7 @@ var MCP_SDK_IMPORT_RE = /@modelcontextprotocol\/sdk/;
 function extractMcpCapabilities(packageDir) {
   const buckets = { tools: /* @__PURE__ */ new Set(), resources: /* @__PURE__ */ new Set(), prompts: /* @__PURE__ */ new Set() };
   let hasPackageJsonMarker = false;
-  const pkgPath = join12(packageDir, "package.json");
+  const pkgPath = join13(packageDir, "package.json");
   if (existsSync10(pkgPath)) {
     const pkg2 = readJsonSafe(pkgPath);
     if (pkg2 && typeof pkg2 === "object" && !Array.isArray(pkg2)) {
@@ -2510,7 +2660,7 @@ function extractMcpCapabilities(packageDir) {
     }
   }
   for (const manifestName of [".mcp.json", "mcp.json"]) {
-    const manifestPath = join12(packageDir, manifestName);
+    const manifestPath = join13(packageDir, manifestName);
     if (!existsSync10(manifestPath)) continue;
     const parsed = readJsonSafe(manifestPath);
     if (parsed !== void 0) {
@@ -2618,7 +2768,7 @@ function asProfile(candidatePath, artifact) {
   return asSkillProfile(profile, `at ${candidatePath}`);
 }
 function classifyInput(p) {
-  if (existsSync11(join13(p, ".claude-plugin", "plugin.json"))) return "plugin";
+  if (existsSync11(join14(p, ".claude-plugin", "plugin.json"))) return "plugin";
   if (detectArtifactType(p) === "mcp") return "mcp";
   return "skill";
 }
@@ -2626,10 +2776,10 @@ var MCP_SDK_DEP2 = "@modelcontextprotocol/sdk";
 var MCP_KEYWORD2 = "mcp-server";
 var MCP_BIN_PREFIX2 = /^mcp-/i;
 function readPackageJsonSafe(root) {
-  const pkgPath = join13(root, "package.json");
+  const pkgPath = join14(root, "package.json");
   if (!existsSync11(pkgPath)) return void 0;
   try {
-    return JSON.parse(readFileSync10(pkgPath, "utf-8"));
+    return JSON.parse(readFileSync11(pkgPath, "utf-8"));
   } catch {
     return void 0;
   }
@@ -2650,7 +2800,7 @@ function hasMcpPackageMarkers(pkg2) {
   return false;
 }
 function detectArtifactType(root) {
-  if (existsSync11(join13(root, ".mcp.json")) || existsSync11(join13(root, "mcp.json"))) return "mcp";
+  if (existsSync11(join14(root, ".mcp.json")) || existsSync11(join14(root, "mcp.json"))) return "mcp";
   const pkg2 = readPackageJsonSafe(root);
   if (pkg2 && hasMcpPackageMarkers(pkg2)) return "mcp";
   return "skill";
@@ -2660,7 +2810,7 @@ function resolveSkillMd(inputPath) {
   let tmpDir;
   const initialStat = statSync7(currentPath);
   if (extname5(currentPath) === ".skill" || initialStat.isFile() && isZipFile(currentPath)) {
-    tmpDir = mkdtempSync2(join13(tmpdir(), "forge_"));
+    tmpDir = mkdtempSync2(join14(tmpdir(), "forge_"));
     extractZip(currentPath, tmpDir);
     currentPath = tmpDir;
   }
@@ -2669,7 +2819,7 @@ function resolveSkillMd(inputPath) {
     return { skillMd: currentPath, root: dirname6(currentPath), tmpDir };
   }
   if (stat.isDirectory()) {
-    const direct = join13(currentPath, "SKILL.md");
+    const direct = join14(currentPath, "SKILL.md");
     if (existsSync11(direct)) {
       return { skillMd: direct, root: currentPath, tmpDir };
     }
@@ -2693,17 +2843,17 @@ function cleanupTmp(tmpDir) {
 }
 function findSkillMdOneLevelDown(dir) {
   const matches = /* @__PURE__ */ new Set();
-  for (const entry of readdirSync5(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      const candidate = join13(dir, entry.name, "SKILL.md");
+      const candidate = join14(dir, entry.name, "SKILL.md");
       if (existsSync11(candidate)) matches.add(candidate);
     }
   }
-  const skillsDir = join13(dir, "skills");
+  const skillsDir = join14(dir, "skills");
   if (isDir(skillsDir)) {
-    for (const entry of readdirSync5(skillsDir, { withFileTypes: true })) {
+    for (const entry of readdirSync6(skillsDir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
-        const candidate = join13(skillsDir, entry.name, "SKILL.md");
+        const candidate = join14(skillsDir, entry.name, "SKILL.md");
         if (existsSync11(candidate)) matches.add(candidate);
       }
     }
@@ -2787,9 +2937,9 @@ function detectLicense(root, fm) {
   if (fm.license) return fm.license;
   const names = ["LICENSE", "LICENSE.md", "LICENSE.txt", "COPYING", "license"];
   for (const name of names) {
-    const p = join13(root, name);
+    const p = join14(root, name);
     if (existsSync11(p) && statSync7(p).isFile()) {
-      const head = readFileSync10(p, "utf-8").slice(0, 2e3).toLowerCase();
+      const head = readFileSync11(p, "utf-8").slice(0, 2e3).toLowerCase();
       for (const [hint, label] of Object.entries(SPDX_HINTS)) {
         if (head.includes(hint)) return label;
       }
@@ -2800,8 +2950,8 @@ function detectLicense(root, fm) {
 }
 function walkFiles(dir) {
   const out = [];
-  for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    const full = join13(dir, entry.name);
+  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+    const full = join14(dir, entry.name);
     if (entry.isDirectory()) {
       out.push(...walkFiles(full));
     } else if (entry.isFile()) {
@@ -2813,7 +2963,7 @@ function walkFiles(dir) {
 function countResources(root) {
   const resources = {};
   for (const d of RESOURCE_DIRS) {
-    const dp = join13(root, d);
+    const dp = join14(root, d);
     if (isDir(dp)) {
       resources[d] = walkFiles(dp).length;
     }
@@ -2824,11 +2974,11 @@ function scanMcpAndImports(text, root) {
   const mcpRefRe = /mcp__[a-zA-Z0-9_]+/g;
   const mcpRefs = new Set(text.match(mcpRefRe) ?? []);
   const imports = /* @__PURE__ */ new Set();
-  const scriptsDir = join13(root, "scripts");
+  const scriptsDir = join14(root, "scripts");
   if (isDir(scriptsDir)) {
     for (const f of walkFiles(scriptsDir)) {
       if (!f.endsWith(".py")) continue;
-      const ft = readFileSync10(f, "utf-8");
+      const ft = readFileSync11(f, "utf-8");
       for (const m2 of ft.match(mcpRefRe) ?? []) mcpRefs.add(m2);
       const importRe = /^\s*(?:import|from)\s+([a-zA-Z0-9_]+)/gm;
       let m;
@@ -2845,7 +2995,7 @@ function scanMcpAndImports(text, root) {
 function profileSkillDir(inputPath) {
   const { skillMd, root, tmpDir } = resolveSkillMd(inputPath);
   try {
-    const text = readFileSync10(skillMd, "utf-8");
+    const text = readFileSync11(skillMd, "utf-8");
     const fm = parseFrontmatter(text);
     const bodyLines = (text.match(/\n/g)?.length ?? 0) + 1;
     const headers = Array.from(text.matchAll(/^#{1,3}\s+(.+)$/gm)).map((m) => m[1]);
@@ -2873,20 +3023,20 @@ function profileSkillDir(inputPath) {
   }
 }
 function profilePlugin(p) {
-  const manifestPath = join13(p, ".claude-plugin", "plugin.json");
+  const manifestPath = join14(p, ".claude-plugin", "plugin.json");
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync10(manifestPath, "utf-8"));
+    manifest = JSON.parse(readFileSync11(manifestPath, "utf-8"));
   } catch (err) {
     throw new Error(`could not parse plugin.json under ${p}: ${err.message}`);
   }
-  const skillsDir = join13(p, "skills");
+  const skillsDir = join14(p, "skills");
   let skills = [];
   if (isDir(skillsDir)) {
-    skills = readdirSync5(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync11(join13(skillsDir, d.name, "SKILL.md"))).map((d) => d.name).sort();
+    skills = readdirSync6(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync11(join14(skillsDir, d.name, "SKILL.md"))).map((d) => d.name).sort();
   }
-  const commandsDir = join13(p, "commands");
-  const commands = isDir(commandsDir) ? readdirSync5(commandsDir).filter((f) => f.endsWith(".md")).length : 0;
+  const commandsDir = join14(p, "commands");
+  const commands = isDir(commandsDir) ? readdirSync6(commandsDir).filter((f) => f.endsWith(".md")).length : 0;
   const mc = manifest.mcpServers ?? manifest.mcp_servers ?? {};
   const mcpServers = typeof mc === "object" && mc !== null ? Object.keys(mc).sort() : [];
   return {
@@ -2903,11 +3053,11 @@ function profilePlugin(p) {
   };
 }
 function profileMcp(p) {
-  const explicitConfig = existsSync11(join13(p, ".mcp.json")) ? join13(p, ".mcp.json") : existsSync11(join13(p, "mcp.json")) ? join13(p, "mcp.json") : void 0;
+  const explicitConfig = existsSync11(join14(p, ".mcp.json")) ? join14(p, ".mcp.json") : existsSync11(join14(p, "mcp.json")) ? join14(p, "mcp.json") : void 0;
   if (explicitConfig) {
     let cfg;
     try {
-      cfg = JSON.parse(readFileSync10(explicitConfig, "utf-8"));
+      cfg = JSON.parse(readFileSync11(explicitConfig, "utf-8"));
     } catch (err) {
       throw new Error(`could not parse MCP config ${explicitConfig}: ${err.message}`);
     }
@@ -2923,10 +3073,10 @@ function profileMcp(p) {
       capabilities: extractMcpCapabilities(p)
     };
   }
-  const pkgPath = join13(p, "package.json");
+  const pkgPath = join14(p, "package.json");
   let pkg2;
   try {
-    pkg2 = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+    pkg2 = JSON.parse(readFileSync11(pkgPath, "utf-8"));
   } catch (err) {
     throw new Error(`could not parse package.json ${pkgPath}: ${err.message}`);
   }
@@ -2943,14 +3093,14 @@ function profileMcp(p) {
 }
 
 // src/gate/mcpOverlap.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync12 } from "fs";
 import { resolve as resolve4 } from "path";
 function readTargetServers(targetPath) {
   const path = resolve4(expandHome(targetPath));
   if (!existsSync12(path)) return [];
   let cfg;
   try {
-    cfg = JSON.parse(readFileSync11(path, "utf-8"));
+    cfg = JSON.parse(readFileSync12(path, "utf-8"));
   } catch {
     return [];
   }
@@ -3151,10 +3301,10 @@ function resolveMcpCandidatePath(entry) {
   if (entry.packageDir) return entry.packageDir;
   let children = [];
   try {
-    children = readdirSync6(entry.quarantinePath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    children = readdirSync7(entry.quarantinePath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   } catch {
   }
-  return children.length === 1 ? join14(entry.quarantinePath, children[0]) : entry.quarantinePath;
+  return children.length === 1 ? join15(entry.quarantinePath, children[0]) : entry.quarantinePath;
 }
 async function runGate(candidatePath, skillsRoot, {
   proFeatureLabel = "overlap analysis",
@@ -3186,17 +3336,17 @@ async function runGate(candidatePath, skillsRoot, {
 
 // src/queue.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync12, renameSync as renameSync4, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync13, renameSync as renameSync4, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
+import { join as join16 } from "path";
 function getQueuePath() {
-  return join15(getHomeDir(), "queue.json");
+  return join16(getHomeDir(), "queue.json");
 }
 function readQueue() {
   const path = getQueuePath();
   if (!existsSync13(path)) {
     return { version: 1, entries: [] };
   }
-  const raw = readFileSync12(path, "utf-8");
+  const raw = readFileSync13(path, "utf-8");
   const parsed = JSON.parse(raw);
   return { version: 1, entries: parsed.entries ?? [] };
 }
@@ -3204,7 +3354,7 @@ function writeQueue(queue2) {
   const home = getHomeDir();
   mkdirSync6(home, { recursive: true });
   const finalPath = getQueuePath();
-  const tempPath = join15(home, `.queue.json.tmp-${randomUUID3()}`);
+  const tempPath = join16(home, `.queue.json.tmp-${randomUUID3()}`);
   try {
     writeFileSync6(tempPath, JSON.stringify(queue2, null, 2) + "\n", "utf-8");
     renameSync4(tempPath, finalPath);
@@ -3254,15 +3404,15 @@ function generateId(existingIds) {
 // src/handoff.ts
 import { spawnSync } from "child_process";
 import { existsSync as existsSync14 } from "fs";
-import { dirname as dirname7, join as join16 } from "path";
+import { dirname as dirname7, join as join17 } from "path";
 import { fileURLToPath } from "url";
 var KNOWN_AGENT_BINARIES = ["claude", "codex", "cursor-agent", "windsurf", "opencode", "gemini"];
 var HANDOFF_INSTRUCTION = "Read {prompt} and follow its instructions for the skill installed at {path}";
 function resolvePromptPath(assetName = "ingest-prompt.md") {
   const here = dirname7(fileURLToPath(import.meta.url));
-  const builtCandidate = join16(here, assetName);
+  const builtCandidate = join17(here, assetName);
   if (existsSync14(builtCandidate)) return builtCandidate;
-  return join16(here, "..", "assets", assetName);
+  return join17(here, "..", "assets", assetName);
 }
 function defaultIsOnPath(bin) {
   const finder = process.platform === "win32" ? "where" : "which";
@@ -3325,7 +3475,7 @@ import { createInterface as createInterface3 } from "readline/promises";
 // src/agents.ts
 import { statSync as statSync8 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join17, resolve as resolve5 } from "path";
+import { join as join18, resolve as resolve5 } from "path";
 function isFile(p) {
   try {
     return statSync8(p).isFile();
@@ -3339,7 +3489,7 @@ function projectPath(root, cwd) {
 function globalPath(root, home) {
   if (!root) return void 0;
   if (root === "~") return home;
-  if (root.startsWith("~/")) return join17(home, root.slice(2));
+  if (root.startsWith("~/")) return join18(home, root.slice(2));
   return root;
 }
 function makeAgent(spec) {
@@ -3570,7 +3720,7 @@ var AGENTS = [
 
 // src/commands/audit.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join18, resolve as resolvePath3 } from "path";
+import { join as join19, resolve as resolvePath3 } from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/decision.ts
@@ -3638,7 +3788,7 @@ async function captureBusinessProfile(rl, existing) {
 function resolveReportPath(reportOption) {
   if (reportOption) return resolvePath3(reportOption);
   const iso = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return join18(getHomeDir(), "reports", `audit-${iso}.md`);
+  return join19(getHomeDir(), "reports", `audit-${iso}.md`);
 }
 function printTerminalSummary(report, reportPath) {
   const { summary } = report;
@@ -4063,6 +4213,7 @@ async function add(source, options = {}) {
   }
   const resolved = resolve(source, artifact);
   const entry = await quarantine(resolved, config.quarantineDir);
+  const gatedFingerprint = fingerprintDirs(entry.skillDirs).digest;
   if (entry.skillDirs.length === 0) {
     console.error(`[skill-forge] no SKILL.md found in installed source: ${source}`);
     reject(entry);
@@ -4088,7 +4239,7 @@ async function add(source, options = {}) {
   const decision = options.yes || options.json ? yesDecision(safety.verdict) : await promptDecision(safety.verdict, "this skill");
   let installedPath = null;
   if (decision === "promote") {
-    const result = promote(entry, targetRoot);
+    const result = promote(entry, targetRoot, { expectedFingerprint: gatedFingerprint });
     logOutcome(`[skill-forge] promoted -> ${result.promoted.join(", ")}`, options.json);
     if (proEnabled) {
       try {
@@ -4179,7 +4330,7 @@ async function addMcp(source, config, options) {
       envVars: detail.env ? Object.keys(detail.env) : void 0,
       candidateEntry: detail.command ? { command: detail.command, args: detail.args, env: detail.env } : void 0
     };
-    const mcpTargetPath = options.mcpTarget ?? config.mcpTargets?.[0] ?? join19(process.cwd(), ".mcp.json");
+    const mcpTargetPath = options.mcpTarget ?? config.mcpTargets?.[0] ?? join20(process.cwd(), ".mcp.json");
     const result = promoteMcp(entry, serverProfile, mcpTargetPath, { force: options.force });
     reject(entry);
     logOutcome(`[skill-forge] promoted -> ${result.target} (server "${result.serverName}")`, options.json);
@@ -4274,7 +4425,7 @@ async function scan(source, options = {}) {
 }
 
 // src/commands/list.ts
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 async function list() {
   await maybeOfferInit();
   const config = loadConfig();
@@ -4287,14 +4438,14 @@ async function list() {
   }
   console.log(`[skill-forge] ${ids.length} held in quarantine (${quarantineDir}):`);
   for (const id of ids) {
-    const skillDirs = findSkillDirs(join20(quarantineDir, id));
+    const skillDirs = findSkillDirs(join21(quarantineDir, id));
     if (skillDirs.length === 0) {
       console.log(`  ${id}  (no SKILL.md found)`);
       continue;
     }
     const names = skillDirs.map((dir) => {
       try {
-        return readFrontmatter(join20(dir, "SKILL.md")).name;
+        return readFrontmatter(join21(dir, "SKILL.md")).name;
       } catch {
         return dir;
       }
@@ -4307,20 +4458,20 @@ async function list() {
 import { existsSync as existsSync18 } from "fs";
 
 // src/commands/held.ts
-import { existsSync as existsSync17, realpathSync as realpathSync2 } from "fs";
-import { basename as basename9, join as join21, resolve as resolvePath4, sep } from "path";
+import { existsSync as existsSync17, realpathSync as realpathSync3 } from "fs";
+import { basename as basename9, join as join22, resolve as resolvePath4, sep as sep2 } from "path";
 var PRO_FEATURE_LABEL2 = "overlap analysis, the provenance ledger, and the pending-ingestion queue";
 function resolveHeldPath(quarantineDir, id) {
   if (id === "" || id !== basename9(id) || id === "." || id === "..") {
     throw new UserError(`invalid quarantine id "${id}" \u2014 pass a single id exactly as printed by \`skill-forge list\``);
   }
-  const candidate = join21(quarantineDir, id);
+  const candidate = join22(quarantineDir, id);
   if (!existsSync17(candidate)) {
     throw new UserError(`no held entry with id "${id}" \u2014 run \`skill-forge list\` to see what is in quarantine`);
   }
-  const realRoot = realpathSync2(resolvePath4(quarantineDir));
-  const realCandidate = realpathSync2(candidate);
-  if (!realCandidate.startsWith(realRoot + sep)) {
+  const realRoot = realpathSync3(resolvePath4(quarantineDir));
+  const realCandidate = realpathSync3(candidate);
+  if (!realCandidate.startsWith(realRoot + sep2)) {
     throw new UserError(`refusing to act on "${id}": it resolves outside the quarantine dir (${realRoot})`);
   }
   return realCandidate;
@@ -4343,7 +4494,7 @@ function resolveTargetRoot(config, target) {
 function heldSkillNames(skillDirs) {
   return skillDirs.map((dir) => {
     try {
-      return readFrontmatter(join21(dir, "SKILL.md")).name;
+      return readFrontmatter(join22(dir, "SKILL.md")).name;
     } catch {
       return basename9(dir);
     }
@@ -4351,7 +4502,7 @@ function heldSkillNames(skillDirs) {
 }
 function looksLikeMcpSandbox(quarantinePath) {
   const candidate = resolveMcpCandidatePath({ quarantinePath });
-  return [".mcp.json", "mcp.json", "package.json"].some((f) => existsSync17(join21(candidate, f)));
+  return [".mcp.json", "mcp.json", "package.json"].some((f) => existsSync17(join22(candidate, f)));
 }
 async function promoteHeldMcp(id, entry, config, options) {
   const candidatePath = resolveMcpCandidatePath(entry);
@@ -4385,7 +4536,7 @@ async function promoteHeldMcp(id, entry, config, options) {
     envVars: detail.env ? Object.keys(detail.env) : void 0,
     candidateEntry: detail.command ? { command: detail.command, args: detail.args, env: detail.env } : void 0
   };
-  const mcpTargetPath = options.mcpTarget ?? config.mcpTargets?.[0] ?? join21(process.cwd(), ".mcp.json");
+  const mcpTargetPath = options.mcpTarget ?? config.mcpTargets?.[0] ?? join22(process.cwd(), ".mcp.json");
   const result = promoteMcp(entry, serverProfile, mcpTargetPath, { force: options.force });
   reject(entry);
   logOutcome(`[skill-forge] promoted -> ${result.target} (server "${result.serverName}")`, options.json);
@@ -4430,6 +4581,7 @@ async function promoteHeld(id, options = {}) {
   }
   const targetRoot = resolveTargetRoot(config, options.target);
   const candidatePath = entry.skillDirs[0];
+  const gatedFingerprint = fingerprintDirs(entry.skillDirs).digest;
   logOutcome(`[skill-forge] re-gating held entry ${id} (${heldSkillNames(entry.skillDirs).join(", ")})`, options.json);
   const { safety, gateResult, proEnabled } = await runGate(candidatePath, targetRoot, {
     proFeatureLabel: PRO_FEATURE_LABEL2,
@@ -4450,7 +4602,7 @@ async function promoteHeld(id, options = {}) {
     logOutcome(`[skill-forge] rejected \u2014 removed ${quarantinePath}`, options.json);
     return;
   }
-  const result = promote(entry, targetRoot, { force: options.force });
+  const result = promote(entry, targetRoot, { force: options.force, expectedFingerprint: gatedFingerprint });
   logOutcome(`[skill-forge] promoted ${result.promoted.length} skill dir(s):`, options.json);
   for (const promotedPath of result.promoted) logOutcome(`  ${promotedPath}`, options.json);
   if (!proEnabled) return;
@@ -4858,17 +5010,17 @@ async function status() {
 
 // src/evolve.ts
 import { createInterface as createInterface5 } from "readline/promises";
-import { createHash } from "crypto";
-import { cpSync as cpSync3, existsSync as existsSync19, lstatSync as lstatSync2, mkdtempSync as mkdtempSync3, readFileSync as readFileSync13, rmSync as rmSync6 } from "fs";
+import { createHash as createHash2 } from "crypto";
+import { cpSync as cpSync3, existsSync as existsSync19, lstatSync as lstatSync3, mkdtempSync as mkdtempSync3, readFileSync as readFileSync14, rmSync as rmSync6 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename10, dirname as dirname9, join as join22, resolve as resolvePath5, sep as sep2 } from "path";
+import { basename as basename10, dirname as dirname9, join as join23, resolve as resolvePath5, sep as sep3 } from "path";
 var SKILLOPT_BIN = "skillopt-sleep";
 var PRO_FEATURE_LABEL3 = "self-evolution via SkillOpt-Sleep (evolve) \u2014 re-gating, provenance, and the pending-ingestion queue";
 async function evolve(targetSkillDir, options = {}, deps = {}) {
   const exec = deps.exec ?? defaultExec;
   const json = options.json;
   const resolvedTargetDir = resolvePath5(targetSkillDir);
-  const skillMdPath = join22(resolvedTargetDir, "SKILL.md");
+  const skillMdPath = join23(resolvedTargetDir, "SKILL.md");
   if (!existsSync19(skillMdPath)) {
     throw new UserError(`no SKILL.md found at ${skillMdPath} \u2014 evolve requires an existing, installed skill directory`);
   }
@@ -4927,16 +5079,16 @@ async function evolve(targetSkillDir, options = {}, deps = {}) {
     }
     return;
   }
-  const stagingRoot = join22(project, ".skillopt-sleep", "staging");
+  const stagingRoot = join23(project, ".skillopt-sleep", "staging");
   const stagingDir = resolvePath5(parsed.staging_dir);
-  if (stagingDir !== stagingRoot && !stagingDir.startsWith(stagingRoot + sep2)) {
+  if (stagingDir !== stagingRoot && !stagingDir.startsWith(stagingRoot + sep3)) {
     throw new UserError(
       `skillopt-sleep reported a staging_dir outside the expected sandbox (${stagingRoot}): ${stagingDir} \u2014 refusing to use it`
     );
   }
-  const proposedSkillMd = join22(stagingDir, "proposed_SKILL.md");
-  const proposedClaudeMd = join22(stagingDir, "proposed_CLAUDE.md");
-  const reportMdPath = join22(stagingDir, "report.md");
+  const proposedSkillMd = join23(stagingDir, "proposed_SKILL.md");
+  const proposedClaudeMd = join23(stagingDir, "proposed_CLAUDE.md");
+  const reportMdPath = join23(stagingDir, "report.md");
   if (!existsSync19(proposedSkillMd)) {
     throw new UserError(`skillopt-sleep reported an accepted proposal but ${proposedSkillMd} is missing`);
   }
@@ -4947,13 +5099,13 @@ async function evolve(targetSkillDir, options = {}, deps = {}) {
   assertNotSymlink(proposedClaudeMd, "proposed_CLAUDE.md");
   const scannedSkillHash = sha256File(proposedSkillMd);
   const scannedClaudeHash = sha256File(proposedClaudeMd);
-  const tempDir = mkdtempSync3(join22(tmpdir2(), "skill-forge-evolve-"));
+  const tempDir = mkdtempSync3(join23(tmpdir2(), "skill-forge-evolve-"));
   let profile;
   let safety;
   try {
-    cpSync3(proposedSkillMd, join22(tempDir, "SKILL.md"));
+    cpSync3(proposedSkillMd, join23(tempDir, "SKILL.md"));
     if (existsSync19(proposedClaudeMd)) {
-      cpSync3(proposedClaudeMd, join22(tempDir, "CLAUDE.md"));
+      cpSync3(proposedClaudeMd, join23(tempDir, "CLAUDE.md"));
     }
     profile = asSkillProfile(profileSkill(tempDir), "for the evolved proposal");
     const strictness = loadConfig().strictness;
@@ -5094,10 +5246,10 @@ function validateRunOutput(raw) {
   return { accepted: Boolean(obj.accepted), staging_dir: stagingDirRaw ?? null };
 }
 function readManifest(stagingDir) {
-  const manifestPath = join22(stagingDir, "manifest.json");
+  const manifestPath = join23(stagingDir, "manifest.json");
   let raw;
   try {
-    raw = readFileSync13(manifestPath, "utf-8");
+    raw = readFileSync14(manifestPath, "utf-8");
   } catch (err) {
     throw new UserError(`could not read staging manifest ${manifestPath}: ${err.message}`);
   }
@@ -5132,11 +5284,11 @@ function validateManifest(raw, manifestPath) {
 }
 function filesIdentical(a, b) {
   if (!existsSync19(a) || !existsSync19(b)) return false;
-  return readFileSync13(a).equals(readFileSync13(b));
+  return readFileSync14(a).equals(readFileSync14(b));
 }
 function isAlreadyAdopted(stagingDir, manifest) {
-  const proposedSkillMd = join22(stagingDir, "proposed_SKILL.md");
-  const proposedClaudeMd = join22(stagingDir, "proposed_CLAUDE.md");
+  const proposedSkillMd = join23(stagingDir, "proposed_SKILL.md");
+  const proposedClaudeMd = join23(stagingDir, "proposed_CLAUDE.md");
   let sawComparison = false;
   if (existsSync19(proposedSkillMd)) {
     sawComparison = true;
@@ -5151,7 +5303,7 @@ function isAlreadyAdopted(stagingDir, manifest) {
 function assertNotSymlink(path, label) {
   let stat;
   try {
-    stat = lstatSync2(path);
+    stat = lstatSync3(path);
   } catch {
     return;
   }
@@ -5161,7 +5313,7 @@ function assertNotSymlink(path, label) {
 }
 function sha256File(path) {
   if (!existsSync19(path)) return null;
-  return createHash("sha256").update(readFileSync13(path)).digest("hex");
+  return createHash2("sha256").update(readFileSync14(path)).digest("hex");
 }
 
 // src/commands/evolve.ts
@@ -5173,21 +5325,21 @@ async function evolveCommand(targetSkillDir, options = {}) {
 import { resolve as resolvePath7 } from "path";
 
 // src/organize.ts
-import { existsSync as existsSync20, readFileSync as readFileSync14, readdirSync as readdirSync7, realpathSync as realpathSync3, statSync as statSync9 } from "fs";
-import { basename as basename11, join as join23, resolve as resolvePath6 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync15, readdirSync as readdirSync8, realpathSync as realpathSync4, statSync as statSync9 } from "fs";
+import { basename as basename11, join as join24, resolve as resolvePath6 } from "path";
 var PRO_FEATURE_LABEL4 = "set-level organizer reports";
 var TIERS = /* @__PURE__ */ new Set(["resource", "custom"]);
 var MATURITIES = /* @__PURE__ */ new Set(["seedling", "stable", "deprecated"]);
 function listSubdirs2(dir) {
   let entries;
   try {
-    entries = readdirSync7(dir, { withFileTypes: true });
+    entries = readdirSync8(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const entry of entries) {
-    const full = join23(dir, entry.name);
+    const full = join24(dir, entry.name);
     if (entry.isDirectory()) {
       out.push(full);
       continue;
@@ -5205,14 +5357,14 @@ function findSkillDirsUnderRoot2(root) {
   const found = /* @__PURE__ */ new Set();
   const topDirs = listSubdirs2(root);
   for (const dir of topDirs) {
-    if (existsSync20(join23(dir, "SKILL.md"))) found.add(dir);
+    if (existsSync20(join24(dir, "SKILL.md"))) found.add(dir);
   }
-  for (const dir of listSubdirs2(join23(root, "skills"))) {
-    if (existsSync20(join23(dir, "SKILL.md"))) found.add(dir);
+  for (const dir of listSubdirs2(join24(root, "skills"))) {
+    if (existsSync20(join24(dir, "SKILL.md"))) found.add(dir);
   }
   for (const topDir of topDirs) {
-    for (const dir of listSubdirs2(join23(topDir, "skills"))) {
-      if (existsSync20(join23(dir, "SKILL.md"))) found.add(dir);
+    for (const dir of listSubdirs2(join24(topDir, "skills"))) {
+      if (existsSync20(join24(dir, "SKILL.md"))) found.add(dir);
     }
   }
   return Array.from(found).filter((p) => !p.includes("/.git/"));
@@ -5281,7 +5433,7 @@ function loadUsageSnapshot(snapshotPath) {
   const resolvedPath = resolvePath6(expandHome(snapshotPath));
   let raw;
   try {
-    raw = readFileSync14(resolvedPath, "utf-8");
+    raw = readFileSync15(resolvedPath, "utf-8");
   } catch (err) {
     return { usage: /* @__PURE__ */ new Map(), warning: `could not read usage snapshot (${err.message}); proceeding without usage` };
   }
@@ -5380,17 +5532,17 @@ function buildRegistryEntries(candidates, warnings) {
   for (const candidate of candidates) {
     let realPath;
     try {
-      realPath = realpathSync3(candidate.dirPath);
+      realPath = realpathSync4(candidate.dirPath);
     } catch (err) {
       warnings.push(`could not resolve skill directory ${candidate.dirPath}: ${err.message}`);
       continue;
     }
     if (seenRealPaths.has(realPath)) continue;
     seenRealPaths.add(realPath);
-    const skillMdPath = join23(realPath, "SKILL.md");
+    const skillMdPath = join24(realPath, "SKILL.md");
     let text;
     try {
-      text = readFileSync14(skillMdPath, "utf-8");
+      text = readFileSync15(skillMdPath, "utf-8");
     } catch (err) {
       warnings.push(`could not read ${skillMdPath}: ${err.message}`);
       continue;
@@ -5795,8 +5947,8 @@ async function find(query, options = {}, deps = {}) {
 }
 
 // src/commands/watch.ts
-import { realpathSync as realpathSync4 } from "fs";
-import { join as join24, resolve as resolvePath8 } from "path";
+import { realpathSync as realpathSync5 } from "fs";
+import { join as join25, resolve as resolvePath8 } from "path";
 var PRO_FEATURE_LABEL5 = "provenance drift watch (watch)";
 function isGitUrl(source) {
   const s = source.trim();
@@ -5846,7 +5998,7 @@ async function runWatch(config, options = {}, deps = {}) {
     let realPath = resolvedRoot;
     if (exists) {
       try {
-        realPath = realpathSync4(resolvedRoot);
+        realPath = realpathSync5(resolvedRoot);
       } catch {
         realPath = resolvedRoot;
       }
@@ -5858,7 +6010,7 @@ async function runWatch(config, options = {}, deps = {}) {
       ledger = readProvenanceLedger(resolvedRoot);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      const ledgerPath = join24(resolvedRoot, "SOURCES.md");
+      const ledgerPath = join25(resolvedRoot, "SOURCES.md");
       roots.push({ root, realPath, exists, ledgerPath, ledgerExists: false });
       warnings.push(`${ledgerPath}: could not read ledger: ${message}`);
       continue;
@@ -5950,7 +6102,7 @@ async function watchCommand(options = {}) {
 
 // src/commands/routine.ts
 import { existsSync as existsSync21, rmSync as rmSync7, statSync as statSync10 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var PRO_FEATURE_LABEL6 = "the scheduled maintenance routine";
 var SEVERITY_ORDER = ["LOW", "MEDIUM", "HIGH", "CRITICAL"];
 function parseFailOnFloor(failOn) {
@@ -5971,7 +6123,7 @@ function exceedsFloor(audit2, failOn) {
 }
 function resolveReportPath2(override, generatedAt) {
   if (override) return override;
-  return join25(getHomeDir(), "reports", `routine-${generatedAt.replace(/[:.]/g, "-")}.md`);
+  return join26(getHomeDir(), "reports", `routine-${generatedAt.replace(/[:.]/g, "-")}.md`);
 }
 function runHousekeeping(config, options) {
   const actions = [];
@@ -5980,7 +6132,7 @@ function runHousekeeping(config, options) {
   const pruneDays = options.pruneDays ?? 30;
   const cutoff = Date.now() - pruneDays * 864e5;
   for (const id of listQuarantineIds(config.quarantineDir)) {
-    const path = join25(config.quarantineDir, id);
+    const path = join26(config.quarantineDir, id);
     let mtime;
     try {
       mtime = statSync10(path).mtimeMs;
@@ -6192,8 +6344,8 @@ async function routineCommand(options = {}) {
 }
 
 // src/commands/ingest.ts
-import { realpathSync as realpathSync5 } from "fs";
-import { dirname as dirname11, isAbsolute, relative, resolve as resolvePath9 } from "path";
+import { realpathSync as realpathSync6 } from "fs";
+import { dirname as dirname11, isAbsolute as isAbsolute2, relative as relative2, resolve as resolvePath9 } from "path";
 var PRO_FEATURE_LABEL7 = "the pending-ingestion queue";
 var VALID_STATUSES = ["ingested", "dismissed"];
 function requireProFeature() {
@@ -6234,14 +6386,14 @@ function printPendingList(pending, json) {
 }
 function realpathOrNull(p) {
   try {
-    return realpathSync5(p);
+    return realpathSync6(p);
   } catch {
     return null;
   }
 }
 function isUnderRoot(candidate, root) {
-  const rel = relative(root, candidate);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+  const rel = relative2(root, candidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
 }
 function validatePendingEntries(entries, config) {
   const quarantineRoot = realpathOrNull(resolvePath9(config.quarantineDir));
@@ -6318,14 +6470,14 @@ async function queueClose(id, options = {}) {
 }
 
 // src/commands/refine.ts
-import { createHash as createHash3, randomUUID as randomUUID5 } from "crypto";
-import { chmodSync, existsSync as existsSync24, lstatSync as lstatSync3, mkdirSync as mkdirSync9, readFileSync as readFileSync16, realpathSync as realpathSync8, renameSync as renameSync6, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname13, isAbsolute as isAbsolute3, join as join28, relative as relative3, resolve as resolvePath12, sep as sep3 } from "path";
+import { createHash as createHash4, randomUUID as randomUUID5 } from "crypto";
+import { chmodSync, existsSync as existsSync24, lstatSync as lstatSync4, mkdirSync as mkdirSync9, readFileSync as readFileSync17, realpathSync as realpathSync9, renameSync as renameSync6, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname13, isAbsolute as isAbsolute4, join as join29, relative as relative4, resolve as resolvePath12, sep as sep4 } from "path";
 import { createInterface as createInterface6 } from "readline/promises";
 
 // src/refine/context.ts
-import { existsSync as existsSync23, realpathSync as realpathSync7, statSync as statSync12 } from "fs";
-import { isAbsolute as isAbsolute2, join as join27, relative as relative2, resolve as resolvePath11 } from "path";
+import { existsSync as existsSync23, realpathSync as realpathSync8, statSync as statSync12 } from "fs";
+import { isAbsolute as isAbsolute3, join as join28, relative as relative3, resolve as resolvePath11 } from "path";
 
 // src/refine/models.ts
 import { randomBytes } from "crypto";
@@ -6394,27 +6546,27 @@ function contentSimilarity(a, b) {
 }
 
 // src/refine/store.ts
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync22, readFileSync as readFileSync15, statSync as statSync11, realpathSync as realpathSync6 } from "fs";
-import { join as join26, resolve as resolvePath10 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync22, readFileSync as readFileSync16, statSync as statSync11, realpathSync as realpathSync7 } from "fs";
+import { join as join27, resolve as resolvePath10 } from "path";
 var SIMILARITY_JOIN_THRESHOLD = 0.7;
 var READY_THRESHOLD = 2;
 function getRefinementsDir() {
-  return join26(getHomeDir(), "refinements");
+  return join27(getHomeDir(), "refinements");
 }
 function getRefinementsPath() {
-  return join26(getRefinementsDir(), "refinements.json");
+  return join27(getRefinementsDir(), "refinements.json");
 }
 function getPatternsPath() {
-  return join26(getRefinementsDir(), "patterns.json");
+  return join27(getRefinementsDir(), "patterns.json");
 }
 function getBackupsDir() {
-  return join26(getRefinementsDir(), "backups");
+  return join27(getRefinementsDir(), "backups");
 }
 function readJsonFile(path, label) {
   let raw;
   try {
-    raw = readFileSync15(path, "utf-8");
+    raw = readFileSync16(path, "utf-8");
   } catch (err) {
     throw new UserError(`unable to read ${label} at ${path}: ${err.message}`);
   }
@@ -6517,7 +6669,7 @@ function writePatternsStore(store) {
 function resolveProjectRealpath(projectRoot) {
   const resolved = resolvePath10(projectRoot);
   try {
-    return realpathSync6(resolved);
+    return realpathSync7(resolved);
   } catch {
     return resolved;
   }
@@ -6652,13 +6804,13 @@ function createBackup(filePaths, deps = {}) {
     if (!existsSync22(path)) {
       return { path, existed: false, sha256: null, mode: null, contentBase64: null };
     }
-    const bytes = readFileSync15(path);
+    const bytes = readFileSync16(path);
     const mode = statSync11(path).mode & 511;
-    const sha256 = createHash2("sha256").update(bytes).digest("hex");
+    const sha256 = createHash3("sha256").update(bytes).digest("hex");
     return { path, existed: true, sha256, mode, contentBase64: bytes.toString("base64") };
   });
   const manifest = { id, createdAt: now.toISOString(), files };
-  writeJsonAtomic(join26(getBackupsDir(), id, "manifest.json"), manifest);
+  writeJsonAtomic(join27(getBackupsDir(), id, "manifest.json"), manifest);
   return manifest;
 }
 function validateBackupManifestShape(value, path) {
@@ -6707,7 +6859,7 @@ function readBackupManifest(id) {
   if (!isValidBackupId(id)) {
     throw new UserError(`invalid backup id "${id}" \u2014 expected the format produced by \`skill-forge refine promote\` (e.g. 20260720T142305Z-a1b2)`);
   }
-  const manifestPath = join26(getBackupsDir(), id, "manifest.json");
+  const manifestPath = join27(getBackupsDir(), id, "manifest.json");
   if (!existsSync22(manifestPath)) {
     throw new UserError(`no backup with id: ${id}`);
   }
@@ -6730,20 +6882,20 @@ function assertPlainSkillName(name) {
 }
 function realpathOrNull2(p) {
   try {
-    return realpathSync7(p);
+    return realpathSync8(p);
   } catch {
     return null;
   }
 }
 function isUnderRoot2(candidate, root) {
-  const rel = relative2(root, candidate);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+  const rel = relative3(root, candidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel);
 }
 function resolveScopes(config, cwd, skill, userRootFlag) {
   assertPlainSkillName(skill);
   const resolvedCwd = resolvePath11(cwd);
-  const localDir = join27(resolvedCwd, ".claude", "skills", skill);
-  const sharedDir = join27(resolvedCwd, "skills", skill);
+  const localDir = join28(resolvedCwd, ".claude", "skills", skill);
+  const sharedDir = join28(resolvedCwd, "skills", skill);
   const local = { scope: "local", dir: localDir, exists: existsSync23(localDir) };
   const shared = { scope: "shared", dir: sharedDir, exists: existsSync23(sharedDir) };
   const user = resolveUserScope(config, resolvedCwd, skill, userRootFlag);
@@ -6752,10 +6904,10 @@ function resolveScopes(config, cwd, skill, userRootFlag) {
 function resolveUserScope(config, resolvedCwd, skill, userRootFlag) {
   if (userRootFlag) {
     const root = resolvePath11(userRootFlag);
-    return { resolved: true, dir: join27(root, skill), root: userRootFlag, reason: "flag" };
+    return { resolved: true, dir: join28(root, skill), root: userRootFlag, reason: "flag" };
   }
   const cwdReal = realpathOrNull2(resolvedCwd) ?? resolvedCwd;
-  const candidates = config.skillsRoots.map((root) => ({ root, dir: join27(resolveConfiguredRoot2(root), skill) }));
+  const candidates = config.skillsRoots.map((root) => ({ root, dir: join28(resolveConfiguredRoot2(root), skill) }));
   for (const candidate of candidates) {
     const skillReal = realpathOrNull2(candidate.dir);
     if (skillReal) {
@@ -6790,12 +6942,12 @@ function inventoryScopeDir(scope, dir) {
     scope,
     dir,
     dirExists: isDirectory(dir),
-    skillMd: isFile2(join27(dir, "SKILL.md")),
-    patchMd: isFile2(join27(dir, "SKILL.patch.md")),
-    extendMd: isFile2(join27(dir, "SKILL.extend.md")),
-    configJson: isFile2(join27(dir, "skill-config.json")),
-    hooksDir: isDirectory(join27(dir, "hooks")),
-    scriptsDir: isDirectory(join27(dir, "scripts"))
+    skillMd: isFile2(join28(dir, "SKILL.md")),
+    patchMd: isFile2(join28(dir, "SKILL.patch.md")),
+    extendMd: isFile2(join28(dir, "SKILL.extend.md")),
+    configJson: isFile2(join28(dir, "skill-config.json")),
+    hooksDir: isDirectory(join28(dir, "hooks")),
+    scriptsDir: isDirectory(join28(dir, "scripts"))
   };
 }
 function inventoryAllScopes(resolution) {
@@ -7067,15 +7219,15 @@ function resolveConfiguredRoot3(root) {
   return resolvePath12(expandHome(root));
 }
 function isUnderRoot3(candidate, root) {
-  const rel = relative3(root, candidate);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel);
+  const rel = relative4(root, candidate);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute4(rel);
 }
 function sanitizeDiffForConsole(diff) {
   return diff.split("\n").map((line) => sanitizeForMarkdown(line)).join("\n");
 }
 function resolveContentOption(options) {
   if (options.content !== void 0) return options.content;
-  if (options.contentFile) return readFileSync16(resolvePath12(options.contentFile), "utf-8");
+  if (options.contentFile) return readFileSync17(resolvePath12(options.contentFile), "utf-8");
   return void 0;
 }
 function validateCaptureOptions(options) {
@@ -7201,7 +7353,7 @@ ${rendered}` : rendered;
 function ensureScopeDirSafe(scopeDir, resolvedCwd) {
   let lst;
   try {
-    lst = lstatSync3(scopeDir);
+    lst = lstatSync4(scopeDir);
   } catch {
     lst = void 0;
   }
@@ -7213,7 +7365,7 @@ function ensureScopeDirSafe(scopeDir, resolvedCwd) {
   const lexical = resolvePath12(scopeDir);
   let realResolved;
   try {
-    realResolved = realpathSync8(scopeDir);
+    realResolved = realpathSync9(scopeDir);
   } catch {
     realResolved = real;
   }
@@ -7227,16 +7379,16 @@ function ensureScopeDirSafe(scopeDir, resolvedCwd) {
 }
 function writeOverrideFile(scopeDir, relPath, content, resolvedCwd) {
   const realScopeDir = ensureScopeDirSafe(scopeDir, resolvedCwd);
-  const destPath = join28(scopeDir, relPath);
+  const destPath = join29(scopeDir, relPath);
   const destDir = dirname13(destPath);
   mkdirSync9(destDir, { recursive: true });
-  const realDestDir = realpathSync8(destDir);
+  const realDestDir = realpathSync9(destDir);
   if (!isUnderRoot3(realDestDir, realScopeDir)) {
     throw new UserError(`refusing to write ${destPath}: resolves outside scope directory ${scopeDir}`);
   }
   let destLst;
   try {
-    destLst = lstatSync3(destPath);
+    destLst = lstatSync4(destPath);
   } catch {
     destLst = void 0;
   }
@@ -7323,12 +7475,12 @@ Write ${preview.destPath}? [y/N] `);
 }
 function renderCaptureArtifactPreview(opts, content, refinementId, generatedAt, scopeDir) {
   const probeRelPath = opts.overrideType === "patch" ? "SKILL.patch.md" : opts.overrideType === "extend" || opts.overrideType === "new" ? "SKILL.extend.md" : void 0;
-  const probePath = probeRelPath ? join28(scopeDir, probeRelPath) : void 0;
-  const existingContent = probePath && existsSync24(probePath) ? readFileSync16(probePath, "utf-8") : "";
+  const probePath = probeRelPath ? join29(scopeDir, probeRelPath) : void 0;
+  const existingContent = probePath && existsSync24(probePath) ? readFileSync17(probePath, "utf-8") : "";
   const rendered = renderCaptureArtifact(opts, content, refinementId, generatedAt, existingContent);
   const relPath = rendered.relPath;
-  const destPath = join28(scopeDir, relPath);
-  const before = existsSync24(destPath) ? readFileSync16(destPath, "utf-8") : "";
+  const destPath = join29(scopeDir, relPath);
+  const before = existsSync24(destPath) ? readFileSync17(destPath, "utf-8") : "";
   const diff = previewDiff(before, rendered.content, destPath);
   return { relPath, content: rendered.content, destPath, diff };
 }
@@ -7425,16 +7577,16 @@ async function refineWhichCommand(skill, options = {}) {
 }
 function writePostWriteSidecar(backupId, files) {
   const sidecar = { schemaVersion: 1, files };
-  const dir = join28(getBackupsDir(), backupId);
+  const dir = join29(getBackupsDir(), backupId);
   mkdirSync9(dir, { recursive: true });
-  writeFileSync9(join28(dir, "post.json"), JSON.stringify(sidecar, null, 2) + "\n", { mode: 384 });
+  writeFileSync9(join29(dir, "post.json"), JSON.stringify(sidecar, null, 2) + "\n", { mode: 384 });
 }
 function readPostWriteSidecar(backupId) {
-  const path = join28(getBackupsDir(), backupId, "post.json");
+  const path = join29(getBackupsDir(), backupId, "post.json");
   if (!existsSync24(path)) return { hashes: /* @__PURE__ */ new Map(), status: "missing" };
   let raw;
   try {
-    raw = readFileSync16(path, "utf-8");
+    raw = readFileSync17(path, "utf-8");
   } catch {
     return { hashes: /* @__PURE__ */ new Map(), status: "unreadable" };
   }
@@ -7479,20 +7631,20 @@ async function refinePromoteCommand(patternId, options = {}) {
   const resolvedUserRoot = resolveConfiguredRoot3(scopes.user.root);
   let realUserRoot;
   try {
-    realUserRoot = realpathSync8(resolvedUserRoot);
+    realUserRoot = realpathSync9(resolvedUserRoot);
   } catch {
     realUserRoot = resolvedUserRoot;
   }
   let realSkillDir;
   try {
-    realSkillDir = realpathSync8(skillDir);
+    realSkillDir = realpathSync9(skillDir);
   } catch {
     realSkillDir = resolvePath12(skillDir);
   }
   if (!isUnderRoot3(realSkillDir, realUserRoot)) {
     throw new UserError(`refusing to promote: resolved skill directory ${skillDir} is outside the configured user scope root ${scopes.user.root}`);
   }
-  const skillMdPath = join28(skillDir, "SKILL.md");
+  const skillMdPath = join29(skillDir, "SKILL.md");
   if (!existsSync24(skillMdPath)) {
     throw new UserError(`user-scope SKILL.md not found at ${skillMdPath} \u2014 refusing to promote against a missing base skill.`);
   }
@@ -7510,7 +7662,7 @@ async function refinePromoteCommand(patternId, options = {}) {
       `pattern ${patternId}'s representative refinement is a '${representative.overrideType}' override \u2014 promote currently only materializes patch/extend/new-type patterns against the user-scope SKILL.md; other override types must be merged manually.`
     );
   }
-  const before = readFileSync16(skillMdPath, "utf-8");
+  const before = readFileSync17(skillMdPath, "utf-8");
   const after = applyPatchBlocks(before, [block]);
   const diff = previewDiff(before, after, skillMdPath);
   if (options.dryRun) {
@@ -7542,7 +7694,7 @@ Promote pattern ${patternId} into ${skillMdPath}? [y/N] `);
     throw err;
   }
   try {
-    const postSha256 = createHash3("sha256").update(readFileSync16(skillMdPath)).digest("hex");
+    const postSha256 = createHash4("sha256").update(readFileSync17(skillMdPath)).digest("hex");
     writePostWriteSidecar(backup.id, [{ path: skillMdPath, sha256: postSha256 }]);
     markGeneralized(patternId, backup.id);
     const skillsRoot = resolveConfiguredRoot3(scopes.user.root);
@@ -7569,10 +7721,10 @@ Promote pattern ${patternId} into ${skillMdPath}? [y/N] `);
 function assertBackupDirContained(backupId) {
   const backupsDir = getBackupsDir();
   if (!existsSync24(backupsDir)) return;
-  const realBackupsDir = realpathSync8(backupsDir);
-  const backupDir = join28(backupsDir, backupId);
+  const realBackupsDir = realpathSync9(backupsDir);
+  const backupDir = join29(backupsDir, backupId);
   if (!existsSync24(backupDir)) return;
-  const realBackupDir = realpathSync8(backupDir);
+  const realBackupDir = realpathSync9(backupDir);
   if (!isUnderRoot3(realBackupDir, realBackupsDir)) {
     throw new UserError(`refusing rollback: backup id "${backupId}" resolves outside the backups directory`);
   }
@@ -7581,9 +7733,9 @@ function resolveTargetRealPath(path) {
   let lexicalAncestor = resolvePath12(path);
   while (true) {
     try {
-      const real = realpathSync8(lexicalAncestor);
-      const remainder = relative3(lexicalAncestor, resolvePath12(path));
-      return remainder === "" ? real : join28(real, remainder);
+      const real = realpathSync9(lexicalAncestor);
+      const remainder = relative4(lexicalAncestor, resolvePath12(path));
+      return remainder === "" ? real : join29(real, remainder);
     } catch {
       const parent = dirname13(lexicalAncestor);
       if (parent === lexicalAncestor) return resolvePath12(path);
@@ -7598,7 +7750,7 @@ function assertManifestPathsWithinRoots(manifest, config) {
   const roots = config.skillsRoots.map((root) => {
     const resolved = resolveConfiguredRoot3(root);
     try {
-      return realpathSync8(resolved);
+      return realpathSync9(resolved);
     } catch {
       return resolved;
     }
@@ -7615,7 +7767,7 @@ function assertNoSymlinkLeaves(manifest) {
   for (const file of manifest.files) {
     let lst;
     try {
-      lst = lstatSync3(file.path);
+      lst = lstatSync4(file.path);
     } catch {
       lst = void 0;
     }
@@ -7628,11 +7780,11 @@ function findLexicalRoot(filePath, config) {
   const lexicalTarget = resolvePath12(filePath);
   for (const root of config.skillsRoots) {
     const rootLexical = resolveConfiguredRoot3(root);
-    const rel = relative3(rootLexical, lexicalTarget);
-    if (rel !== "" && (rel === ".." || rel.startsWith(`..${sep3}`) || isAbsolute3(rel))) continue;
+    const rel = relative4(rootLexical, lexicalTarget);
+    if (rel !== "" && (rel === ".." || rel.startsWith(`..${sep4}`) || isAbsolute4(rel))) continue;
     let rootReal;
     try {
-      rootReal = realpathSync8(rootLexical);
+      rootReal = realpathSync9(rootLexical);
     } catch {
       rootReal = rootLexical;
     }
@@ -7642,8 +7794,8 @@ function findLexicalRoot(filePath, config) {
 }
 function walkRealComponents(filePath, config, createMissing) {
   const { rootLexical, rootReal } = findLexicalRoot(filePath, config);
-  const relPath = relative3(rootLexical, resolvePath12(filePath));
-  const components = relPath.split(sep3).filter((c) => c.length > 0);
+  const relPath = relative4(rootLexical, resolvePath12(filePath));
+  const components = relPath.split(sep4).filter((c) => c.length > 0);
   if (components.length === 0) {
     throw new UserError(`refusing to operate on ${filePath}: resolves to the skills root itself`);
   }
@@ -7652,10 +7804,10 @@ function walkRealComponents(filePath, config, createMissing) {
   let current = rootReal;
   for (const component of dirComponents) {
     if (current === void 0) break;
-    const next = join28(current, component);
+    const next = join29(current, component);
     let lst;
     try {
-      lst = lstatSync3(next);
+      lst = lstatSync4(next);
     } catch {
       lst = void 0;
     }
@@ -7683,13 +7835,13 @@ function safeRestoreWrite(filePath, contentBuffer, mode, config) {
   if (parentReal === void 0) {
     throw new UserError(`refusing to restore ${filePath}: could not establish a real parent directory`);
   }
-  const finalPath = join28(parentReal, leafComponent);
+  const finalPath = join29(parentReal, leafComponent);
   if (!isUnderRoot3(finalPath, rootReal)) {
     throw new UserError(`refusing to restore ${filePath}: resolves outside root ${rootReal}`);
   }
   let leafLst;
   try {
-    leafLst = lstatSync3(finalPath);
+    leafLst = lstatSync4(finalPath);
   } catch {
     leafLst = void 0;
   }
@@ -7709,13 +7861,13 @@ function safeRestoreWrite(filePath, contentBuffer, mode, config) {
 function safeDeleteTombstone(filePath, config) {
   const { parentReal, leafComponent, rootReal } = walkRealComponents(filePath, config, false);
   if (parentReal === void 0) return;
-  const finalPath = join28(parentReal, leafComponent);
+  const finalPath = join29(parentReal, leafComponent);
   if (!isUnderRoot3(finalPath, rootReal)) {
     throw new UserError(`refusing to delete ${filePath}: resolves outside root ${rootReal}`);
   }
   let leafLst;
   try {
-    leafLst = lstatSync3(finalPath);
+    leafLst = lstatSync4(finalPath);
   } catch {
     leafLst = void 0;
   }
@@ -7751,7 +7903,7 @@ async function refineRollbackCommand(backupId, options = {}) {
   for (const file of manifest.files) {
     const expected = sidecar.hashes.get(file.path);
     if (expected === void 0) continue;
-    const currentSha256 = existsSync24(file.path) ? createHash3("sha256").update(readFileSync16(file.path)).digest("hex") : null;
+    const currentSha256 = existsSync24(file.path) ? createHash4("sha256").update(readFileSync17(file.path)).digest("hex") : null;
     if (currentSha256 !== expected) mismatches.push(file.path);
   }
   if (mismatches.length > 0 && !options.force) {