@csark0812/skeleton 2.0.0 → 3.0.1

package/dist/cli.js

@@ -15678,7 +15678,7 @@ var require_extend = __commonJS((exports, module) => {
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync26 } from "node:fs";
+import { readFileSync as readFileSync25 } from "node:fs";
 import process9 from "node:process";
 
 // src/audit/config/load.ts
@@ -30641,438 +30641,61 @@ function printTextReport(ctx) {
 
 // src/audit/core/review-proof.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync13, mkdirSync as mkdirSync2, readFileSync as readFileSync12, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync2, readFileSync as readFileSync11, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname8, relative as relative6 } from "node:path";
 
-// src/audit/core/code-fit.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "node:fs";
-import { join as join11 } from "node:path";
-
-// src/audit/core/ssot-fit.ts
-var DEFAULT_SSOT_OVERLAP_MIN = 0.35;
-var DEFAULT_BETTER_MATCH_MARGIN = 0.15;
-var STOP = new Set([
-  "a",
-  "an",
-  "the",
-  "and",
-  "or",
-  "of",
-  "for",
-  "to",
-  "in",
-  "on",
-  "with",
-  "this",
-  "that",
-  "is",
-  "are",
-  "be",
-  "as",
-  "by",
-  "from",
-  "at",
-  "it",
-  "its"
-]);
-var STEM_BLOCKLIST = new Set([
-  "business",
-  "analysis",
-  "status",
-  "process",
-  "access",
-  "address",
-  "series",
-  "species",
-  "news",
-  "means",
-  "cross",
-  "class",
-  "glass",
-  "less",
-  "success",
-  "progress",
-  "express",
-  "discuss",
-  "focus",
-  "bonus",
-  "basis",
-  "crisis",
-  "thesis",
-  "atlas",
-  "canvas",
-  "campus",
-  "virus",
-  "bus",
-  "gas",
-  "plus",
-  "alias",
-  "bias",
-  "circus",
-  "consensus",
-  "census"
-]);
-function lightStem(token) {
-  if (token.length < 4)
-    return token;
-  if (STEM_BLOCKLIST.has(token))
-    return token;
-  if (token.endsWith("ies") && token.length > 4) {
-    return `${token.slice(0, -3)}y`;
-  }
-  if (token.endsWith("sses") || token.endsWith("ches") || token.endsWith("shes") || token.endsWith("xes")) {
-    return token.slice(0, -2);
-  }
-  if (token.endsWith("s") && !token.endsWith("ss") && !token.endsWith("us") && !token.endsWith("is")) {
-    return token.slice(0, -1);
-  }
-  return token;
-}
-function contentTokens(text5) {
-  return text5.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 1 && !STOP.has(t)).map(lightStem);
-}
-function uniqueContentTokens(text5) {
-  return [...new Set(contentTokens(text5))];
-}
-function stripCode2(content3) {
-  return content3.replace(/```[\s\S]*?```/g, `
-`).replace(/`[^`\n]+`/g, " ");
-}
-function stripSsotAndMeta(content3) {
-  return content3.replace(/<!--\s*source-of-truth:[\s\S]*?-->/gi, `
-`).replace(/^\s*source-of-truth:\s*.+$/gim, `
-`).replace(/^\s*\*\*Source of truth for\*\*\s*.+$/gim, `
-`).replace(/<!--\s*doc-meta:[\s\S]*?-->/gi, `
-`);
-}
-function extractH1(content3) {
-  const prose = stripCode2(content3);
-  const m = /^#\s+(.+)$/m.exec(prose);
-  return m?.[1]?.trim() ?? "";
-}
-function extractLeadParagraph(content3) {
-  const prose = stripSsotAndMeta(stripCode2(content3));
-  const lines = prose.split(/\n/);
-  const chunks = [];
-  let buf = [];
-  const flush = () => {
-    const t = buf.join(" ").trim();
-    if (t)
-      chunks.push(t);
-    buf = [];
-  };
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
-      flush();
-      continue;
-    }
-    if (/^[-*|]/.test(trimmed) && chunks.length === 0 && buf.length === 0) {
-      buf.push(trimmed.replace(/^[-*|]+\s*/, ""));
-      continue;
-    }
-    buf.push(trimmed);
-  }
-  flush();
-  return chunks[0] ?? "";
-}
-function buildEvidenceText(content3) {
-  const h1 = extractH1(content3);
-  const lead = extractLeadParagraph(content3);
-  const body = stripSsotAndMeta(stripCode2(content3));
-  return [h1, lead, body].filter(Boolean).join(`
-
-`);
-}
-function ssotEvidenceOverlap(summary, evidence) {
-  const st = uniqueContentTokens(summary);
-  if (st.length === 0)
-    return 0;
-  const ev = new Set(contentTokens(evidence));
-  let hit = 0;
-  for (const t of st) {
-    if (ev.has(t))
-      hit++;
-  }
-  return hit / st.length;
-}
-function longestSummaryPhrase(summary) {
-  const toks = contentTokens(summary);
-  if (toks.length >= 3)
-    return toks.slice(0, 3);
-  if (toks.length >= 2)
-    return toks.slice(0, 2);
-  return null;
-}
-function evidenceHasPhrase(evidence, phrase) {
-  if (phrase.length === 0)
-    return true;
-  const ev = contentTokens(evidence);
-  const needle = phrase.join(" ");
-  for (let i = 0;i <= ev.length - phrase.length; i++) {
-    if (ev.slice(i, i + phrase.length).join(" ") === needle)
-      return true;
-  }
-  return false;
-}
-function evaluateSsotFit(files, options = {}) {
-  const overlapMin = options.overlapMin ?? DEFAULT_SSOT_OVERLAP_MIN;
-  const margin = options.betterMatchMargin ?? DEFAULT_BETTER_MATCH_MARGIN;
-  const phraseCheck = options.phraseCheck !== false;
-  const prepared = files.map((f) => {
-    const evidence = buildEvidenceText(f.content);
-    const overlap = ssotEvidenceOverlap(f.summary, evidence);
-    const summaryToks = uniqueContentTokens(f.summary);
-    return { ...f, evidence, overlap, summaryToks };
-  });
-  const issues = [];
-  for (const row of prepared) {
-    if (row.summaryToks.length < 2) {
-      issues.push({
-        kind: "short",
-        path: row.path,
-        message: `source-of-truth summary too short to verify against body ("${row.summary}")`
-      });
-      continue;
-    }
-    if (row.overlap < overlapMin) {
-      let message = `source-of-truth summary weakly matches this paper (token overlap ${row.overlap.toFixed(2)} < ${overlapMin})`;
-      if (phraseCheck) {
-        const phrase = longestSummaryPhrase(row.summary);
-        if (phrase && !evidenceHasPhrase(row.evidence, phrase)) {
-          message += ` — key phrase "${phrase.join(" ")}" not found in H1/lead/body`;
-        }
-      }
-      issues.push({ kind: "weak", path: row.path, message });
-      let best = null;
-      for (const other of prepared) {
-        if (other.path === row.path)
-          continue;
-        const cross = ssotEvidenceOverlap(row.summary, other.evidence);
-        if (cross < overlapMin)
-          continue;
-        if (cross < row.overlap + margin)
-          continue;
-        if (!best || cross > best.overlap)
-          best = { path: other.path, overlap: cross };
-      }
-      if (best) {
-        issues.push({
-          kind: "better-match",
-          path: row.path,
-          otherPath: best.path,
-          message: `source-of-truth fits ${best.path} better (overlap ${best.overlap.toFixed(2)} vs own ${row.overlap.toFixed(2)}). ` + `Try: (1) rewrite this SSOT to match this paper, (2) move/fix the marker onto ${best.path}, ` + `or (3) if these pages are really one topic, consider combining them`
-        });
-      }
-    }
-  }
-  return issues;
-}
-
-// src/audit/core/code-fit.ts
-var DEFAULT_CODE_FIT_OVERLAP_MIN = 0.03;
-var DEFAULT_CODE_FIT_SURFACE_CAP = 25;
-var CODE_FIT_RE = /<!--\s*code-fit:\s*([^>]*?)-->/gi;
-function parseCodeFitMarkers(content3) {
+// src/audit/core/review-deps.ts
+import { existsSync as existsSync12 } from "node:fs";
+var REVIEW_DEPS_RE = /<!--\s*review-deps:\s*([^>]*?)-->/gi;
+var GLOB_MAGIC_RE = /[*?{[]/;
+function parseReviewDepsMarkers(content3) {
   const withoutCode = content3.replace(/```[\s\S]*?```/g, `
 `).replace(/`[^`\n]+`/g, " ");
   const out = [];
-  for (const match of withoutCode.matchAll(CODE_FIT_RE)) {
-    const body = (match[1] ?? "").trim();
-    const parsed = parseMarkerBody(body);
-    if (parsed)
-      out.push(parsed);
+  for (const match of withoutCode.matchAll(REVIEW_DEPS_RE)) {
+    const raw = (match[1] ?? "").trim();
+    const pathsMatch = /\bpaths\s*=\s*([^\s]+)/i.exec(raw);
+    const paths = pathsMatch?.[1] ? pathsMatch[1].split(",").map((path3) => normalizeRelPath(path3.trim())).filter(Boolean) : [];
+    out.push({ paths, raw });
   }
   return out;
 }
-function parseMarkerBody(body) {
-  const targetsMatch = /\btargets\s*=\s*([^\s]+)/i.exec(body);
-  if (!targetsMatch?.[1])
-    return null;
-  const targets = targetsMatch[1].split(",").map((t) => t.trim()).filter(Boolean);
-  if (targets.length === 0)
-    return null;
-  const surfaceMatch = /\bsurface\s*=\s*([^\s]+)/i.exec(body);
-  const surface = surfaceMatch?.[1] ? surfaceMatch[1].split(",").map((s) => s.trim()).filter(Boolean) : null;
-  return { targets, surface, raw: body };
+function reviewDependencyPatterns(content3) {
+  return [...new Set(parseReviewDepsMarkers(content3).flatMap((marker) => marker.paths))].sort();
 }
-function stripCodeNoise(source) {
-  return source.replace(/\/\*[\s\S]*?\*\//g, `
-`).replace(/\/\/[^\n]*/g, `
-`).replace(/`(?:\\.|[^`\\])*`/g, " ").replace(/'(?:\\.|[^'\\])*'/g, " ").replace(/"(?:\\.|[^"\\])*"/g, " ");
+function isReviewDependencyGlob(pattern) {
+  return GLOB_MAGIC_RE.test(pattern);
 }
-function extractPublicSurface(source) {
-  const names = new Set;
-  for (const m of source.matchAll(/\bcase\s+["']([^"']+)["']\s*:/g)) {
-    if (m[1])
-      names.add(m[1]);
-  }
-  for (const m of source.matchAll(/\bexport\s+(?:async\s+)?(?:function|class|const|let|var|type|interface|enum)\s+([A-Za-z_$][\w$]*)/g)) {
-    if (m[1])
-      names.add(m[1]);
-  }
-  for (const m of source.matchAll(/\bexport\s+default\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/g)) {
-    if (m[1])
-      names.add(m[1]);
-  }
-  for (const m of source.matchAll(/\bexport\s+default\s+class\s+([A-Za-z_$][\w$]*)/g)) {
-    if (m[1])
-      names.add(m[1]);
-  }
-  collectExportListNames(source, names);
-  return [...names].sort();
+function isSafeReviewDependencyPath(value) {
+  const normalized = normalizeRelPath(value);
+  return value.length > 0 && value === normalized && normalized !== "." && normalized !== ".." && !normalized.startsWith("/") && !normalized.startsWith("../") && !normalized.includes("/../") && !/^[A-Za-z]:\//.test(normalized);
 }
-function collectExportListNames(source, names) {
-  for (const m of source.matchAll(/\bexport\s*\{([^}]+)\}/g)) {
-    const inner = m[1] ?? "";
-    for (const part of inner.split(",")) {
-      addExportListPart(part.trim(), names);
+function resolveReviewDependencies(root2, patterns) {
+  const targets = new Set;
+  for (const pattern of patterns) {
+    if (!isSafeReviewDependencyPath(pattern)) {
+      throw new Error(`Invalid review dependency path: ${pattern}`);
     }
-  }
-}
-function addExportListPart(cleaned, names) {
-  if (!cleaned || cleaned === "type" || cleaned === "typeof")
-    return;
-  const asMatch = /^([\w$]+)\s+as\s+([\w$]+)$/.exec(cleaned);
-  if (asMatch?.[2]) {
-    names.add(asMatch[2]);
-    return;
-  }
-  const typeAs = /^type\s+([\w$]+)(?:\s+as\s+([\w$]+))?$/.exec(cleaned);
-  if (typeAs?.[1]) {
-    names.add(typeAs[2] ?? typeAs[1]);
-    return;
-  }
-  const id = /^([\w$]+)$/.exec(cleaned);
-  if (id?.[1])
-    names.add(id[1]);
-}
-function codeIdentifiers(source) {
-  const stripped = stripCodeNoise(source);
-  return uniqueContentTokens(stripped.replace(/[^A-Za-z0-9_$]+/g, " ").replace(/_/g, " "));
-}
-function identifierOverlap(docContent, codeSource) {
-  const codeIds = new Set(codeIdentifiers(codeSource));
-  if (codeIds.size === 0)
-    return 1;
-  const docToks = uniqueContentTokens(docContent);
-  if (docToks.length === 0)
-    return 0;
-  let hit = 0;
-  for (const t of docToks) {
-    if (codeIds.has(t))
-      hit++;
-  }
-  return hit / docToks.length;
-}
-function nameInDoc(name, docContent) {
-  const docToks = new Set(contentTokens(docContent));
-  const parts = uniqueContentTokens(name.replace(/_/g, " "));
-  if (parts.length === 0) {
-    return docToks.has(name.toLowerCase());
-  }
-  const asToken = contentTokens(name);
-  if (asToken.some((t) => docToks.has(t)))
-    return true;
-  return parts.every((p) => docToks.has(p));
-}
-function nameExistsInTarget(name, autoSurface, source) {
-  if (autoSurface.includes(name))
-    return true;
-  const ids = new Set(extractPublicSurface(source));
-  if (ids.has(name))
-    return true;
-  const re = new RegExp(`\\b${escapeRegExp(name)}\\b`);
-  return re.test(source);
-}
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function pushCoverageGaps(issues, input, effective) {
-  if (effective.length === 0)
-    return;
-  const missing = effective.filter((n) => !nameInDoc(n, input.docContent));
-  if (missing.length === 0)
-    return;
-  issues.push({
-    path: input.docPath,
-    message: `code-fit coverage: doc does not mention ${missing.map((m) => `"${m}"`).join(", ")} (from ${input.target})`,
-    link: input.target
-  });
-}
-function pushLexicalGap(issues, input, source) {
-  const overlapMin = input.options.overlapMin ?? DEFAULT_CODE_FIT_OVERLAP_MIN;
-  const overlap = identifierOverlap(input.docContent, source);
-  if (overlap + 0.000000001 >= overlapMin)
-    return;
-  issues.push({
-    path: input.docPath,
-    message: `code-fit lexical overlap ${(overlap * 100).toFixed(0)}% < ${(overlapMin * 100).toFixed(0)}% vs ${input.target}`,
-    link: input.target
-  });
-}
-function evaluateTarget(input) {
-  const issues = [];
-  const abs = join11(input.options.root, input.target);
-  if (!existsSync12(abs)) {
-    issues.push({
-      path: input.docPath,
-      message: `code-fit target missing: ${input.target}`,
-      link: input.target
-    });
-    return issues;
-  }
-  const source = readFileSync11(abs, "utf8");
-  const auto = extractPublicSurface(source);
-  const cap = input.options.surfaceCap ?? DEFAULT_CODE_FIT_SURFACE_CAP;
-  if (input.surfaceOverride === null && auto.length > cap) {
-    issues.push({
-      path: input.docPath,
-      message: `code-fit auto-surface has ${auto.length} names (cap ${cap}); add surface=… to the marker for ${input.target}`,
-      link: input.target
-    });
-    return issues;
-  }
-  if (input.surfaceOverride !== null) {
-    for (const name of input.surfaceOverride) {
-      if (!nameExistsInTarget(name, auto, source)) {
-        issues.push({
-          path: input.docPath,
-          message: `code-fit surface name "${name}" not found in ${input.target}`,
-          link: input.target
-        });
+    if (!isReviewDependencyGlob(pattern)) {
+      if (!existsSync12(`${root2}/${pattern}`)) {
+        throw new Error(`Review dependency path is missing: ${pattern}`);
       }
-    }
-  }
-  const effective = input.surfaceOverride !== null ? input.surfaceOverride : auto;
-  pushCoverageGaps(issues, input, effective);
-  pushLexicalGap(issues, input, source);
-  return issues;
-}
-function evaluateCodeFitDoc(docPath, docContent, options) {
-  const markers = parseCodeFitMarkers(docContent);
-  if (markers.length === 0)
-    return [];
-  const issues = [];
-  for (const marker of markers) {
-    if (marker.targets.length === 0) {
-      issues.push({
-        path: docPath,
-        message: "code-fit marker missing targets="
-      });
+      targets.add(pattern);
       continue;
     }
-    for (const target of marker.targets) {
-      issues.push(...evaluateTarget({
-        docPath,
-        docContent,
-        target,
-        surfaceOverride: marker.surface,
-        options
-      }));
+    for (const match of globSync(pattern, {
+      cwd: root2,
+      onlyFiles: true,
+      dot: true,
+      ignore: [".git/**"]
+    })) {
+      targets.add(normalizeRelPath(match));
     }
   }
-  return issues;
+  return { patterns: [...new Set(patterns)].sort(), targets: [...targets].sort() };
+}
+function reviewDependencyMatchesPath(pattern, relPath2) {
+  return isReviewDependencyGlob(pattern) ? matchesGlobScope(relPath2, pattern) : normalizeRelPath(relPath2) === pattern;
 }
 
 // src/audit/core/review-proof.ts
@@ -31087,7 +30710,7 @@ function hash(content3) {
   return `sha256:${createHash("sha256").update(content3, "utf8").digest("hex")}`;
 }
 function emptyLock() {
-  return { version: 1, documents: {} };
+  return { version: 2, documents: {} };
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -31112,17 +30735,17 @@ function parseEntry(value) {
     return null;
   if (!isHash(value.documentHash))
     return null;
-  if (!isRecord(value.codeTargets))
+  if (!isRecord(value.reviewDependencies))
     return null;
-  const codeTargets = {};
-  for (const [target, targetHash] of Object.entries(value.codeTargets)) {
+  const reviewDependencies = {};
+  for (const [target, targetHash] of Object.entries(value.reviewDependencies)) {
     if (!isSafeRepoPath(target))
       return null;
     if (!isHash(targetHash))
       return null;
-    codeTargets[target] = targetHash;
+    reviewDependencies[target] = targetHash;
   }
-  return { reviewedAt: value.reviewedAt, documentHash: value.documentHash, codeTargets };
+  return { reviewedAt: value.reviewedAt, documentHash: value.documentHash, reviewDependencies };
 }
 function lockPath(ctx) {
   return normalizeRelPath(ctx.config.reviewProof?.lockfile ?? DEFAULT_REVIEW_LOCKFILE);
@@ -31130,7 +30753,7 @@ function lockPath(ctx) {
 function parseLock(content3) {
   try {
     const parsed = JSON.parse(content3);
-    if (!isRecord(parsed) || parsed.version !== 1 || !isRecord(parsed.documents))
+    if (!isRecord(parsed) || parsed.version !== 2 || !isRecord(parsed.documents))
       return null;
     const documents = {};
     for (const [path3, value] of Object.entries(parsed.documents)) {
@@ -31141,7 +30764,7 @@ function parseLock(content3) {
         return null;
       documents[path3] = entry;
     }
-    return { version: 1, documents };
+    return { version: 2, documents };
   } catch {
     return null;
   }
@@ -31150,18 +30773,15 @@ function loadLock(root2, relPath2) {
   const abs = resolveWritePath(root2, relPath2);
   if (!existsSync13(abs))
     return null;
-  return parseLock(readFileSync12(abs, "utf8"));
-}
-function codeTargets(content3) {
-  return [...new Set(parseCodeFitMarkers(content3).flatMap((marker) => marker.targets))].sort();
+  return parseLock(readFileSync11(abs, "utf8"));
 }
-function hashTargets(root2, targets) {
+function hashDependencies(root2, targets) {
   const out = {};
   for (const target of targets) {
     const abs = resolveWritePath(root2, target);
     if (!existsSync13(abs))
-      throw new Error(`Cannot attest missing code-fit target: ${target}`);
-    out[target] = hash(readFileSync12(abs, "utf8"));
+      throw new Error(`Cannot attest missing review dependency: ${target}`);
+    out[target] = hash(readFileSync11(abs, "utf8"));
   }
   return out;
 }
@@ -31174,10 +30794,10 @@ function sortedLock(lock) {
     documents[path3] = {
       reviewedAt: entry.reviewedAt,
       documentHash: entry.documentHash,
-      codeTargets: Object.fromEntries(Object.entries(entry.codeTargets).sort(([a], [b]) => a.localeCompare(b)))
+      reviewDependencies: Object.fromEntries(Object.entries(entry.reviewDependencies).sort(([a], [b]) => a.localeCompare(b)))
     };
   }
-  return { version: 1, documents };
+  return { version: 2, documents };
 }
 function validateReviewedAt(reviewedAt) {
   if (!isCalendarDate(reviewedAt)) {
@@ -31190,7 +30810,7 @@ function commitWrites(root2, writes) {
   try {
     for (const [relPath2, content3] of writes) {
       const abs = resolveWritePath(root2, relPath2);
-      originals.set(relPath2, existsSync13(abs) ? readFileSync12(abs, "utf8") : null);
+      originals.set(relPath2, existsSync13(abs) ? readFileSync11(abs, "utf8") : null);
       mkdirSync2(dirname8(abs), { recursive: true });
       writeFileSync3(abs, content3, "utf8");
       written.push(relPath2);
@@ -31231,7 +30851,7 @@ function attestDocuments(options) {
     const abs = resolveWritePath(ctx.root, relPath2);
     if (!existsSync13(abs))
       throw new Error(`Cannot attest missing document: ${relPath2}`);
-    const original = readFileSync12(abs, "utf8");
+    const original = readFileSync11(abs, "utf8");
     if (!DOC_META_RE.test(original)) {
       throw new Error(`Cannot attest ${relPath2}: missing doc-meta comment`);
     }
@@ -31241,7 +30861,7 @@ function attestDocuments(options) {
       lock.documents[relPath2] = {
         reviewedAt,
         documentHash: hash(updated),
-        codeTargets: hashTargets(ctx.root, codeTargets(updated))
+        reviewDependencies: hashDependencies(ctx.root, resolveReviewDependencies(ctx.root, reviewDependencyPatterns(updated)).targets)
       };
     }
   }
@@ -31259,16 +30879,32 @@ function attestDocuments(options) {
     modifiedFiles: options.dryRun ? [] : [...writes.keys()]
   };
 }
-function changedTargetIssue(relPath2, target) {
+function changedDependencyIssue(relPath2, target) {
   return issue("review-proof", relPath2, {
-    code: "review-code-target-changed",
-    message: `code-fit target changed after the recorded review: ${target}`,
+    code: "review-dependency-changed",
+    message: `review dependency changed after the recorded review: ${target}`,
     link: target,
-    remediation: "Re-read the entire document against the current target, then attest it again."
+    remediation: "Re-read the entire document against the current dependencies, then attest it again."
   });
 }
-function validateEntry(input) {
-  const { ctx, relPath: relPath2, content: content3, entry } = input;
+function validateEntry(input) {
+  const { ctx, relPath: relPath2, content: content3, entry } = input;
+  const issues = documentProofIssues(relPath2, content3, entry);
+  const currentTargets = currentDependencies({ root: ctx.root, relPath: relPath2, content: content3, issues });
+  if (!currentTargets)
+    return issues;
+  const recordedTargets = Object.keys(entry.reviewDependencies).sort();
+  if (JSON.stringify(currentTargets) !== JSON.stringify(recordedTargets)) {
+    issues.push(issue("review-proof", relPath2, {
+      code: "review-dependency-set-changed",
+      message: "review dependency set changed after the recorded review"
+    }));
+    return issues;
+  }
+  issues.push(...dependencyHashIssues({ root: ctx.root, relPath: relPath2, targets: currentTargets, entry }));
+  return issues;
+}
+function documentProofIssues(relPath2, content3, entry) {
   const issues = [];
   if (entry.reviewedAt !== docMetaLastReviewed(content3)) {
     issues.push(issue("review-proof", relPath2, {
@@ -31283,27 +30919,33 @@ function validateEntry(input) {
       remediation: "Re-read the entire document, then attest it again."
     }));
   }
-  const currentTargets = codeTargets(content3);
-  const recordedTargets = Object.keys(entry.codeTargets).sort();
-  if (JSON.stringify(currentTargets) !== JSON.stringify(recordedTargets)) {
+  return issues;
+}
+function currentDependencies(input) {
+  const { root: root2, relPath: relPath2, content: content3, issues } = input;
+  try {
+    return resolveReviewDependencies(root2, reviewDependencyPatterns(content3)).targets;
+  } catch (error) {
     issues.push(issue("review-proof", relPath2, {
-      code: "review-code-target-set-changed",
-      message: "code-fit target set changed after the recorded review"
+      code: "review-dependency-invalid",
+      message: error instanceof Error ? error.message : String(error)
     }));
-    return issues;
+    return null;
   }
-  for (const target of currentTargets) {
-    const abs = resolveWritePath(ctx.root, target);
+}
+function dependencyHashIssues(input) {
+  const { root: root2, relPath: relPath2, targets, entry } = input;
+  const issues = [];
+  for (const target of targets) {
+    const abs = resolveWritePath(root2, target);
     if (!existsSync13(abs)) {
       issues.push(issue("review-proof", relPath2, {
-        code: "review-code-target-missing",
-        message: `recorded code-fit target is missing: ${target}`,
+        code: "review-dependency-missing",
+        message: `recorded review dependency is missing: ${target}`,
         link: target
       }));
-      continue;
-    }
-    if (entry.codeTargets[target] !== hash(readFileSync12(abs, "utf8"))) {
-      issues.push(changedTargetIssue(relPath2, target));
+    } else if (entry.reviewDependencies[target] !== hash(readFileSync11(abs, "utf8"))) {
+      issues.push(changedDependencyIssue(relPath2, target));
     }
   }
   return issues;
@@ -31321,7 +30963,7 @@ function runReviewProofRule(ctx) {
       })
     ];
   }
-  const lock = parseLock(readFileSync12(absLock, "utf8"));
+  const lock = parseLock(readFileSync11(absLock, "utf8"));
   if (!lock) {
     return [
       issue("review-proof", relLock, {
@@ -31335,7 +30977,7 @@ function runReviewProofRule(ctx) {
     const abs = resolveWritePath(ctx.root, relPath2);
     if (!existsSync13(abs))
       continue;
-    const content3 = readFileSync12(abs, "utf8");
+    const content3 = readFileSync11(abs, "utf8");
     const entry = lock.documents[normalizeRelPath(relative6(ctx.root, abs))];
     if (!entry) {
       issues.push(issue("review-proof", relPath2, {
@@ -31352,8 +30994,8 @@ function runReviewProofRule(ctx) {
 var reviewProofRule = { id: "review-proof", run: runReviewProofRule };
 
 // src/references/check.ts
-import { existsSync as existsSync15, readdirSync as readdirSync3, readFileSync as readFileSync14 } from "node:fs";
-import { join as join13, relative as relative8 } from "node:path";
+import { existsSync as existsSync15, readdirSync as readdirSync3, readFileSync as readFileSync13 } from "node:fs";
+import { join as join12, relative as relative8 } from "node:path";
 
 // src/references/constants.ts
 var CANONICAL_REFS_DIR = ".skeleton/references";
@@ -31376,8 +31018,8 @@ function isGeneratedReference(content3) {
 }
 
 // src/references/discover.ts
-import { existsSync as existsSync14, readdirSync as readdirSync2, readFileSync as readFileSync13 } from "node:fs";
-import { join as join12, relative as relative7 } from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync2, readFileSync as readFileSync12 } from "node:fs";
+import { join as join11, relative as relative7 } from "node:path";
 function walkMarkdownFiles(dir, root2) {
   const files = [];
   if (!existsSync14(dir))
@@ -31385,7 +31027,7 @@ function walkMarkdownFiles(dir, root2) {
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     if (entry.name.startsWith("."))
       continue;
-    const fullPath = join12(dir, entry.name);
+    const fullPath = join11(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...walkMarkdownFiles(fullPath, root2));
       continue;
@@ -31397,7 +31039,7 @@ function walkMarkdownFiles(dir, root2) {
   return files;
 }
 function canonicalExists(root2, refPath) {
-  return existsSync14(join12(root2, CANONICAL_REFS_DIR, refPath));
+  return existsSync14(join11(root2, CANONICAL_REFS_DIR, refPath));
 }
 function findSharedRefLinks(content3, sourceFile) {
   const links = [];
@@ -31421,7 +31063,7 @@ function findSiblingRefLinks(root2, content3, sourceFile) {
     const raw = normalizeRelPath(match[1] ?? "");
     if (!raw)
       continue;
-    const refPath = withinDir ? normalizeRelPath(join12(withinDir, raw)) : raw;
+    const refPath = withinDir ? normalizeRelPath(join11(withinDir, raw)) : raw;
     if (!canonicalExists(root2, refPath))
       continue;
     links.push({ refPath, sourceFile });
@@ -31441,7 +31083,7 @@ function findLocalCanonicalLinks(root2, content3, sourceFile) {
   return links;
 }
 function collectLinksForFile(root2, relFile) {
-  const content3 = readFileSync13(join12(root2, relFile), "utf8");
+  const content3 = readFileSync12(join11(root2, relFile), "utf8");
   if (isGeneratedReference(content3))
     return [];
   return [
@@ -31456,7 +31098,7 @@ function expandTransitiveRefs(input) {
     const refPath = queue.pop();
     if (!(refPath && canonicalExists(root2, refPath)))
       continue;
-    const canonicalContent = readFileSync13(join12(root2, CANONICAL_REFS_DIR, refPath), "utf8");
+    const canonicalContent = readFileSync12(join11(root2, CANONICAL_REFS_DIR, refPath), "utf8");
     const syntheticSource = generatedRefPath(skillDir, refPath);
     for (const link2 of findLocalCanonicalLinks(root2, canonicalContent, syntheticSource)) {
       if (refPaths.has(link2.refPath))
@@ -31468,8 +31110,8 @@ function expandTransitiveRefs(input) {
   }
 }
 function planForSkill(root2, slug2, skillDir) {
-  const absSkillDir = join12(root2, skillDir);
-  if (!existsSync14(join12(absSkillDir, "SKILL.md")))
+  const absSkillDir = join11(root2, skillDir);
+  if (!existsSync14(join11(absSkillDir, "SKILL.md")))
     return null;
   const refPaths = new Set;
   const links = [];
@@ -31485,8 +31127,8 @@ function planForSkill(root2, slug2, skillDir) {
 function concreteSkillDirs(root2, index2, slug2) {
   const dirs = [];
   for (const skillRoot of index2.roots) {
-    const rel = normalizeRelPath(skillRoot.kind === "nested" ? join12(skillRoot.relPath, slug2) : slug2);
-    if (existsSync14(join12(root2, rel, "SKILL.md")))
+    const rel = normalizeRelPath(skillRoot.kind === "nested" ? join11(skillRoot.relPath, slug2) : slug2);
+    if (existsSync14(join11(root2, rel, "SKILL.md")))
       dirs.push(rel);
   }
   return [...new Set(dirs)];
@@ -31504,7 +31146,7 @@ function discoverSkillReferencePlans(root2, ownership) {
   return plans.sort((a, b) => a.skillDir.localeCompare(b.skillDir));
 }
 function generatedRefPath(skillDir, refPath) {
-  return normalizeRelPath(join12(skillDir, "references", refPath));
+  return normalizeRelPath(join11(skillDir, "references", refPath));
 }
 function rewriteSharedRefTarget(sourceFile, skillDir, refPath) {
   const sourceDir = sourceFile.slice(0, sourceFile.lastIndexOf("/"));
@@ -31536,7 +31178,7 @@ function walkMarkdown(dir, onFile) {
   for (const entry of readdirSync3(dir, { withFileTypes: true })) {
     if (entry.name.startsWith("."))
       continue;
-    const fullPath = join13(dir, entry.name);
+    const fullPath = join12(dir, entry.name);
     if (entry.isDirectory()) {
       walkMarkdown(fullPath, onFile);
       continue;
@@ -31549,7 +31191,7 @@ function walkMarkdown(dir, onFile) {
 function listAllGeneratedFiles(root2) {
   const files = [];
   walkMarkdown(root2, (fullPath) => {
-    const content3 = readFileSync14(fullPath, "utf8");
+    const content3 = readFileSync13(fullPath, "utf8");
     if (isGeneratedReference(content3)) {
       files.push(normalizeRelPath(relative8(root2, fullPath)));
     }
@@ -31557,21 +31199,21 @@ function listAllGeneratedFiles(root2) {
   return files;
 }
 function checkNeededCopy(root2, targetRel) {
-  const targetPath = join13(root2, targetRel);
+  const targetPath = join12(root2, targetRel);
   if (!existsSync15(targetPath)) {
     return issue("generated-references", targetRel, "missing generated copy — run skeleton references sync");
   }
-  const generated = readFileSync14(targetPath, "utf8");
+  const generated = readFileSync13(targetPath, "utf8");
   if (!isGeneratedReference(generated)) {
     return issue("generated-references", targetRel, "expected generated-reference provenance header");
   }
   const body = stripGeneratedHeader(generated);
-  const sourceRel = normalizeRelPath(generated.match(/source: ([^\n]+)/)?.[1] ?? join13(CANONICAL_REFS_DIR, targetRel.split("/references/")[1] ?? ""));
-  const canonicalPath = join13(root2, sourceRel);
+  const sourceRel = normalizeRelPath(generated.match(/source: ([^\n]+)/)?.[1] ?? join12(CANONICAL_REFS_DIR, targetRel.split("/references/")[1] ?? ""));
+  const canonicalPath = join12(root2, sourceRel);
   if (!existsSync15(canonicalPath)) {
     return issue("generated-references", targetRel, `canonical source missing: ${sourceRel}`);
   }
-  const canonical = readFileSync14(canonicalPath, "utf8");
+  const canonical = readFileSync13(canonicalPath, "utf8");
   if (body !== canonical) {
     return issue("generated-references", targetRel, "stale generated copy — run skeleton references sync");
   }
@@ -31592,7 +31234,7 @@ function checkStaleSharedLinks(root2, skillDir) {
   const issues = [];
   walkMarkdown(skillDir, (fullPath) => {
     const relFile = normalizeRelPath(relative8(root2, fullPath));
-    const content3 = readFileSync14(fullPath, "utf8");
+    const content3 = readFileSync13(fullPath, "utf8");
     if (!content3.match(SHARED_REF_LINK_RE))
       return;
     issues.push(issue("generated-references", relFile, "still links to shared root references/ — run skeleton references sync"));
@@ -31601,7 +31243,7 @@ function checkStaleSharedLinks(root2, skillDir) {
 }
 function runGeneratedReferencesCheck(root2, ownership) {
   const issues = [];
-  const canonicalDir = join13(root2, CANONICAL_REFS_DIR);
+  const canonicalDir = join12(root2, CANONICAL_REFS_DIR);
   if (!existsSync15(canonicalDir))
     return issues;
   const skillIndex = buildSkillIndex(root2, ownership);
@@ -31619,7 +31261,7 @@ function runGeneratedReferencesCheck(root2, ownership) {
   }
   issues.push(...checkOrphanedCopies(root2, needed, skillIndex));
   for (const plan of plans) {
-    issues.push(...checkStaleSharedLinks(root2, join13(root2, plan.skillDir)));
+    issues.push(...checkStaleSharedLinks(root2, join12(root2, plan.skillDir)));
   }
   return issues;
 }
@@ -31643,38 +31285,9 @@ function runBannedRule(ctx) {
 }
 var bannedRule = { id: "banned", run: runBannedRule };
 
-// src/audit/rules/code-fit.ts
-import { relative as relative9 } from "node:path";
-function runCodeFitRule(ctx) {
-  const overlapMin = ctx.config.docsLint?.codeFitOverlapMin ?? DEFAULT_CODE_FIT_OVERLAP_MIN;
-  const surfaceCap = ctx.config.docsLint?.codeFitSurfaceCap ?? DEFAULT_CODE_FIT_SURFACE_CAP;
-  const options = { root: ctx.root, overlapMin, surfaceCap };
-  const corpus = collectScanFiles(ctx.config, ctx.root, ctx.skillIndex);
-  const issues = [];
-  for (const abs of corpus) {
-    const content3 = readFileContent(abs);
-    if (!parseCodeFitMarkers(content3).length)
-      continue;
-    const rel = normalizeRelPath(relative9(ctx.root, abs));
-    for (const fit of evaluateCodeFitDoc(rel, content3, options)) {
-      issues.push(issue("code-fit", fit.path, {
-        message: fit.message,
-        link: fit.link,
-        severity: "error"
-      }));
-    }
-  }
-  return issues;
-}
-var codeFitRule = {
-  id: "code-fit",
-  alwaysRun: true,
-  run: runCodeFitRule
-};
-
 // src/audit/rules/doc-meta.ts
-import { existsSync as existsSync16, readFileSync as readFileSync15 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync14 } from "node:fs";
+import { join as join13 } from "node:path";
 function checkDocMetaBanner(relPath2, content3) {
   if (DOC_META_RE.test(content3))
     return null;
@@ -31725,136 +31338,359 @@ function checkGitFreshness(input) {
     remediation: "Re-read the entire document, then use explicit review attestation for that path."
   });
 }
-function runDocMetaRule(ctx) {
-  const issues = [];
-  const today = new Date;
-  for (const relPath2 of ctx.docMetaPaths) {
-    const abs = join14(ctx.root, relPath2);
-    if (!existsSync16(abs))
+function runDocMetaRule(ctx) {
+  const issues = [];
+  const today = new Date;
+  for (const relPath2 of ctx.docMetaPaths) {
+    const abs = join13(ctx.root, relPath2);
+    if (!existsSync16(abs))
+      continue;
+    const content3 = readFileSync14(abs, "utf8");
+    const banner = checkDocMetaBanner(relPath2, content3);
+    if (banner) {
+      issues.push(banner);
+      continue;
+    }
+    const stale = checkStaleReview({
+      relPath: relPath2,
+      content: content3,
+      today,
+      staleDays: ctx.config.daysUntilStale
+    });
+    if (stale)
+      issues.push(stale);
+    const git = checkGitFreshness({
+      relPath: relPath2,
+      content: content3,
+      root: ctx.root,
+      lockedSkillSlugs: ctx.lockedSkillSlugs
+    });
+    if (git)
+      issues.push(git);
+  }
+  return issues;
+}
+var docMetaRule = { id: "doc-meta", run: runDocMetaRule };
+
+// src/audit/rules/links.ts
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "node:fs";
+import { dirname as dirname9, resolve as resolve5 } from "node:path";
+function resolveLink2(sourceFile, target) {
+  const withoutAnchor = target.split("#")[0]?.split("?")[0] ?? "";
+  if (!withoutAnchor)
+    return sourceFile;
+  return resolve5(dirname9(sourceFile), withoutAnchor);
+}
+function checkMissingSkill(input, relSource) {
+  if (!input.target.includes("/SKILL.md"))
+    return null;
+  const slug2 = SKILL_LINK_IN_TARGET_RE.exec(input.target)?.[1];
+  if (!(slug2 && !resolveSkillPath(input.ctx.skillIndex, input.ctx.root, slug2)))
+    return null;
+  return issue("links", relSource, {
+    message: `missing skill "${slug2}/SKILL.md"`,
+    link: input.linkLabel
+  });
+}
+function checkAgentFile(input, resolved, relSource) {
+  if (!((input.target.includes(".claude/agents/") || input.target.includes(".cursor/agents/")) && input.target.endsWith(".md"))) {
+    return null;
+  }
+  const agentPath = resolved.endsWith(".md") ? resolved : `${resolved}.md`;
+  if (existsSync17(agentPath))
+    return null;
+  return issue("links", relSource, { message: "missing agent file", link: input.linkLabel });
+}
+function checkBrokenPath(ctx) {
+  const { input, pathPart, resolved, relSource, relTarget } = ctx;
+  if (!(pathPart && !existsSync17(resolved)))
+    return null;
+  return issue("links", relSource, {
+    message: `broken link → ${relTarget}`,
+    link: input.linkLabel
+  });
+}
+function checkBrokenAnchor(ctx) {
+  const { input, anchor, resolved, relSource, relTarget } = ctx;
+  if (!(anchor && existsSync17(resolved)))
+    return null;
+  const targetContent = readFileSync15(resolved, "utf8");
+  const slugs = extractHeadingSlugs(targetContent, resolved);
+  const anchorSlug = slugifyAnchor(anchor);
+  if (slugs.has(anchorSlug))
+    return null;
+  return issue("links", relSource, {
+    message: `broken anchor → #${anchor} in ${relTarget}`,
+    link: input.linkLabel
+  });
+}
+function resolveTargetParts(sourceFile, target, root2) {
+  const relSource = relPath(sourceFile, root2);
+  const anchor = target.includes("#") ? target.split("#")[1]?.split("?")[0] ?? "" : "";
+  const pathPart = target.split("#")[0]?.split("?")[0] ?? "";
+  const resolved = resolveLink2(sourceFile, target);
+  const relTarget = relPath(resolved, root2);
+  return { relSource, anchor, pathPart, resolved, relTarget };
+}
+function validateTarget(input) {
+  const { ctx, sourceFile, target } = input;
+  if (isExternalLink(target) && !target.startsWith("#"))
+    return [];
+  if (isPlaceholderLink(target))
+    return [];
+  const parts = resolveTargetParts(sourceFile, target, ctx.root);
+  const missingSkill = checkMissingSkill(input, parts.relSource);
+  if (missingSkill)
+    return [missingSkill];
+  const agent = checkAgentFile(input, parts.resolved, parts.relSource);
+  if (agent)
+    return [agent];
+  const brokenPath = checkBrokenPath({ input, ...parts });
+  if (brokenPath)
+    return [brokenPath];
+  const brokenAnchor = checkBrokenAnchor({ input, ...parts });
+  return brokenAnchor ? [brokenAnchor] : [];
+}
+function runLinksRule(ctx) {
+  const issues = [];
+  for (const filePath of ctx.files) {
+    const content3 = readFileContent(filePath);
+    const links = extractLinksFromMarkdown(content3, filePath);
+    for (const { target, line } of links) {
+      const linkLabel = line ? `line ${line}` : target;
+      issues.push(...validateTarget({ ctx, sourceFile: filePath, target, linkLabel }));
+    }
+  }
+  return issues;
+}
+var linksRule = { id: "links", run: runLinksRule };
+
+// src/audit/rules/near-duplicate.ts
+import { readFileSync as readFileSync16 } from "node:fs";
+import { join as join14 } from "node:path";
+
+// src/audit/core/ssot-fit.ts
+var DEFAULT_SSOT_OVERLAP_MIN = 0.35;
+var DEFAULT_BETTER_MATCH_MARGIN = 0.15;
+var STOP = new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "of",
+  "for",
+  "to",
+  "in",
+  "on",
+  "with",
+  "this",
+  "that",
+  "is",
+  "are",
+  "be",
+  "as",
+  "by",
+  "from",
+  "at",
+  "it",
+  "its"
+]);
+var STEM_BLOCKLIST = new Set([
+  "business",
+  "analysis",
+  "status",
+  "process",
+  "access",
+  "address",
+  "series",
+  "species",
+  "news",
+  "means",
+  "cross",
+  "class",
+  "glass",
+  "less",
+  "success",
+  "progress",
+  "express",
+  "discuss",
+  "focus",
+  "bonus",
+  "basis",
+  "crisis",
+  "thesis",
+  "atlas",
+  "canvas",
+  "campus",
+  "virus",
+  "bus",
+  "gas",
+  "plus",
+  "alias",
+  "bias",
+  "circus",
+  "consensus",
+  "census"
+]);
+function lightStem(token) {
+  if (token.length < 4)
+    return token;
+  if (STEM_BLOCKLIST.has(token))
+    return token;
+  if (token.endsWith("ies") && token.length > 4) {
+    return `${token.slice(0, -3)}y`;
+  }
+  if (token.endsWith("sses") || token.endsWith("ches") || token.endsWith("shes") || token.endsWith("xes")) {
+    return token.slice(0, -2);
+  }
+  if (token.endsWith("s") && !token.endsWith("ss") && !token.endsWith("us") && !token.endsWith("is")) {
+    return token.slice(0, -1);
+  }
+  return token;
+}
+function contentTokens(text5) {
+  return text5.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 1 && !STOP.has(t)).map(lightStem);
+}
+function uniqueContentTokens(text5) {
+  return [...new Set(contentTokens(text5))];
+}
+function stripCode2(content3) {
+  return content3.replace(/```[\s\S]*?```/g, `
+`).replace(/`[^`\n]+`/g, " ");
+}
+function stripSsotAndMeta(content3) {
+  return content3.replace(/<!--\s*source-of-truth:[\s\S]*?-->/gi, `
+`).replace(/^\s*source-of-truth:\s*.+$/gim, `
+`).replace(/^\s*\*\*Source of truth for\*\*\s*.+$/gim, `
+`).replace(/<!--\s*doc-meta:[\s\S]*?-->/gi, `
+`);
+}
+function extractH1(content3) {
+  const prose = stripCode2(content3);
+  const m = /^#\s+(.+)$/m.exec(prose);
+  return m?.[1]?.trim() ?? "";
+}
+function extractLeadParagraph(content3) {
+  const prose = stripSsotAndMeta(stripCode2(content3));
+  const lines = prose.split(/\n/);
+  const chunks = [];
+  let buf = [];
+  const flush = () => {
+    const t = buf.join(" ").trim();
+    if (t)
+      chunks.push(t);
+    buf = [];
+  };
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      flush();
       continue;
-    const content3 = readFileSync15(abs, "utf8");
-    const banner = checkDocMetaBanner(relPath2, content3);
-    if (banner) {
-      issues.push(banner);
+    }
+    if (/^[-*|]/.test(trimmed) && chunks.length === 0 && buf.length === 0) {
+      buf.push(trimmed.replace(/^[-*|]+\s*/, ""));
       continue;
     }
-    const stale = checkStaleReview({
-      relPath: relPath2,
-      content: content3,
-      today,
-      staleDays: ctx.config.daysUntilStale
-    });
-    if (stale)
-      issues.push(stale);
-    const git = checkGitFreshness({
-      relPath: relPath2,
-      content: content3,
-      root: ctx.root,
-      lockedSkillSlugs: ctx.lockedSkillSlugs
-    });
-    if (git)
-      issues.push(git);
+    buf.push(trimmed);
   }
-  return issues;
+  flush();
+  return chunks[0] ?? "";
 }
-var docMetaRule = { id: "doc-meta", run: runDocMetaRule };
+function buildEvidenceText(content3) {
+  const h1 = extractH1(content3);
+  const lead = extractLeadParagraph(content3);
+  const body = stripSsotAndMeta(stripCode2(content3));
+  return [h1, lead, body].filter(Boolean).join(`
 
-// src/audit/rules/links.ts
-import { existsSync as existsSync17, readFileSync as readFileSync16 } from "node:fs";
-import { dirname as dirname9, resolve as resolve5 } from "node:path";
-function resolveLink2(sourceFile, target) {
-  const withoutAnchor = target.split("#")[0]?.split("?")[0] ?? "";
-  if (!withoutAnchor)
-    return sourceFile;
-  return resolve5(dirname9(sourceFile), withoutAnchor);
-}
-function checkMissingSkill(input, relSource) {
-  if (!input.target.includes("/SKILL.md"))
-    return null;
-  const slug2 = SKILL_LINK_IN_TARGET_RE.exec(input.target)?.[1];
-  if (!(slug2 && !resolveSkillPath(input.ctx.skillIndex, input.ctx.root, slug2)))
-    return null;
-  return issue("links", relSource, {
-    message: `missing skill "${slug2}/SKILL.md"`,
-    link: input.linkLabel
-  });
+`);
 }
-function checkAgentFile(input, resolved, relSource) {
-  if (!((input.target.includes(".claude/agents/") || input.target.includes(".cursor/agents/")) && input.target.endsWith(".md"))) {
-    return null;
+function ssotEvidenceOverlap(summary, evidence) {
+  const st = uniqueContentTokens(summary);
+  if (st.length === 0)
+    return 0;
+  const ev = new Set(contentTokens(evidence));
+  let hit = 0;
+  for (const t of st) {
+    if (ev.has(t))
+      hit++;
   }
-  const agentPath = resolved.endsWith(".md") ? resolved : `${resolved}.md`;
-  if (existsSync17(agentPath))
-    return null;
-  return issue("links", relSource, { message: "missing agent file", link: input.linkLabel });
-}
-function checkBrokenPath(ctx) {
-  const { input, pathPart, resolved, relSource, relTarget } = ctx;
-  if (!(pathPart && !existsSync17(resolved)))
-    return null;
-  return issue("links", relSource, {
-    message: `broken link → ${relTarget}`,
-    link: input.linkLabel
-  });
-}
-function checkBrokenAnchor(ctx) {
-  const { input, anchor, resolved, relSource, relTarget } = ctx;
-  if (!(anchor && existsSync17(resolved)))
-    return null;
-  const targetContent = readFileSync16(resolved, "utf8");
-  const slugs = extractHeadingSlugs(targetContent, resolved);
-  const anchorSlug = slugifyAnchor(anchor);
-  if (slugs.has(anchorSlug))
-    return null;
-  return issue("links", relSource, {
-    message: `broken anchor → #${anchor} in ${relTarget}`,
-    link: input.linkLabel
-  });
+  return hit / st.length;
 }
-function resolveTargetParts(sourceFile, target, root2) {
-  const relSource = relPath(sourceFile, root2);
-  const anchor = target.includes("#") ? target.split("#")[1]?.split("?")[0] ?? "" : "";
-  const pathPart = target.split("#")[0]?.split("?")[0] ?? "";
-  const resolved = resolveLink2(sourceFile, target);
-  const relTarget = relPath(resolved, root2);
-  return { relSource, anchor, pathPart, resolved, relTarget };
+function longestSummaryPhrase(summary) {
+  const toks = contentTokens(summary);
+  if (toks.length >= 3)
+    return toks.slice(0, 3);
+  if (toks.length >= 2)
+    return toks.slice(0, 2);
+  return null;
 }
-function validateTarget(input) {
-  const { ctx, sourceFile, target } = input;
-  if (isExternalLink(target) && !target.startsWith("#"))
-    return [];
-  if (isPlaceholderLink(target))
-    return [];
-  const parts = resolveTargetParts(sourceFile, target, ctx.root);
-  const missingSkill = checkMissingSkill(input, parts.relSource);
-  if (missingSkill)
-    return [missingSkill];
-  const agent = checkAgentFile(input, parts.resolved, parts.relSource);
-  if (agent)
-    return [agent];
-  const brokenPath = checkBrokenPath({ input, ...parts });
-  if (brokenPath)
-    return [brokenPath];
-  const brokenAnchor = checkBrokenAnchor({ input, ...parts });
-  return brokenAnchor ? [brokenAnchor] : [];
+function evidenceHasPhrase(evidence, phrase) {
+  if (phrase.length === 0)
+    return true;
+  const ev = contentTokens(evidence);
+  const needle = phrase.join(" ");
+  for (let i = 0;i <= ev.length - phrase.length; i++) {
+    if (ev.slice(i, i + phrase.length).join(" ") === needle)
+      return true;
+  }
+  return false;
 }
-function runLinksRule(ctx) {
+function evaluateSsotFit(files, options = {}) {
+  const overlapMin = options.overlapMin ?? DEFAULT_SSOT_OVERLAP_MIN;
+  const margin = options.betterMatchMargin ?? DEFAULT_BETTER_MATCH_MARGIN;
+  const phraseCheck = options.phraseCheck !== false;
+  const prepared = files.map((f) => {
+    const evidence = buildEvidenceText(f.content);
+    const overlap = ssotEvidenceOverlap(f.summary, evidence);
+    const summaryToks = uniqueContentTokens(f.summary);
+    return { ...f, evidence, overlap, summaryToks };
+  });
   const issues = [];
-  for (const filePath of ctx.files) {
-    const content3 = readFileContent(filePath);
-    const links = extractLinksFromMarkdown(content3, filePath);
-    for (const { target, line } of links) {
-      const linkLabel = line ? `line ${line}` : target;
-      issues.push(...validateTarget({ ctx, sourceFile: filePath, target, linkLabel }));
+  for (const row of prepared) {
+    if (row.summaryToks.length < 2) {
+      issues.push({
+        kind: "short",
+        path: row.path,
+        message: `source-of-truth summary too short to verify against body ("${row.summary}")`
+      });
+      continue;
+    }
+    if (row.overlap < overlapMin) {
+      let message = `source-of-truth summary weakly matches this paper (token overlap ${row.overlap.toFixed(2)} < ${overlapMin})`;
+      if (phraseCheck) {
+        const phrase = longestSummaryPhrase(row.summary);
+        if (phrase && !evidenceHasPhrase(row.evidence, phrase)) {
+          message += ` — key phrase "${phrase.join(" ")}" not found in H1/lead/body`;
+        }
+      }
+      issues.push({ kind: "weak", path: row.path, message });
+      let best = null;
+      for (const other of prepared) {
+        if (other.path === row.path)
+          continue;
+        const cross = ssotEvidenceOverlap(row.summary, other.evidence);
+        if (cross < overlapMin)
+          continue;
+        if (cross < row.overlap + margin)
+          continue;
+        if (!best || cross > best.overlap)
+          best = { path: other.path, overlap: cross };
+      }
+      if (best) {
+        issues.push({
+          kind: "better-match",
+          path: row.path,
+          otherPath: best.path,
+          message: `source-of-truth fits ${best.path} better (overlap ${best.overlap.toFixed(2)} vs own ${row.overlap.toFixed(2)}). ` + `Try: (1) rewrite this SSOT to match this paper, (2) move/fix the marker onto ${best.path}, ` + `or (3) if these pages are really one topic, consider combining them`
+        });
+      }
     }
   }
   return issues;
 }
-var linksRule = { id: "links", run: runLinksRule };
 
 // src/audit/rules/near-duplicate.ts
-import { readFileSync as readFileSync17 } from "node:fs";
-import { join as join15 } from "node:path";
 var DEFAULT_THRESHOLD = 0.72;
 var SHINGLE_N = 3;
 function tokenize2(text5) {
@@ -31919,7 +31755,7 @@ function runNearDuplicateRule(ctx) {
   const ignored = ignoredPairSet(ctx);
   const entries = eligibleEntries(ctx);
   const fingerprints = entries.map((e) => {
-    const content3 = readFileSync17(join15(ctx.root, e.path), "utf8");
+    const content3 = readFileSync16(join14(ctx.root, e.path), "utf8");
     const tokens = tokenize2(bodyWithoutSsotNoise(content3));
     return {
       path: e.path,
@@ -32013,6 +31849,44 @@ function runProsePolicyRule(ctx) {
   return issues;
 }
 var prosePolicyRule = { id: "prose-policy", run: runProsePolicyRule };
+
+// src/audit/rules/review-deps.ts
+import { relative as relative9 } from "node:path";
+function runReviewDepsRule(ctx) {
+  const issues = [];
+  for (const abs of collectScanFiles(ctx.config, ctx.root, ctx.skillIndex)) {
+    const path3 = normalizeRelPath(relative9(ctx.root, abs));
+    for (const marker of parseReviewDepsMarkers(readFileContent(abs))) {
+      issues.push(...validateMarker(ctx.root, path3, marker.paths));
+    }
+  }
+  return issues;
+}
+function validateMarker(root2, path3, dependencies) {
+  if (dependencies.length === 0)
+    return [issue("review-deps", path3, "review-deps marker missing paths=")];
+  return dependencies.flatMap((dependency) => validateDependency(root2, path3, dependency));
+}
+function validateDependency(root2, path3, dependency) {
+  if (!isSafeReviewDependencyPath(dependency)) {
+    return [issue("review-deps", path3, `invalid review dependency path: ${dependency}`)];
+  }
+  try {
+    const resolved = resolveReviewDependencies(root2, [dependency]);
+    if (!isReviewDependencyGlob(dependency) || resolved.targets.length > 0)
+      return [];
+    return [
+      issue("review-deps", path3, {
+        code: "review-dependency-glob-empty",
+        message: `review dependency glob matches no files: ${dependency}`,
+        severity: "warning"
+      })
+    ];
+  } catch (error) {
+    return [issue("review-deps", path3, error instanceof Error ? error.message : String(error))];
+  }
+}
+var reviewDepsRule = { id: "review-deps", alwaysRun: true, run: runReviewDepsRule };
 // src/audit/rules/scan-gaps.ts
 function runCoverageGapsRule(ctx) {
   const exclude = [...COVERAGE_BUILTIN_EXCLUDES, ...ctx.config.scan.exclude];
@@ -32042,8 +31916,8 @@ function runScanRootsRule(ctx) {
 var scanRootsRule = { id: "scan-roots", run: runScanRootsRule };
 
 // src/audit/rules/skill-index.ts
-import { existsSync as existsSync18, readdirSync as readdirSync4, readFileSync as readFileSync18 } from "node:fs";
-import { join as join16, relative as relative10 } from "node:path";
+import { existsSync as existsSync18, readdirSync as readdirSync4, readFileSync as readFileSync17 } from "node:fs";
+import { join as join15, relative as relative10 } from "node:path";
 function walkSkillMarkdown(dir) {
   const files = [];
   if (!existsSync18(dir))
@@ -32051,7 +31925,7 @@ function walkSkillMarkdown(dir) {
   for (const entry of readdirSync4(dir, { withFileTypes: true })) {
     if (entry.name.startsWith("."))
       continue;
-    const fullPath = join16(dir, entry.name);
+    const fullPath = join15(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...walkSkillMarkdown(fullPath));
       continue;
@@ -32078,7 +31952,7 @@ function parseReadmeTaxonomySlugs(content3) {
 function scanFileForSkillLinks(ctx, filePath, index2) {
   const issues = [];
   const rel = relative10(ctx.root, filePath).replace(/\\/g, "/");
-  const content3 = readFileSync18(filePath, "utf8");
+  const content3 = readFileSync17(filePath, "utf8");
   if (isGeneratedReference(content3))
     return issues;
   for (const match of content3.matchAll(SKILL_LINK_RE)) {
@@ -32093,14 +31967,14 @@ function scanFileForSkillLinks(ctx, filePath, index2) {
 }
 function taxonomyIssuesForReadme(input) {
   const { ctx, index: index2, skillRoot, diskSlugs, nonPublic } = input;
-  const readmePath = join16(ctx.root, skillRoot.relPath, "README.md");
+  const readmePath = join15(ctx.root, skillRoot.relPath, "README.md");
   if (!existsSync18(readmePath))
     return [];
-  const readme = readFileSync18(readmePath, "utf8");
+  const readme = readFileSync17(readmePath, "utf8");
   if (!readme.includes("## Taxonomy"))
     return [];
   const taxonomySlugs = parseReadmeTaxonomySlugs(readme);
-  const nestedSlugs = diskSlugs.filter((slug2) => existsSync18(join16(ctx.root, skillRoot.relPath, slug2, "SKILL.md")));
+  const nestedSlugs = diskSlugs.filter((slug2) => existsSync18(join15(ctx.root, skillRoot.relPath, slug2, "SKILL.md")));
   const foreign = new Set(index2.foreignSlugs);
   const publicSlugs = nestedSlugs.filter((slug2) => !(nonPublic.has(slug2) || foreign.has(slug2)));
   const relReadme = `${skillRoot.relPath}/README.md`;
@@ -32133,9 +32007,9 @@ function slugsForRoot(skillRoot, index2, owned) {
 function auditSkillRoot(input) {
   const { ctx, index: index2, skillRoot, owned } = input;
   const issues = [];
-  const base = skillRoot.kind === "nested" ? join16(ctx.root, skillRoot.relPath) : ctx.root;
+  const base = skillRoot.kind === "nested" ? join15(ctx.root, skillRoot.relPath) : ctx.root;
   for (const slug2 of slugsForRoot(skillRoot, index2, owned)) {
-    const skillDir = join16(base, slug2);
+    const skillDir = join15(base, slug2);
     if (!existsSync18(skillDir))
       continue;
     for (const skillMd of walkSkillMarkdown(skillDir)) {
@@ -32186,8 +32060,8 @@ function runSsotRule(ctx) {
 var ssotRule = { id: "ssot", run: runSsotRule };
 
 // src/audit/rules/ssot-summary.ts
-import { readFileSync as readFileSync19 } from "node:fs";
-import { join as join17 } from "node:path";
+import { readFileSync as readFileSync18 } from "node:fs";
+import { join as join16 } from "node:path";
 function runSsotSummaryRule(ctx) {
   const overlapMin = ctx.config.docsLint?.ssotOverlapMin ?? DEFAULT_SSOT_OVERLAP_MIN;
   const margin = ctx.config.docsLint?.ssotBetterMatchMargin ?? DEFAULT_BETTER_MATCH_MARGIN;
@@ -32195,7 +32069,7 @@ function runSsotSummaryRule(ctx) {
   const files = ctx.ssotEntries.map((entry) => ({
     path: entry.path,
     summary: entry.summary,
-    content: readFileSync19(join17(ctx.root, entry.path), "utf8")
+    content: readFileSync18(join16(ctx.root, entry.path), "utf8")
   }));
   return evaluateSsotFit(files, {
     overlapMin,
@@ -32219,7 +32093,7 @@ var docsRules = [
   linksRule,
   docMetaRule,
   reviewProofRule,
-  codeFitRule,
+  reviewDepsRule,
   { ...bannedRule, global: true },
   prosePolicyRule
 ];
@@ -32562,19 +32436,19 @@ async function runAudit(options) {
 }
 
 // src/customize/resolve.ts
-import { existsSync as existsSync19, readFileSync as readFileSync20 } from "node:fs";
-import { basename as basename3, join as join18, relative as relative11 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync19 } from "node:fs";
+import { basename as basename3, join as join17, relative as relative11 } from "node:path";
 function customizeDir(root2) {
-  return join18(root2, REGISTRY_DIR_REL, "customize");
+  return join17(root2, REGISTRY_DIR_REL, "customize");
 }
 function customizePathForSlug(root2, slug2) {
-  return join18(customizeDir(root2), `${slug2}.md`);
+  return join17(customizeDir(root2), `${slug2}.md`);
 }
 function resolveSlugFile(root2, slug2) {
   const direct = customizePathForSlug(root2, slug2);
   if (existsSync19(direct)) {
     return {
-      content: readFileSync20(direct, "utf8"),
+      content: readFileSync19(direct, "utf8"),
       path: normalizeRelPath(relative11(root2, direct))
     };
   }
@@ -32596,10 +32470,10 @@ function readAlwaysInclude(root2, basenames, skipBasename) {
     const file = basename3(name);
     if (skipBasename && file === skipBasename)
       continue;
-    const abs = join18(dir, file);
+    const abs = join17(dir, file);
     if (!existsSync19(abs))
       continue;
-    parts.push(readFileSync20(abs, "utf8").trimEnd());
+    parts.push(readFileSync19(abs, "utf8").trimEnd());
     paths.push(normalizeRelPath(relative11(root2, abs)));
   }
   return { parts, paths };
@@ -32723,29 +32597,29 @@ Customize override for /${slug2} (from ${from}):
 
 // src/init/init.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { copyFileSync, existsSync as existsSync23, mkdirSync as mkdirSync4, readFileSync as readFileSync22 } from "node:fs";
-import { join as join22 } from "node:path";
+import { copyFileSync, existsSync as existsSync23, mkdirSync as mkdirSync4, readFileSync as readFileSync21 } from "node:fs";
+import { join as join21 } from "node:path";
 import process6 from "node:process";
 
 // src/init/merge-hooks.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync3, readFileSync as readFileSync21, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname12, join as join21 } from "node:path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync3, readFileSync as readFileSync20, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname12, join as join20 } from "node:path";
 
 // src/init/package-paths.ts
 import { existsSync as existsSync20 } from "node:fs";
-import { dirname as dirname10, join as join19 } from "node:path";
+import { dirname as dirname10, join as join18 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var MODULE_DIR = dirname10(fileURLToPath4(import.meta.url));
-var PACKAGE_ROOT_CANDIDATES = [join19(MODULE_DIR, "../.."), join19(MODULE_DIR, "..")];
+var PACKAGE_ROOT_CANDIDATES = [join18(MODULE_DIR, "../.."), join18(MODULE_DIR, "..")];
 function resolvePackageRoot() {
   for (const candidate of PACKAGE_ROOT_CANDIDATES) {
-    if (existsSync20(join19(candidate, "package.json")))
+    if (existsSync20(join18(candidate, "package.json")))
       return candidate;
   }
   throw new Error("Could not resolve @csark0812/skeleton package root");
 }
 function resolveTemplatesDir() {
-  const dir = join19(resolvePackageRoot(), "templates/skeleton-init");
+  const dir = join18(resolvePackageRoot(), "templates/skeleton-init");
   if (!existsSync20(dir)) {
     throw new Error("Missing templates/skeleton-init in package");
   }
@@ -32755,7 +32629,7 @@ function resolveTemplatesDir() {
 // src/init/resolve-hook-command.ts
 import { existsSync as existsSync21, realpathSync as realpathSync5 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname11, join as join20, relative as relative12, resolve as resolve6 } from "node:path";
+import { dirname as dirname11, join as join19, relative as relative12, resolve as resolve6 } from "node:path";
 var PACKAGE_NAME = "@csark0812/skeleton";
 var CLI_DIST = "dist/cli.js";
 var PACKAGE_ROOT = resolvePackageRoot();
@@ -32774,7 +32648,7 @@ function toRepoRelative(cwd, absPath) {
 }
 function tryResolvePublishedCli(cwd) {
   try {
-    const req = createRequire3(join20(cwd, "package.json"));
+    const req = createRequire3(join19(cwd, "package.json"));
     return req.resolve(`${PACKAGE_NAME}/${CLI_DIST}`);
   } catch {
     return null;
@@ -32783,7 +32657,7 @@ function tryResolvePublishedCli(cwd) {
 function walkNodeModulesCli(cwd) {
   let dir = cwd;
   while (true) {
-    const candidate = join20(dir, "node_modules", PACKAGE_NAME, CLI_DIST);
+    const candidate = join19(dir, "node_modules", PACKAGE_NAME, CLI_DIST);
     if (existsSync21(candidate))
       return candidate;
     const parent = dirname11(dir);
@@ -32825,14 +32699,14 @@ function identityKey(platform, event, matcher) {
   return `skeleton:customize:${platform}:${event}:${matcher}`;
 }
 function loadFragment(name, hookCommand) {
-  const raw = readFileSync21(join21(TEMPLATES_DIR, name), "utf8");
+  const raw = readFileSync20(join20(TEMPLATES_DIR, name), "utf8");
   return JSON.parse(raw.replaceAll("{{HOOK_COMMAND}}", hookCommand));
 }
 function readJson(path3) {
   if (!existsSync22(path3))
     return null;
   try {
-    return JSON.parse(readFileSync21(path3, "utf8"));
+    return JSON.parse(readFileSync20(path3, "utf8"));
   } catch (error) {
     throw new Error(`Invalid JSON in ${path3}: ${error}`);
   }
@@ -32992,10 +32866,10 @@ function mergeNestedHooks(args) {
 }
 function mergeHookConfigs(opts) {
   const results = [];
-  const cursorPath = join21(opts.cwd, ".cursor/hooks.json");
+  const cursorPath = join20(opts.cwd, ".cursor/hooks.json");
   const cursorFragment = loadFragment("cursor-hooks.fragment.json", opts.hookCommand);
   results.push(mergeCursorHooks(cursorPath, cursorFragment, opts));
-  const claudePath = join21(opts.cwd, ".claude/settings.json");
+  const claudePath = join20(opts.cwd, ".claude/settings.json");
   const claudeFragment = loadFragment("claude-settings.fragment.json", opts.hookCommand);
   results.push(mergeNestedHooks({
     platform: "claude",
@@ -33004,8 +32878,8 @@ function mergeHookConfigs(opts) {
     eventName: "PostToolUse",
     opts
   }));
-  const codexPath = join21(opts.cwd, ".codex/hooks.json");
-  if (existsSync22(join21(opts.cwd, ".codex"))) {
+  const codexPath = join20(opts.cwd, ".codex/hooks.json");
+  if (existsSync22(join20(opts.cwd, ".codex"))) {
     const codexFragment = loadFragment("codex-hooks.fragment.json", opts.hookCommand);
     results.push(mergeNestedHooks({
       platform: "codex",
@@ -33020,11 +32894,11 @@ function mergeHookConfigs(opts) {
   return results;
 }
 function mergePackageJsonScripts(cwd) {
-  const pkgPath = join21(cwd, "package.json");
+  const pkgPath = join20(cwd, "package.json");
   if (!existsSync22(pkgPath))
     return "skipped";
-  const fragment = JSON.parse(readFileSync21(join21(TEMPLATES_DIR, "package.json.scripts.fragment.json"), "utf8"));
-  const pkg = JSON.parse(readFileSync21(pkgPath, "utf8"));
+  const fragment = JSON.parse(readFileSync20(join20(TEMPLATES_DIR, "package.json.scripts.fragment.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync20(pkgPath, "utf8"));
   pkg.scripts ??= {};
   let changed = false;
   for (const [key, value] of Object.entries(fragment)) {
@@ -33080,23 +32954,23 @@ function skillsAddArgs(options = {}) {
 // src/init/init.ts
 var TEMPLATES_DIR2 = resolveTemplatesDir();
 function writeScaffold(cwd) {
-  const skeletonDir2 = join22(cwd, ".skeleton");
+  const skeletonDir2 = join21(cwd, ".skeleton");
   mkdirSync4(skeletonDir2, { recursive: true });
   let created = false;
-  const tomlPath = join22(cwd, "skeleton.toml");
-  const legacyYaml = join22(skeletonDir2, "config.yaml");
+  const tomlPath = join21(cwd, "skeleton.toml");
+  const legacyYaml = join21(skeletonDir2, "config.yaml");
   if (!(existsSync23(tomlPath) || existsSync23(legacyYaml))) {
-    copyFileSync(join22(TEMPLATES_DIR2, "skeleton.toml"), tomlPath);
+    copyFileSync(join21(TEMPLATES_DIR2, "skeleton.toml"), tomlPath);
     created = true;
   }
-  mkdirSync4(join22(skeletonDir2, "customize"), { recursive: true });
+  mkdirSync4(join21(skeletonDir2, "customize"), { recursive: true });
   return created ? "created" : "skipped";
 }
 function assertPackageResolvable(cwd) {
-  const pkgPath = join22(cwd, "package.json");
+  const pkgPath = join21(cwd, "package.json");
   if (!existsSync23(pkgPath))
     return;
-  const pkg = JSON.parse(readFileSync22(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync21(pkgPath, "utf8"));
   const hasDep = pkg.devDependencies?.["@csark0812/skeleton"] || pkg.dependencies?.["@csark0812/skeleton"];
   if (!hasDep) {
     try {
@@ -33180,7 +33054,7 @@ function parseInitArgs(argv) {
 // src/plugins/build.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync24, readFileSync as readFileSync23, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync5 } from "node:fs";
 import { basename as basename4, dirname as dirname13, resolve as resolve7 } from "node:path";
 function parseBuildPluginArgs(argv) {
   let check = false;
@@ -33238,7 +33112,7 @@ function sourceFingerprint(tsAbs, seen = new Set) {
     if (seen.has(abs))
       return;
     seen.add(abs);
-    const content3 = readFileSync23(abs, "utf8");
+    const content3 = readFileSync22(abs, "utf8");
     hash2.update(basename4(abs));
     hash2.update("\x00");
     hash2.update(content3);
@@ -33286,7 +33160,7 @@ function checkOne(tsAbs) {
   if (!existsSync24(stampAbs)) {
     throw new Error(`Plugin stale: ${mjsAbs} has no fingerprint stamp. Run: skeleton build-plugin`);
   }
-  const expected = readFileSync23(stampAbs, "utf8").trim();
+  const expected = readFileSync22(stampAbs, "utf8").trim();
   const actual = sourceFingerprint(tsAbs);
   if (expected !== actual) {
     throw new Error(`Plugin stale: ${mjsAbs} does not match ${tsAbs} (or local imports). Run: skeleton build-plugin`);
@@ -33322,11 +33196,11 @@ import {
   existsSync as existsSync25,
   mkdirSync as mkdirSync5,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync24,
+  readFileSync as readFileSync23,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname14, join as join23, relative as relative13 } from "node:path";
+import { dirname as dirname14, join as join22, relative as relative13 } from "node:path";
 import process7 from "node:process";
 function resolveOwnership(root2, override) {
   if (override !== undefined)
@@ -33342,7 +33216,7 @@ function walkMarkdownFiles2(dir, root2) {
   for (const entry of readdirSync5(dir, { withFileTypes: true })) {
     if (entry.name.startsWith("."))
       continue;
-    const fullPath = join23(dir, entry.name);
+    const fullPath = join22(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...walkMarkdownFiles2(fullPath, root2));
       continue;
@@ -33356,14 +33230,14 @@ function walkMarkdownFiles2(dir, root2) {
 function collectGeneratedInDir(input) {
   const { dir, refsDir, skillDir, files } = input;
   for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    const fullPath = join23(dir, entry.name);
+    const fullPath = join22(dir, entry.name);
     if (entry.isDirectory()) {
       collectGeneratedInDir({ dir: fullPath, refsDir, skillDir, files });
       continue;
     }
     if (!entry.name.endsWith(".md"))
       continue;
-    const content3 = readFileSync24(fullPath, "utf8");
+    const content3 = readFileSync23(fullPath, "utf8");
     if (!isGeneratedReference(content3))
       continue;
     const refPath = normalizeRelPath(relative13(refsDir, fullPath));
@@ -33371,7 +33245,7 @@ function collectGeneratedInDir(input) {
   }
 }
 function listGeneratedReferenceFiles(root2, skillDir) {
-  const refsDir = join23(root2, skillDir, "references");
+  const refsDir = join22(root2, skillDir, "references");
   if (!existsSync25(refsDir))
     return [];
   const files = [];
@@ -33380,18 +33254,18 @@ function listGeneratedReferenceFiles(root2, skillDir) {
 }
 function syncGeneratedCopy(ctx, refPath) {
   const { root: root2, plan, options, result } = ctx;
-  const sourceRel = normalizeRelPath(join23(CANONICAL_REFS_DIR, refPath));
-  const canonicalPath = join23(root2, sourceRel);
+  const sourceRel = normalizeRelPath(join22(CANONICAL_REFS_DIR, refPath));
+  const canonicalPath = join22(root2, sourceRel);
   if (!existsSync25(canonicalPath)) {
     throw new Error(`canonical reference missing: ${sourceRel}`);
   }
   const targetRel = generatedRefPath(plan.skillDir, refPath);
-  const targetPath = join23(root2, targetRel);
-  const canonicalContent = readFileSync24(canonicalPath, "utf8");
+  const targetPath = join22(root2, targetRel);
+  const canonicalContent = readFileSync23(canonicalPath, "utf8");
   const nextContent = formatGeneratedHeader(sourceRel) + canonicalContent;
   if (!options.dryRun)
     mkdirSync5(dirname14(targetPath), { recursive: true });
-  const existing = existsSync25(targetPath) ? readFileSync24(targetPath, "utf8") : null;
+  const existing = existsSync25(targetPath) ? readFileSync23(targetPath, "utf8") : null;
   if (existing !== nextContent) {
     if (!options.dryRun)
       writeFileSync6(targetPath, nextContent, "utf8");
@@ -33405,8 +33279,8 @@ function rewritePlanLinks(ctx, skillDir) {
   if (options.rewriteLinks === false)
     return;
   for (const relFile of walkMarkdownFiles2(skillDir, root2)) {
-    const filePath = join23(root2, relFile);
-    const content3 = readFileSync24(filePath, "utf8");
+    const filePath = join22(root2, relFile);
+    const content3 = readFileSync23(filePath, "utf8");
     const next = rewriteSharedRefLinks(content3, relFile, plan.skillDir);
     if (next === content3)
       continue;
@@ -33422,12 +33296,12 @@ function removeStaleGenerated(ctx) {
     if (plan.refPaths.has(refPath))
       continue;
     if (!options.dryRun)
-      unlinkSync2(join23(root2, generatedRel));
+      unlinkSync2(join22(root2, generatedRel));
     result.removed.push(generatedRel);
   }
 }
 function syncPlan(ctx) {
-  const skillDir = join23(ctx.root, ctx.plan.skillDir);
+  const skillDir = join22(ctx.root, ctx.plan.skillDir);
   for (const refPath of ctx.plan.refPaths) {
     syncGeneratedCopy(ctx, refPath);
   }
@@ -33436,7 +33310,7 @@ function syncPlan(ctx) {
 }
 function syncReferences(options = {}) {
   const root2 = options.root ?? process7.cwd();
-  const canonicalDir = join23(root2, CANONICAL_REFS_DIR);
+  const canonicalDir = join22(root2, CANONICAL_REFS_DIR);
   if (!existsSync25(canonicalDir)) {
     throw new Error(`canonical references dir not found: ${CANONICAL_REFS_DIR}`);
   }
@@ -33484,27 +33358,47 @@ function printSyncResult(result) {
 
 // src/validate/changed.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync25 } from "node:fs";
-import { basename as basename5, extname as extname2, join as join24 } from "node:path";
+import { existsSync as existsSync26, readFileSync as readFileSync24 } from "node:fs";
+import { basename as basename5, extname as extname2, join as join23 } from "node:path";
 
 // src/validate/git-diff.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
 function gitDiffChangedFiles(options = {}) {
   const root2 = options.root ?? findRepoRoot();
-  let args;
-  if (options.staged) {
-    args = ["diff", "--cached", "--name-only", "--diff-filter=ACMR"];
-  } else if (options.base) {
-    args = ["diff", `${options.base}...HEAD`, "--name-only", "--diff-filter=ACMR"];
-  } else {
-    args = ["diff", "HEAD", "--name-only", "--diff-filter=ACMR"];
-  }
-  const proc = spawnSync4("git", args, { cwd: root2, encoding: "utf8" });
+  const proc = spawnSync4("git", gitDiffArgs(options), { cwd: root2, encoding: "utf8" });
   if (proc.status !== 0) {
     throw new Error(proc.stderr?.trim() || "git diff failed");
   }
-  return proc.stdout.split(`
-`).map((line) => normalizeRelPath(line.trim())).filter(Boolean);
+  return parseChangedPaths(proc.stdout);
+}
+function gitDiffArgs(options) {
+  const prefix = options.staged ? ["diff", "--cached"] : ["diff", options.base ? `${options.base}...HEAD` : "HEAD"];
+  return [...prefix, "--name-status", "--find-renames", "--diff-filter=ACMRD"];
+}
+function parseChangedPaths(output) {
+  const changed = new Map;
+  for (const line of output.split(`
+`))
+    addChangedLine(changed, line);
+  return [...changed.values()];
+}
+function addChangedLine(changed, line) {
+  const [status = "", first = "", second] = line.split("\t");
+  if (!first)
+    return;
+  const paths = status.startsWith("R") || status.startsWith("C") ? [first, second] : [first];
+  for (const raw of paths)
+    addChangedPath({ changed, status, first, raw });
+}
+function addChangedPath(input) {
+  const { changed, status, first, raw } = input;
+  if (!raw)
+    return;
+  const path3 = normalizeRelPath(raw);
+  changed.set(path3, {
+    path: path3,
+    deleted: status.startsWith("D") || status.startsWith("R") && raw === first
+  });
 }
 
 // src/validate/changed.ts
@@ -33583,25 +33477,25 @@ function validationIssue(code3, file, message) {
   return issue("validate-changed", file, { code: code3, message, severity: "error" });
 }
 function validateJson(relPath2, root2) {
-  const abs = join24(root2, relPath2);
+  const abs = join23(root2, relPath2);
   try {
-    parseJsonContent(readFileSync25(abs, "utf8"));
+    parseJsonContent(readFileSync24(abs, "utf8"));
     return null;
   } catch (error) {
     return validationIssue("invalid-json", relPath2, `invalid JSON: ${error}`);
   }
 }
 function validatePolicy(relPath2, root2) {
-  const abs = join24(root2, relPath2);
+  const abs = join23(root2, relPath2);
   try {
-    loadPolicyFile(abs, readFileSync25(abs, "utf8"));
+    loadPolicyFile(abs, readFileSync24(abs, "utf8"));
     return null;
   } catch (error) {
     return validationIssue("invalid-policy", relPath2, `invalid policy: ${error}`);
   }
 }
 function validateShell(relPath2, root2) {
-  const abs = join24(root2, relPath2);
+  const abs = join23(root2, relPath2);
   const shellcheck = spawnSync5("shellcheck", [abs], { encoding: "utf8" });
   if (shellcheck.status === 0)
     return null;
@@ -33612,20 +33506,24 @@ function validateShell(relPath2, root2) {
 }
 function resolvePaths(options) {
   if (options.paths && options.paths.length > 0) {
-    return options.paths.map((p) => normalizeRelPath(p));
+    return { paths: options.paths.map((p) => normalizeRelPath(p)), deleted: new Set };
   }
-  return gitDiffChangedFiles({
+  const changed = gitDiffChangedFiles({
     staged: options.staged,
     base: options.base,
     root: options.root
   });
+  return {
+    paths: changed.map((entry) => entry.path),
+    deleted: new Set(changed.filter((entry) => entry.deleted).map((entry) => entry.path))
+  };
 }
 function packageManagerFromPackageJson(root2) {
-  const pkgPath = join24(root2, "package.json");
+  const pkgPath = join23(root2, "package.json");
   if (!existsSync26(pkgPath))
     return null;
   try {
-    const pkg = JSON.parse(readFileSync25(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync24(pkgPath, "utf8"));
     const raw = pkg.packageManager?.split("@")[0];
     if (raw === "bun" || raw === "npm" || raw === "pnpm" || raw === "yarn")
       return raw;
@@ -33633,13 +33531,13 @@ function packageManagerFromPackageJson(root2) {
   return null;
 }
 function packageManagerFromLockfiles(root2) {
-  if (existsSync26(join24(root2, "bun.lock")) || existsSync26(join24(root2, "bun.lockb")))
+  if (existsSync26(join23(root2, "bun.lock")) || existsSync26(join23(root2, "bun.lockb")))
     return "bun";
-  if (existsSync26(join24(root2, "pnpm-lock.yaml")))
+  if (existsSync26(join23(root2, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync26(join24(root2, "yarn.lock")))
+  if (existsSync26(join23(root2, "yarn.lock")))
     return "yarn";
-  if (existsSync26(join24(root2, "package-lock.json")))
+  if (existsSync26(join23(root2, "package-lock.json")))
     return "npm";
   return null;
 }
@@ -33665,7 +33563,7 @@ function emptyBuckets() {
 function classifySinglePath(input) {
   const { relPath: relPath2, ctx, state, bucketCtx } = input;
   const normalized = normalizeRelPath(relPath2);
-  const abs = join24(ctx.root, normalized);
+  const abs = join23(ctx.root, normalized);
   if (!existsSync26(abs)) {
     state.missing.push(normalized);
     return;
@@ -33730,23 +33628,29 @@ function discoverImpactedDocuments(input) {
   const changed = new Set(input.relPaths.map(normalizeRelPath));
   const impacted = [];
   for (const abs of collectScanFiles(input.config, input.root, input.skillIndex)) {
-    const path3 = relPath(abs, input.root);
-    const content3 = readFileSync25(abs, "utf8");
-    const codeTargets2 = [
-      ...new Set(parseCodeFitMarkers(content3).flatMap((marker) => marker.targets.map(normalizeRelPath)))
-    ].sort();
-    const reasons = [];
-    if (changed.has(path3))
-      reasons.push({ kind: "changed-document" });
-    for (const target of codeTargets2) {
-      if (changed.has(target))
-        reasons.push({ kind: "changed-code-target", target });
-    }
-    if (reasons.length > 0)
-      impacted.push({ path: path3, codeTargets: codeTargets2, reasons });
+    const document4 = impactedDocumentForPath(abs, input.root, changed);
+    if (document4)
+      impacted.push(document4);
   }
   return impacted.sort((a, b) => a.path.localeCompare(b.path));
 }
+function impactedDocumentForPath(abs, root2, changed) {
+  const path3 = relPath(abs, root2);
+  const reviewDependencies = reviewDependencyPatterns(readFileSync24(abs, "utf8"));
+  const reasons = impactReasons(path3, reviewDependencies, changed);
+  return reasons.length > 0 ? { path: path3, reviewDependencies, reasons } : null;
+}
+function impactReasons(path3, reviewDependencies, changed) {
+  const reasons = changed.has(path3) ? [{ kind: "changed-document" }] : [];
+  for (const dependency of reviewDependencies) {
+    for (const target of changed) {
+      if (reviewDependencyMatchesPath(dependency, target)) {
+        reasons.push({ kind: "changed-review-dependency", dependency, target });
+      }
+    }
+  }
+  return reasons;
+}
 function dateModeImpactDiagnostics(input) {
   if (input.config.reviewProof)
     return [];
@@ -33754,12 +33658,12 @@ function dateModeImpactDiagnostics(input) {
   const today = formatLocalReviewDate(new Date);
   const diagnostics = [];
   for (const impacted of input.impactedDocuments) {
-    if (!impacted.reasons.some((reason) => reason.kind === "changed-code-target"))
+    if (!impacted.reasons.some((reason) => reason.kind === "changed-review-dependency"))
       continue;
-    const content3 = readFileSync25(join24(input.root, impacted.path), "utf8");
+    const content3 = readFileSync24(join23(input.root, impacted.path), "utf8");
     if (changed.has(impacted.path) && docMetaLastReviewed(content3) === today)
       continue;
-    diagnostics.push(validationIssue("impacted-document-review-required", impacted.path, "a linked code-fit target changed; re-read the entire document, then attest it with --fix=doc-meta --confirm-reviewed and include the document in validation"));
+    diagnostics.push(validationIssue("impacted-document-review-required", impacted.path, "a linked review dependency changed; re-read the entire document, then attest it with --fix=doc-meta --confirm-reviewed and include the document in validation"));
   }
   return diagnostics;
 }
@@ -33840,8 +33744,6 @@ function resultFor(input) {
   const diagnostics = input.diagnostics ?? [];
   const failed = diagnostics.some((item) => item.severity === "error") || audits.some((audit) => audit.exitCode !== 0);
   return {
-    schemaVersion: 1,
-    command: "validate-changed",
     ok: !failed,
     exitCode: failed ? 1 : 0,
     input: {
@@ -33871,7 +33773,8 @@ function emptyClassification() {
 }
 async function evaluateValidateChanged(options = {}) {
   const root2 = options.root ?? findRepoRoot();
-  const relPaths = resolvePaths(options);
+  const resolvedPaths = resolvePaths(options);
+  const relPaths = resolvedPaths.paths;
   if (relPaths.length === 0) {
     return resultFor({ options, relPaths, classification: emptyClassification() });
   }
@@ -33896,6 +33799,7 @@ async function evaluateValidateChanged(options = {}) {
     wiredPolicies,
     skillIndex
   });
+  classification.missing = classification.missing.filter((path3) => !resolvedPaths.deleted.has(path3));
   const impactedDocuments = discoverImpactedDocuments({ relPaths, root: root2, config, skillIndex });
   for (const impacted of impactedDocuments) {
     if (!classification.buckets.docs.includes(impacted.path)) {
@@ -33929,11 +33833,7 @@ async function evaluateValidateChanged(options = {}) {
     diagnostics: evaluated.diagnostics
   });
 }
-function printValidateChangedResult(result, json) {
-  if (json) {
-    console.log(JSON.stringify(result, null, 2));
-    return result.exitCode;
-  }
+function printValidateChangedResult(result) {
   if (result.input.paths.length === 0) {
     console.log("validate changed: no changed files.");
     return result.exitCode;
@@ -33943,6 +33843,13 @@ function printValidateChangedResult(result, json) {
   }
   for (const audit of result.audits)
     printAuditResult(audit, false);
+  for (const impacted of result.impactedDocuments) {
+    for (const reason of impacted.reasons) {
+      if (reason.kind !== "changed-review-dependency")
+        continue;
+      console.log(`validate changed: ${impacted.path} requires review (dependency ${reason.dependency} matched ${reason.target})`);
+    }
+  }
   for (const diagnostic of result.diagnostics) {
     const path3 = diagnostic.file === "." ? "" : `${diagnostic.file}: `;
     console.error(`validate changed: ${path3}${diagnostic.message}`);
@@ -33963,7 +33870,7 @@ function printValidateChangedResult(result, json) {
   return result.exitCode;
 }
 async function runValidateChanged(options = {}) {
-  return printValidateChangedResult(await evaluateValidateChanged(options), options.json ?? false);
+  return printValidateChangedResult(await evaluateValidateChanged(options));
 }
 
 // src/cli.ts
@@ -33976,7 +33883,7 @@ Commands:
                          [--fix[=doc-meta|anchors|ssot]] [--dry-run]
                          [--confirm-reviewed (doc-meta only; requires --paths)]
   build-plugin [path] [--check]
-  validate changed [paths…] [--staged] [--base <ref>] [--json]
+  validate changed [paths…] [--staged] [--base <ref>]
   catalog [--check] [--strict]  write or check .skeleton/catalog.md (gitignored)
   customize resolve <slug> [--json]
   hook customize            (reads a host hook payload on stdin)
@@ -33989,13 +33896,10 @@ function parseValidateChangedArgs(rest) {
   const paths = [];
   let staged = false;
   let base;
-  let json = false;
   for (let i = 0;i < rest.length; i++) {
     const arg = rest[i];
     if (arg === "--staged")
       staged = true;
-    else if (arg === "--json")
-      json = true;
     else if (arg === "--base") {
       const value = rest[++i];
       if (!value || value.startsWith("-"))
@@ -34010,7 +33914,7 @@ function parseValidateChangedArgs(rest) {
     else if (arg && !arg.startsWith("-"))
       paths.push(arg);
   }
-  return { paths, staged, base, json };
+  return { paths, staged, base };
 }
 async function handleAudit(argv) {
   const sub = argv[0];
@@ -34034,8 +33938,8 @@ async function handleBuildPlugin(argv) {
   return 0;
 }
 async function handleValidateChanged(argv) {
-  const { paths, staged, base, json } = parseValidateChangedArgs(argv);
-  return runValidateChanged({ paths, staged, base, json });
+  const { paths, staged, base } = parseValidateChangedArgs(argv);
+  return runValidateChanged({ paths, staged, base });
 }
 function handleRegister() {
   console.error("register: removed — add `<!-- source-of-truth: … -->` (or visible `source-of-truth:`) to the file, then run `skeleton catalog`.");
@@ -34069,7 +33973,7 @@ function handleHook(argv) {
     usage();
     return 1;
   }
-  process9.stdout.write(runCustomizeHook(readFileSync26(0, "utf8")));
+  process9.stdout.write(runCustomizeHook(readFileSync25(0, "utf8")));
   return 0;
 }
 function handleInit(argv) {