skillwiki 0.10.49 → 0.10.50

package/dist/{chunk-FXASPB3C.js → chunk-EUTNN4RN.js}

@@ -2,7 +2,7 @@
 import {
   atomicWriteText,
   buildRootIndexUniverse
-} from "./chunk-UHZBOOMK.js";
+} from "./chunk-74OSLCXE.js";
 import {
   authorizeRawOperation,
   buildSourceReferenceIndex,
@@ -22,7 +22,7 @@ import {
   resolveExistingRegularFileInsideVault,
   stripFencedBlocks,
   writeLogEvent
-} from "./chunk-PLUHIOCQ.js";
+} from "./chunk-GAHMWLWU.js";
 import {
   ExitCode,
   FleetManifestSchema,
@@ -40,11 +40,11 @@ import {
   scanVault,
   splitFrontmatter,
   vaultIoConcurrency
-} from "./chunk-EVQASYII.js";
+} from "./chunk-IJ7DD7QZ.js";
 
 // src/utils/managed-write-preflight.ts
 import { existsSync as existsSync11 } from "fs";
-import { join as join20, resolve as resolve6 } from "path";
+import { join as join21, resolve as resolve6 } from "path";
 
 // src/commands/fleet.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -606,13 +606,332 @@ function safeUserName() {
 
 // src/commands/sync.ts
 import { existsSync as existsSync8 } from "fs";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 
-// src/commands/lint.ts
+// src/utils/last-op.ts
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync } from "fs";
+import { join as join2 } from "path";
+var LAST_OP_DIR = ".skillwiki";
+var LAST_OP_FILE = "last-op.json";
+function lastOpPath(vault) {
+  return join2(vault, LAST_OP_DIR, LAST_OP_FILE);
+}
+function readLastOp(vault) {
+  const p = lastOpPath(vault);
+  if (!existsSync(p)) return [];
+  try {
+    const raw = readFileSync(p, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      unlinkSync(p);
+      return [];
+    }
+    return parsed;
+  } catch {
+    try {
+      unlinkSync(p);
+    } catch (_e) {
+    }
+    return [];
+  }
+}
+function appendLastOp(vault, entry) {
+  const existing = readLastOp(vault);
+  existing.push(entry);
+  const dir = join2(vault, LAST_OP_DIR);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(lastOpPath(vault), JSON.stringify(existing, null, 2), "utf8");
+}
+function clearLastOp(vault) {
+  const p = lastOpPath(vault);
+  try {
+    unlinkSync(p);
+  } catch (_e) {
+  }
+}
+
+// src/lint/helpers.ts
+import { readdir } from "fs/promises";
+import { join as join3, relative, sep } from "path";
+var ERROR_ORDER = [
+  "sensitive_content",
+  "conflict_markers",
+  "broken_wikilinks",
+  "invalid_frontmatter",
+  "raw_source_identity_conflict",
+  "raw_dedup",
+  "broken_sources",
+  "tag_not_in_taxonomy",
+  "path_too_long"
+];
+var WARNING_ORDER = [
+  "raw_body_duplicate",
+  "raw_subdirectory_duplicate",
+  "file_source_url",
+  "index_incomplete",
+  "index_link_format",
+  "stale_page",
+  "page_too_large",
+  "log_rotate_needed",
+  "orphans",
+  "compound_refs",
+  "legacy_citation_style",
+  "orphaned_citations",
+  "duplicate_frontmatter",
+  "frontmatter_yaml_invalid",
+  "work_item_health",
+  "orphaned_project_pages",
+  "missing_overview",
+  "missing_diagram",
+  "cycle_traps"
+];
+var INFO_ORDER = [
+  "bridges",
+  "sparse_community",
+  "page_structure",
+  "topic_map_recommended",
+  "frontmatter_wikilink",
+  "wikilink_citation",
+  "missing_tldr",
+  "stale_sections",
+  "cli_refs"
+];
+var KNOWN_BUCKETS = [...ERROR_ORDER, ...WARNING_ORDER, ...INFO_ORDER];
+var CLI_REFS_TYPED_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
+var STRUCT_MIN_BODY_LINES = 60;
+var STRUCT_MIN_SECTIONS = 3;
+var CANONICAL_LOCAL_SOURCE_LABEL = /^\s*(?:>\s*)?(?:[-*+]\s*)?Source (?:file|inspected):/i;
+var LOCAL_ABSOLUTE_SOURCE_REF = /(?:file:\/\/(?:\/)?(?:Users|home)\/|\/(?:Users|home)\/)/;
+function hasDuplicateFrontmatter(body) {
+  if (/^---\r?\n/.test(body)) return true;
+  const lines = body.split(/\r?\n/);
+  const limit = Math.min(lines.length, 20);
+  let seenYamlKey = false;
+  for (let i = 0; i < limit; i++) {
+    if (/^\w[\w-]*:/.test(lines[i].trim())) seenYamlKey = true;
+    if (seenYamlKey && lines[i].trim() === "---") return true;
+  }
+  return false;
+}
+function hasCanonicalLocalSourceAssertion(body) {
+  const visibleBody = stripFencedBlocks(body);
+  return visibleBody.split(/\r?\n/).some(
+    (line) => CANONICAL_LOCAL_SOURCE_LABEL.test(line) && LOCAL_ABSOLUTE_SOURCE_REF.test(line)
+  );
+}
+function shouldCheckCanonicalLocalSourceAssertion(page) {
+  if (page.relPath.startsWith("raw/transcripts/")) return false;
+  if (/^projects\/[^/]+\/work\/[^/]+\/log\.md$/.test(page.relPath)) return false;
+  if (page.relPath.startsWith("raw/")) return true;
+  if (/^(entities|concepts|comparisons|queries|meta)\//.test(page.relPath)) return true;
+  if (/^projects\/[^/]+\/compound\//.test(page.relPath)) return true;
+  if (/^projects\/[^/]+\/work\/[^/]+\/(spec|plan)\.md$/.test(page.relPath)) return true;
+  return false;
+}
+function extractSourceEntries(rawFm) {
+  const lines = rawFm.split(/\r?\n/);
+  const sourcesLineIdx = lines.findIndex((l) => /^sources:/.test(l));
+  if (sourcesLineIdx === -1) return [];
+  const sourcesLine = lines[sourcesLineIdx].trim();
+  const inlineMatch = sourcesLine.match(/^sources:\s*\[(.+)]\s*$/);
+  if (inlineMatch) {
+    return [...inlineMatch[1].matchAll(/"[^"]*"|'[^']*'|[^,\s]\S*/g)].map(
+      (m) => m[0].replace(/,\s*$/, "")
+    );
+  }
+  const entries = [];
+  for (let i = sourcesLineIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (!/^\s+- /.test(line)) break;
+    entries.push(line.replace(/^\s+- /, "").trim());
+  }
+  return entries;
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function formatExample(item) {
+  if (typeof item === "string") return item;
+  if (item === null || item === void 0) return String(item);
+  try {
+    return JSON.stringify(item);
+  } catch {
+    return String(item);
+  }
+}
+function summarizeBucket(bucket, severity, vaultPath, examplesLimit) {
+  const safeLimit = Math.max(0, Math.min(examplesLimit, 10));
+  const examples = bucket.items.slice(0, safeLimit).map(formatExample);
+  return {
+    kind: bucket.kind,
+    severity,
+    count: bucket.items.length,
+    examples,
+    examples_limit: safeLimit,
+    sample_truncated: bucket.items.length > examples.length,
+    details_command: `skillwiki lint ${shellQuote(vaultPath)} --only ${bucket.kind}`
+  };
+}
+function severityForBucket(kind) {
+  if (ERROR_ORDER.includes(kind)) return "error";
+  if (WARNING_ORDER.includes(kind)) return "warning";
+  return "info";
+}
+function lintReadVault(input) {
+  if (input.fix) {
+    return { readPath: input.vault, readMirror: false };
+  }
+  const resolved = resolveReadOnlyVaultRoot(input.vault);
+  return { readPath: resolved.root, readMirror: resolved.mirrored };
+}
+function lintVaultOutput(input, readVault) {
+  return {
+    path: input.vault,
+    source: input.source ?? "resolved",
+    read_path: readVault.readPath,
+    read_mirror: readVault.readMirror
+  };
+}
+function readMirrorHintLines(vault) {
+  if (!vault.read_mirror) return [];
+  return [
+    `read mirror: ${vault.read_path}`,
+    `requested vault: ${vault.path}`,
+    "if results look stale, refresh the read mirror or rerun with SKILLWIKI_DISABLE_VAULT_READ_MIRROR=1 for a live scan; live scans may be slower"
+  ];
+}
+function appendLintFixLastOp(vault, fixed) {
+  if (fixed.length === 0) return;
+  appendLastOp(vault, {
+    operation: "lint-fix",
+    summary: `fixed ${fixed.length} page(s)`,
+    files: fixed,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function summarizeLintOutput(output, examplesLimit = 3) {
+  const buckets = [
+    ...output.by_severity.error.map(
+      (bucket) => summarizeBucket(bucket, "error", output.vault.path, examplesLimit)
+    ),
+    ...output.by_severity.warning.map(
+      (bucket) => summarizeBucket(bucket, "warning", output.vault.path, examplesLimit)
+    ),
+    ...output.by_severity.info.map(
+      (bucket) => summarizeBucket(bucket, "info", output.vault.path, examplesLimit)
+    )
+  ];
+  const lines = [];
+  lines.push(...readMirrorHintLines(output.vault));
+  lines.push(`errors: ${output.summary.errors}`);
+  lines.push(`warnings: ${output.summary.warnings}`);
+  lines.push(`info: ${output.summary.info}`);
+  for (const bucket of buckets) {
+    lines.push(`  ${bucket.kind}: ${bucket.count}`);
+    if (bucket.examples.length > 0) {
+      lines.push(`    e.g. ${bucket.examples[0]}`);
+    }
+  }
+  return {
+    vault: output.vault,
+    summary: output.summary,
+    buckets,
+    details_included: false,
+    truncated: false,
+    fixed: output.fixed,
+    unresolved: output.unresolved,
+    humanHint: lines.join("\n")
+  };
+}
+function outputForOnlyBucket(input, match, fixed, unresolved, readVault = lintReadVault(input)) {
+  const severity = severityForBucket(input.only);
+  const filtered = severity === "error" ? { error: match, warning: [], info: [] } : severity === "warning" ? { error: [], warning: match, info: [] } : { error: [], warning: [], info: match };
+  const summary = {
+    errors: filtered.error.reduce((n, b) => n + b.items.length, 0),
+    warnings: filtered.warning.reduce((n, b) => n + b.items.length, 0),
+    info: filtered.info.reduce((n, b) => n + b.items.length, 0)
+  };
+  let exitCode = ExitCode.OK;
+  if (summary.errors > 0) exitCode = ExitCode.LINT_HAS_ERRORS;
+  else if (summary.warnings > 0 || summary.info > 0) exitCode = ExitCode.LINT_HAS_WARNINGS;
+  const vault = lintVaultOutput(input, readVault);
+  const hintLines = [
+    ...readMirrorHintLines(vault),
+    `--only ${input.only}`,
+    match.length === 0 ? "0 violations" : match.map((b) => `  ${b.kind}: ${b.items.length}`).join("\n")
+  ];
+  const output = {
+    vault,
+    summary,
+    by_severity: filtered,
+    fixed,
+    unresolved,
+    humanHint: hintLines.join("\n")
+  };
+  return {
+    exitCode,
+    result: ok(input.summary ? summarizeLintOutput(output, input.examplesLimit) : output)
+  };
+}
+async function walkMarkdownFiles(absDir, vaultRoot) {
+  const entries = await readdir(absDir, { withFileTypes: true });
+  const pages = [];
+  for (const entry of entries) {
+    const absPath = join3(absDir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === ".git" || entry.name === "node_modules") continue;
+      pages.push(...await walkMarkdownFiles(absPath, vaultRoot));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      pages.push({ absPath, relPath: relative(vaultRoot, absPath).split(sep).join("/") });
+    }
+  }
+  return pages;
+}
+
+// src/lint/fingerprints.ts
+function lintIssueFingerprint(bucket, item) {
+  const page = extractIssuePage(item);
+  const detail = normalizeIssueDetail(item);
+  return `${bucket}\0${page}\0${detail}`;
+}
+function extractIssuePage(item) {
+  if (typeof item === "string") {
+    const m = item.match(/^([^:]+?)(?::\s|$)/);
+    return (m?.[1] ?? item).trim();
+  }
+  if (item && typeof item === "object") {
+    const obj = item;
+    for (const key of ["path", "file", "page", "relPath"]) {
+      if (typeof obj[key] === "string") return obj[key];
+    }
+  }
+  return "";
+}
+function normalizeIssueDetail(item) {
+  if (typeof item === "string") {
+    return item.replace(/\s+/g, " ").trim();
+  }
+  try {
+    return JSON.stringify(item, Object.keys(item).sort());
+  } catch {
+    return String(item);
+  }
+}
+function collectLintErrorFingerprints(output) {
+  const fps = /* @__PURE__ */ new Set();
+  for (const bucket of output.by_severity.error) {
+    for (const item of bucket.items) {
+      fps.add(lintIssueFingerprint(bucket.kind, item));
+    }
+  }
+  return fps;
+}
+
+// src/lint/rules.ts
 import { existsSync as existsSync4 } from "fs";
-import { readFile as readFile13, readdir as readdir2 } from "fs/promises";
-import { join as join12, relative, sep } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join13 } from "path";
 
 // src/parsers/wikilinks.ts
 var FENCE = /```[\s\S]*?```|`[^`\n]*`/g;
@@ -720,7 +1039,7 @@ ${broken.map((b) => `  ${b.page}:[[${b.slug}]] (line ${b.line})`).join("\n")}` }
 
 // src/commands/tag-audit.ts
 import { readFile as readFile3 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join4 } from "path";
 
 // src/parsers/taxonomy.ts
 import yaml2 from "js-yaml";
@@ -873,7 +1192,7 @@ async function runTagAudit(input) {
   const scanResult = input.scan ? ok(input.scan) : await scanVault(input.vault);
   if (!scanResult.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scanResult };
   const scan = scanResult.data;
-  const schemaText = await readFile3(join2(input.vault, "SCHEMA.md"), "utf8");
+  const schemaText = await readFile3(join4(input.vault, "SCHEMA.md"), "utf8");
   const tax = extractTaxonomy(schemaText);
   if (!tax.ok) return { exitCode: ExitCode.INVALID_FRONTMATTER, result: tax };
   const allowed = new Set(tax.data);
@@ -906,7 +1225,7 @@ async function runTagAudit(input) {
 
 // src/commands/index-check.ts
 import { readFile as readFile4 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 function normalizeIndexTarget(raw) {
   return raw.replace(/\.md$/, "").replace(/^\.?\//, "");
 }
@@ -918,7 +1237,7 @@ async function runIndexCheck(input) {
   }
   let indexText = "";
   try {
-    indexText = await readFile4(join3(input.vault, "index.md"), "utf8");
+    indexText = await readFile4(join5(input.vault, "index.md"), "utf8");
   } catch {
   }
   const indexTargets = /* @__PURE__ */ new Set();
@@ -971,9 +1290,28 @@ async function runIndexCheck(input) {
   return { exitCode: ExitCode.OK, result: ok({ missing_from_index, ghost_entries, humanHint: hintLines.join("\n") }) };
 }
 
+// src/commands/index-link-format.ts
+import { readFile as readFile5 } from "fs/promises";
+import { join as join6 } from "path";
+var MD_LINK_RE = /\[[^\[\]]+\]\([^)]+\.md\)/;
+async function runIndexLinkFormat(input) {
+  let text = "";
+  try {
+    text = await readFile5(join6(input.vault, "index.md"), "utf8");
+  } catch {
+  }
+  const markdown_links = [];
+  for (const [i, line] of text.split("\n").entries()) {
+    if (MD_LINK_RE.test(line)) markdown_links.push({ line: i + 1, text: line.trim() });
+  }
+  const humanHint = markdown_links.length === 0 ? "all index links use wikilink format" : `markdown links found: ${markdown_links.length}
+${markdown_links.map((l) => `  line ${l.line}: ${l.text}`).join("\n")}`;
+  return { exitCode: ExitCode.OK, result: ok({ markdown_links, humanHint }) };
+}
+
 // src/commands/stale.ts
-import { readdir, rename, mkdir as mkdir3, readFile as readFile6 } from "fs/promises";
-import { join as join5 } from "path";
+import { readdir as readdir2, rename, mkdir as mkdir3, readFile as readFile7 } from "fs/promises";
+import { join as join7 } from "path";
 
 // src/parsers/expiry-annotations.ts
 var HEADING_RE = /^#{1,6}\s+(.+)$/;
@@ -1009,51 +1347,9 @@ function parseExpiryAnnotations(content, pagePath) {
   return annotations;
 }
 
-// src/utils/last-op.ts
-import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync } from "fs";
-import { join as join4 } from "path";
-var LAST_OP_DIR = ".skillwiki";
-var LAST_OP_FILE = "last-op.json";
-function lastOpPath(vault) {
-  return join4(vault, LAST_OP_DIR, LAST_OP_FILE);
-}
-function readLastOp(vault) {
-  const p = lastOpPath(vault);
-  if (!existsSync(p)) return [];
-  try {
-    const raw = readFileSync(p, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed)) {
-      unlinkSync(p);
-      return [];
-    }
-    return parsed;
-  } catch {
-    try {
-      unlinkSync(p);
-    } catch (_e) {
-    }
-    return [];
-  }
-}
-function appendLastOp(vault, entry) {
-  const existing = readLastOp(vault);
-  existing.push(entry);
-  const dir = join4(vault, LAST_OP_DIR);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(lastOpPath(vault), JSON.stringify(existing, null, 2), "utf8");
-}
-function clearLastOp(vault) {
-  const p = lastOpPath(vault);
-  try {
-    unlinkSync(p);
-  } catch (_e) {
-  }
-}
-
 // src/utils/raw-structural-transaction.ts
 import { createHash } from "crypto";
-import { copyFile, mkdir as mkdir2, readFile as readFile5, unlink } from "fs/promises";
+import { copyFile, mkdir as mkdir2, readFile as readFile6, unlink } from "fs/promises";
 import { constants } from "fs";
 import { dirname as dirname2 } from "path";
 function sha256(bytes) {
@@ -1109,7 +1405,7 @@ async function planRawStructuralMove(input) {
   if (!destinationResolved.ok) {
     return destinationResolved.error === "RAW_DESTINATION_EXISTS" ? destinationResolved : err("RAW_DESTINATION_UNSAFE", { path: input.destination, cause: destinationResolved });
   }
-  const sourceBytes = await readFile5(sourceResolved.data);
+  const sourceBytes = await readFile6(sourceResolved.data);
   const sourceSha = sha256(sourceBytes);
   const operation_id = operationId("raw-structural", [input.operation, input.source, input.destination, sourceSha]);
   const base = {
@@ -1142,7 +1438,7 @@ async function applyRawStructuralMove(input) {
   } catch (error) {
     return err("RAW_MOVE_COPY_FAILED", { source: input.source, destination: input.destination, message: String(error) });
   }
-  const destinationBytes = await readFile5(destinationAbs);
+  const destinationBytes = await readFile6(destinationAbs);
   const destinationSha = sha256(destinationBytes);
   if (destinationSha !== planned.data.source_sha256) {
     return err("RAW_MOVE_HASH_MISMATCH", { source: input.source, destination: input.destination, source_sha256: planned.data.source_sha256, destination_sha256: destinationSha });
@@ -1288,10 +1584,10 @@ async function runStale(input) {
   const incompleteWorkItems = [];
   const archived = [];
   const workDirs = /* @__PURE__ */ new Map();
-  const projectsDir = join5(input.vault, "projects");
+  const projectsDir = join7(input.vault, "projects");
   let projectSlugs = [];
   try {
-    projectSlugs = (await readdir(projectsDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+    projectSlugs = (await readdir2(projectsDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
   } catch {
   }
   if (input.project) {
@@ -1301,21 +1597,21 @@ async function runStale(input) {
     projectSlugs = [input.project];
   }
   for (const slug of projectSlugs) {
-    const workPath = join5(projectsDir, slug, "work");
+    const workPath = join7(projectsDir, slug, "work");
     let entries;
     try {
-      entries = await readdir(workPath, { withFileTypes: true });
+      entries = await readdir2(workPath, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
       if (!e.isDirectory()) continue;
       const relDir = `projects/${slug}/work/${e.name}`;
-      const absDir = join5(workPath, e.name);
+      const absDir = join7(workPath, e.name);
       let status = "";
       let files;
       try {
-        files = await readdir(absDir);
+        files = await readdir2(absDir);
       } catch {
         workDirs.set(relDir, "");
         continue;
@@ -1323,7 +1619,7 @@ async function runStale(input) {
       for (const f of files) {
         if (!f.endsWith(".md")) continue;
         try {
-          const fm = extractFrontmatter(await readFile6(join5(absDir, f), "utf8"));
+          const fm = extractFrontmatter(await readFile7(join7(absDir, f), "utf8"));
           if (fm.ok && typeof fm.data.status === "string") {
             status = fm.data.status;
             break;
@@ -1383,9 +1679,9 @@ async function runStale(input) {
     if (entry) transcriptMeta.set(entry[0], entry[1]);
   }
   const claimSources = await mapWithConcurrency([...workDirs.keys()], vaultIoConcurrency(), async (relDir) => {
-    const specPath = join5(input.vault, relDir, "spec.md");
+    const specPath = join7(input.vault, relDir, "spec.md");
     try {
-      const specContent = await readFile6(specPath, "utf8");
+      const specContent = await readFile7(specPath, "utf8");
       const specFm = extractFrontmatter(specContent);
       if (!specFm.ok) return null;
       return {
@@ -1427,7 +1723,7 @@ async function runStale(input) {
     if (daysSince(dateStr) < input.days) continue;
     let files;
     try {
-      files = await readdir(join5(input.vault, relDir));
+      files = await readdir2(join7(input.vault, relDir));
     } catch {
       continue;
     }
@@ -1497,7 +1793,7 @@ async function runStale(input) {
   staleSections.push(...staleSectionResults.flat());
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   if (input.archive) {
-    const archiveDir = join5(input.vault, "_archive", today);
+    const archiveDir = join7(input.vault, "_archive", today);
     const relocations = await readSourceRelocations(input.vault);
     if (!relocations.ok) return { exitCode: ExitCode.WRITE_FAILED, result: relocations };
     const typedPaths = new Set(scan.typedKnowledge.map((page) => page.relPath));
@@ -1566,19 +1862,19 @@ async function runStale(input) {
       const active = parseActiveWorkPath(w.path);
       if (active) {
         const { project: slug, item: itemName } = active;
-        const histDir = join5(input.vault, "projects", slug, "history", "archived-work");
+        const histDir = join7(input.vault, "projects", slug, "history", "archived-work");
         await mkdir3(histDir, { recursive: true });
-        const dest = join5(histDir, itemName);
+        const dest = join7(histDir, itemName);
         try {
-          await rename(join5(input.vault, w.path), dest);
+          await rename(join7(input.vault, w.path), dest);
           archived.push(w.path);
         } catch (error) {
           return { exitCode: ExitCode.WRITE_FAILED, result: err("WRITE_FAILED", { path: w.path, destination: dest, message: String(error) }) };
         }
       } else {
-        const dest = join5(archiveDir, w.path.replace(/\//g, "_"));
+        const dest = join7(archiveDir, w.path.replace(/\//g, "_"));
         try {
-          await rename(join5(input.vault, w.path), dest);
+          await rename(join7(input.vault, w.path), dest);
           archived.push(w.path);
         } catch (error) {
           return { exitCode: ExitCode.WRITE_FAILED, result: err("WRITE_FAILED", { path: w.path, destination: dest, message: String(error) }) };
@@ -1634,8 +1930,8 @@ async function runPagesize(input) {
 }
 
 // src/commands/log-rotate.ts
-import { access, readFile as readFile7, rename as rename2, writeFile as writeFile2, stat } from "fs/promises";
-import { join as join6 } from "path";
+import { access, readFile as readFile8, rename as rename2, writeFile as writeFile2, stat } from "fs/promises";
+import { join as join8 } from "path";
 var ENTRY_RE = /^## \[(\d{4})-\d{2}-\d{2}\]/gm;
 var FULL_DATE_RE = /^## \[(\d{4}-\d{2}-\d{2})\]/gm;
 async function pathExists(p) {
@@ -1658,27 +1954,27 @@ function archiveNameForExistingYearLog(existingText, fallbackYear) {
 }
 async function sidelineExistingYearLog(vault, rotatedPath, fallbackYear) {
   if (!await pathExists(rotatedPath)) return void 0;
-  const existingText = await readFile7(rotatedPath, "utf8");
+  const existingText = await readFile8(rotatedPath, "utf8");
   let archiveName = archiveNameForExistingYearLog(existingText, fallbackYear);
-  let archivePath = join6(vault, archiveName);
+  let archivePath = join8(vault, archiveName);
   if (await pathExists(archivePath)) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     archiveName = archiveName.replace(/\.md$/, `-${stamp}.md`);
-    archivePath = join6(vault, archiveName);
+    archivePath = join8(vault, archiveName);
   }
   await rename2(rotatedPath, archivePath);
   return archiveName;
 }
 async function runLogRotate(input) {
   try {
-    await stat(join6(input.vault, "SCHEMA.md"));
+    await stat(join8(input.vault, "SCHEMA.md"));
   } catch {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { vault: input.vault }) };
   }
-  const logPath = join6(input.vault, "log.md");
+  const logPath = join8(input.vault, "log.md");
   let logText;
   try {
-    logText = await readFile7(logPath, "utf8");
+    logText = await readFile8(logPath, "utf8");
   } catch {
     return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: logPath }) };
   }
@@ -1689,7 +1985,7 @@ async function runLogRotate(input) {
   }
   const newestYear = matches[matches.length - 1][1];
   const rotatedName = `log-${newestYear}.md`;
-  const rotatedPath = join6(input.vault, rotatedName);
+  const rotatedPath = join8(input.vault, rotatedName);
   const yearExists = await pathExists(rotatedPath);
   if (!input.apply) {
     const hint = yearExists ? `${entries}/${input.threshold} entries \u2014 rotation needed (use --apply); existing ${rotatedName} will be sidelined to log-archive-* first` : `${entries}/${input.threshold} entries \u2014 rotation needed (use --apply)`;
@@ -1740,7 +2036,7 @@ Chronological action log. Newest entries last. Skill writes append entries; lint
 }
 
 // src/utils/wiki-path.ts
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 async function resolveInitTimePath(input) {
   const chain = [];
   if (input.flag !== void 0 && input.flag.length > 0) {
@@ -1753,27 +2049,27 @@ async function resolveInitTimePath(input) {
     return { path: input.envValue, source: "env", ...input.explain ? { chain } : {} };
   }
   if (input.explain) chain.push({ source: "env", matched: false });
-  const sw = await parseDotenvFile(join7(input.home, ".skillwiki", ".env"));
+  const sw = await parseDotenvFile(join9(input.home, ".skillwiki", ".env"));
   if (sw.WIKI_PATH !== void 0) {
     if (input.explain) chain.push({ source: "skillwiki-dotenv", matched: true, value: sw.WIKI_PATH });
     return { path: sw.WIKI_PATH, source: "skillwiki-dotenv", ...input.explain ? { chain } : {} };
   }
   if (input.explain) chain.push({ source: "skillwiki-dotenv", matched: false });
-  const hermes = await parseDotenvFile(join7(input.home, ".hermes", ".env"));
+  const hermes = await parseDotenvFile(join9(input.home, ".hermes", ".env"));
   if (hermes.WIKI_PATH !== void 0) {
     if (input.explain) chain.push({ source: "hermes-dotenv", matched: true, value: hermes.WIKI_PATH });
     return { path: hermes.WIKI_PATH, source: "hermes-dotenv", ...input.explain ? { chain } : {} };
   }
   if (input.explain) chain.push({ source: "hermes-dotenv", matched: false });
   if (input.cwd) {
-    const projCfg = await parseDotenvFile(join7(input.cwd, ".skillwiki", ".env"));
+    const projCfg = await parseDotenvFile(join9(input.cwd, ".skillwiki", ".env"));
     if (projCfg.WIKI_PATH !== void 0) {
       if (input.explain) chain.push({ source: "project-dotenv", matched: true, value: projCfg.WIKI_PATH });
       return { path: projCfg.WIKI_PATH, source: "project-dotenv", ...input.explain ? { chain } : {} };
     }
   }
   if (input.explain) chain.push({ source: "project-dotenv", matched: false });
-  const fallback = join7(input.home, "wiki");
+  const fallback = join9(input.home, "wiki");
   if (input.explain) chain.push({ source: "default", matched: true, value: fallback });
   return { path: fallback, source: "default", ...input.explain ? { chain } : {} };
 }
@@ -1784,7 +2080,7 @@ async function resolveRuntimePath(input) {
     return ok({ path: input.flag, source: "flag", ...input.explain ? { chain } : {} });
   }
   if (input.explain) chain.push({ source: "flag", matched: false });
-  const swGlobal = await parseDotenvFile(join7(input.home, ".skillwiki", ".env"));
+  const swGlobal = await parseDotenvFile(join9(input.home, ".skillwiki", ".env"));
   const wikiName = input.wiki;
   if (wikiName !== void 0 && wikiName.length > 0) {
     if (wikiName.toLowerCase() === "default") {
@@ -1828,7 +2124,7 @@ async function resolveRuntimePath(input) {
   }
   if (input.explain) chain.push({ source: "env", matched: false });
   if (input.cwd) {
-    const projCfg = await parseDotenvFile(join7(input.cwd, ".skillwiki", ".env"));
+    const projCfg = await parseDotenvFile(join9(input.cwd, ".skillwiki", ".env"));
     if (projCfg.WIKI_PATH !== void 0) {
       if (input.explain) chain.push({ source: "project-dotenv", matched: true, value: projCfg.WIKI_PATH });
       return ok({ path: projCfg.WIKI_PATH, source: "project-dotenv", ...input.explain ? { chain } : {} });
@@ -2107,29 +2403,10 @@ async function runTopicMapCheck(input) {
   };
 }
 
-// src/commands/index-link-format.ts
-import { readFile as readFile8 } from "fs/promises";
-import { join as join8 } from "path";
-var MD_LINK_RE = /\[[^\[\]]+\]\([^)]+\.md\)/;
-async function runIndexLinkFormat(input) {
-  let text = "";
-  try {
-    text = await readFile8(join8(input.vault, "index.md"), "utf8");
-  } catch {
-  }
-  const markdown_links = [];
-  for (const [i, line] of text.split("\n").entries()) {
-    if (MD_LINK_RE.test(line)) markdown_links.push({ line: i + 1, text: line.trim() });
-  }
-  const humanHint = markdown_links.length === 0 ? "all index links use wikilink format" : `markdown links found: ${markdown_links.length}
-${markdown_links.map((l) => `  line ${l.line}: ${l.text}`).join("\n")}`;
-  return { exitCode: ExitCode.OK, result: ok({ markdown_links, humanHint }) };
-}
-
 // src/commands/dedup.ts
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3, join as join9, posix, resolve } from "path";
+import { dirname as dirname3, join as join10, posix, resolve } from "path";
 
 // src/utils/rclone.ts
 import { execFile } from "child_process";
@@ -2374,7 +2651,7 @@ async function runDedup(input) {
   const structuralPlans = [];
   for (const entry of safeEntries) {
     for (const duplicate of entry.duplicates) {
-      if (!existsSync2(join9(input.vault, duplicate))) continue;
+      if (!existsSync2(join10(input.vault, duplicate))) continue;
       const destination = dedupDestination(input.vault, duplicate);
       const plan = await planRawStructuralMove({ vault: input.vault, operation: "deduplicate", source: duplicate, destination });
       if (!plan.ok) return { exitCode: ExitCode.WRITE_FAILED, result: plan };
@@ -2403,7 +2680,7 @@ async function runDedup(input) {
     for (const plan of structuralPlans) replacements.set(plan.source, plan.canonical);
     const pendingWrites = [];
     for (const page of scan.allMarkdown.filter((p) => !p.relPath.startsWith("raw/"))) {
-      const text = readFileSync2(join9(input.vault, page.relPath), "utf-8");
+      const text = readFileSync2(join10(input.vault, page.relPath), "utf-8");
       let updated = text;
       let changed = false;
       for (const [oldPath, newPath] of replacements) {
@@ -2430,7 +2707,7 @@ async function runDedup(input) {
       relocated.push({ from: plan.source, to: plan.destination });
     }
     for (const pending of pendingWrites) {
-      const write = await safeWritePage(join9(input.vault, pending.page), pending.text);
+      const write = await safeWritePage(join10(input.vault, pending.page), pending.text);
       if (!write.ok) return { exitCode: ExitCode.WRITE_FAILED, result: write };
     }
   }
@@ -2485,8 +2762,8 @@ async function runDedup(input) {
 function dedupDestination(vault, source) {
   const base = lifecycleDestination(source, "deduplicate");
   if (!base.ok) throw new Error(`unsupported raw dedup path: ${source}`);
-  if (!existsSync2(join9(vault, base.data))) return base.data;
-  const contentHash = createHash3("sha256").update(readFileSync2(join9(vault, source))).digest("hex").slice(0, 8);
+  if (!existsSync2(join10(vault, base.data))) return base.data;
+  const contentHash = createHash3("sha256").update(readFileSync2(join10(vault, source))).digest("hex").slice(0, 8);
   const ext = posix.extname(base.data);
   const stem = ext ? base.data.slice(0, -ext.length) : base.data;
   return `${stem}--${contentHash}${ext}`;
@@ -2538,7 +2815,7 @@ function buildSafeEntries(vault, duplicates, unsafe) {
   return entries;
 }
 function hashRawBody(vault, relPath) {
-  const text = readFileSync2(join9(vault, relPath), "utf-8");
+  const text = readFileSync2(join10(vault, relPath), "utf-8");
   return hashRawBodyText(text);
 }
 function hashRawBodyText(text) {
@@ -2579,13 +2856,13 @@ function validateManifestLocalState(vault, manifest) {
         return err("APPROVAL_INVALID", { message: "dedup manifest contains an invalid active raw source path", path });
       }
     }
-    const canonicalExists = existsSync2(join9(vault, entry.canonical));
-    const liveDuplicates = entry.duplicates.filter((path) => existsSync2(join9(vault, path)));
+    const canonicalExists = existsSync2(join10(vault, entry.canonical));
+    const liveDuplicates = entry.duplicates.filter((path) => existsSync2(join10(vault, path)));
     if (!canonicalExists && liveDuplicates.length > 0) {
       return err("APPROVAL_INVALID", { message: "dedup manifest canonical is missing while a local duplicate exists", canonical: entry.canonical });
     }
     for (const path of canonicalExists ? [entry.canonical, ...liveDuplicates] : liveDuplicates) {
-      const text = readFileSync2(join9(vault, path), "utf8");
+      const text = readFileSync2(join10(vault, path), "utf8");
       const fm = extractFrontmatter(text);
       const declaredSha = fm.ok && typeof fm.data.sha256 === "string" ? fm.data.sha256 : null;
       if (declaredSha !== entry.sha256 || hashRawBodyText(text) !== entry.bodyHash) {
@@ -2644,7 +2921,7 @@ async function runRawBodyDedup(vault, scan, pageTextCache) {
 
 // src/commands/audit.ts
 import { readFile as readFile11, stat as stat2 } from "fs/promises";
-import { dirname as dirname4, resolve as resolve2, join as join10 } from "path";
+import { dirname as dirname4, resolve as resolve2, join as join11 } from "path";
 async function runAudit(input) {
   let text;
   try {
@@ -2701,7 +2978,7 @@ async function findVaultRoot(start) {
   let cur = start;
   for (let i = 0; i < 20; i++) {
     try {
-      await stat2(join10(cur, "SCHEMA.md"));
+      await stat2(join11(cur, "SCHEMA.md"));
       return cur;
     } catch {
     }
@@ -2752,86 +3029,10 @@ async function validateCompoundReferences(vault, existingScan, pageTextCache) {
   return ok(findings);
 }
 
-// src/commands/frontmatter-fix.ts
-function isoToday() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-}
-function fixFrontmatter(rawFm) {
-  const additions = [];
-  if (!/^created:/m.test(rawFm)) additions.push(`created: ${isoToday()}`);
-  if (!/^updated:/m.test(rawFm)) additions.push(`updated: ${isoToday()}`);
-  if (!/^tags:/m.test(rawFm)) additions.push("tags: []");
-  if (!/^sources:/m.test(rawFm)) additions.push("sources: []");
-  if (!/^provenance:/m.test(rawFm)) additions.push("provenance: research");
-  if (additions.length === 0) return rawFm;
-  return rawFm.trimEnd() + "\n" + additions.join("\n") + "\n";
-}
-function removeOrphanTagsLines(body) {
-  return body.split("\n").filter((line) => !/^tags:\s*\[/.test(line.trim())).join("\n");
-}
-async function runFrontmatterFix(input) {
-  const scan = await scanVault(input.vault);
-  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
-  const fixed = [];
-  const skipped = [];
-  let unchanged = 0;
-  for (const page of scan.data.typedKnowledge) {
-    const text = await readPage(page);
-    const split = splitFrontmatter(text);
-    if (!split.ok) {
-      skipped.push(page.relPath);
-      continue;
-    }
-    const { rawFrontmatter, body } = split.data;
-    const newFm = fixFrontmatter(rawFrontmatter);
-    const newBody = removeOrphanTagsLines(body);
-    const newText = `---
-${newFm}
----
-${newBody}`;
-    if (newText === text) {
-      unchanged++;
-      continue;
-    }
-    if (!input.dryRun) {
-      const w = await safeWritePage(page.absPath, newText);
-      if (!w.ok) {
-        skipped.push(page.relPath);
-        continue;
-      }
-    }
-    fixed.push(page.relPath);
-  }
-  const exitCode = fixed.length > 0 ? ExitCode.MIGRATION_APPLIED : ExitCode.OK;
-  const hintLines = [`scanned: ${fixed.length + skipped.length + unchanged}`];
-  if (fixed.length > 0) hintLines.push(`fixed: ${fixed.length}`);
-  if (skipped.length > 0) hintLines.push(`skipped (parse error): ${skipped.length}`);
-  if (unchanged > 0) hintLines.push(`unchanged: ${unchanged}`);
-  if (input.dryRun && fixed.length > 0) hintLines.push("(dry run \u2014 no files written)");
-  if (!input.dryRun && fixed.length > 0) {
-    appendLastOp(input.vault, {
-      operation: "frontmatter-fix",
-      summary: `normalized frontmatter on ${fixed.length} page(s)`,
-      files: fixed,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  return {
-    exitCode,
-    result: ok({
-      scanned: fixed.length + skipped.length + unchanged,
-      fixed,
-      skipped,
-      unchanged,
-      humanHint: hintLines.join("\n")
-    })
-  };
-}
-
 // src/commands/path-too-long.ts
 import { existsSync as existsSync3 } from "fs";
 import { mkdir as mkdir4, readFile as readFile12, rename as rename3, unlink as unlink2 } from "fs/promises";
-import { dirname as dirname5, join as join11, posix as posix2, resolve as resolve3 } from "path";
+import { dirname as dirname5, join as join12, posix as posix2, resolve as resolve3 } from "path";
 var MAX_PATH_LENGTH = 240;
 var WINDOWS_ABSOLUTE_PATH_LIMIT = 259;
 async function runPathTooLong(input) {
@@ -2868,10 +3069,10 @@ async function fixPathTooLong(input) {
     }
     try {
       if (target.mode === "dedupe") {
-        await unlink2(join11(input.vault, violation.relPath));
+        await unlink2(join12(input.vault, violation.relPath));
       } else {
-        await mkdir4(dirname5(join11(input.vault, target.relPath)), { recursive: true });
-        await rename3(join11(input.vault, violation.relPath), join11(input.vault, target.relPath));
+        await mkdir4(dirname5(join12(input.vault, target.relPath)), { recursive: true });
+        await rename3(join12(input.vault, violation.relPath), join12(input.vault, target.relPath));
       }
       fixed.push({ from: violation.relPath, to: target.relPath });
     } catch {
@@ -2950,9 +3151,9 @@ function truncateFilename(relPath, maxLength = MAX_PATH_LENGTH) {
 async function resolveFixTarget(vault, original, preferred, maxLength) {
   for (const candidate of candidateRelPaths(preferred, maxLength)) {
     if (candidate === original || candidate.length > maxLength) continue;
-    const candidatePath = join11(vault, candidate);
+    const candidatePath = join12(vault, candidate);
     if (!existsSync3(candidatePath)) return { relPath: candidate, mode: "rename" };
-    if (await hasSameContent(join11(vault, original), candidatePath)) {
+    if (await hasSameContent(join12(vault, original), candidatePath)) {
       return { relPath: candidate, mode: "dedupe" };
     }
   }
@@ -2996,15 +3197,91 @@ function replacePathReferences(content, oldRelPath, newRelPath) {
     const stemWikilinkRe = new RegExp(`\\[\\[${oldStemEscaped}(\\|[^\\]]*)?\\]\\]`, "g");
     updated = updated.replace(stemWikilinkRe, (_match, alias) => `[[${newStem}${alias ?? ""}]]`);
   }
-  return updated;
-}
-function computeShortHash(input) {
-  let hash = 2166136261;
-  for (let i = 0; i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
+  return updated;
+}
+function computeShortHash(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0").slice(0, 8);
+}
+
+// src/commands/frontmatter-fix.ts
+function isoToday() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function fixFrontmatter(rawFm) {
+  const additions = [];
+  if (!/^created:/m.test(rawFm)) additions.push(`created: ${isoToday()}`);
+  if (!/^updated:/m.test(rawFm)) additions.push(`updated: ${isoToday()}`);
+  if (!/^tags:/m.test(rawFm)) additions.push("tags: []");
+  if (!/^sources:/m.test(rawFm)) additions.push("sources: []");
+  if (!/^provenance:/m.test(rawFm)) additions.push("provenance: research");
+  if (additions.length === 0) return rawFm;
+  return rawFm.trimEnd() + "\n" + additions.join("\n") + "\n";
+}
+function removeOrphanTagsLines(body) {
+  return body.split("\n").filter((line) => !/^tags:\s*\[/.test(line.trim())).join("\n");
+}
+async function runFrontmatterFix(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const fixed = [];
+  const skipped = [];
+  let unchanged = 0;
+  for (const page of scan.data.typedKnowledge) {
+    const text = await readPage(page);
+    const split = splitFrontmatter(text);
+    if (!split.ok) {
+      skipped.push(page.relPath);
+      continue;
+    }
+    const { rawFrontmatter, body } = split.data;
+    const newFm = fixFrontmatter(rawFrontmatter);
+    const newBody = removeOrphanTagsLines(body);
+    const newText = `---
+${newFm}
+---
+${newBody}`;
+    if (newText === text) {
+      unchanged++;
+      continue;
+    }
+    if (!input.dryRun) {
+      const w = await safeWritePage(page.absPath, newText);
+      if (!w.ok) {
+        skipped.push(page.relPath);
+        continue;
+      }
+    }
+    fixed.push(page.relPath);
+  }
+  const exitCode = fixed.length > 0 ? ExitCode.MIGRATION_APPLIED : ExitCode.OK;
+  const hintLines = [`scanned: ${fixed.length + skipped.length + unchanged}`];
+  if (fixed.length > 0) hintLines.push(`fixed: ${fixed.length}`);
+  if (skipped.length > 0) hintLines.push(`skipped (parse error): ${skipped.length}`);
+  if (unchanged > 0) hintLines.push(`unchanged: ${unchanged}`);
+  if (input.dryRun && fixed.length > 0) hintLines.push("(dry run \u2014 no files written)");
+  if (!input.dryRun && fixed.length > 0) {
+    appendLastOp(input.vault, {
+      operation: "frontmatter-fix",
+      summary: `normalized frontmatter on ${fixed.length} page(s)`,
+      files: fixed,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
-  return (hash >>> 0).toString(16).padStart(8, "0").slice(0, 8);
+  return {
+    exitCode,
+    result: ok({
+      scanned: fixed.length + skipped.length + unchanged,
+      fixed,
+      skipped,
+      unchanged,
+      humanHint: hintLines.join("\n")
+    })
+  };
 }
 
 // src/utils/cli-surface.ts
@@ -3018,8 +3295,10 @@ function buildCliSurface() {
   program.command("validate").option("--apply").option("--vault <dir>").option("--wiki <name>");
   program.command("graph");
   program.command("canvas");
+  program.command("eval").option("--base <git-ref>").option("--top <n>").option("--wiki <name>");
   program.command("overlap").option("--wiki <name>");
-  program.command("query").option("--limit <n>").option("--include-pending").option("--wiki <name>");
+  program.command("query").option("--limit <n>").option("--include-pending").option("--hybrid").option("--wiki <name>");
+  program.command("vectors");
   program.command("sources");
   program.command("orphans").option("--wiki <name>");
   program.command("audit");
@@ -3049,7 +3328,7 @@ function buildCliSurface() {
   program.command("status").option("--wiki <name>");
   program.command("archive").option("--wiki <name>").option("--cascade").option("--apply").option("--approve <token>").option("--remote <remote>").option("--remote-delete").option("--max-remote-deletes <n>");
   program.command("remove").option("--wiki <name>").option("--remote <remote>").option("--remote-delete").option("--max-remote-deletes <n>").option("--reason <text>");
-  program.command("drift").option("--apply").option("--new <date>").option("--wiki <name>");
+  program.command("drift").option("--apply").option("--affected-pages").option("--new <date>").option("--wiki <name>");
   program.command("dedup").option("--apply").option("--approve <token>").option("--canonical-policy <policy>").option("--manifest-out <path>").option("--manifest-in <path>").option("--remote <remote>").option("--remote-delete").option("--max-remote-deletes <n>").option("--wiki <name>");
   program.command("migrate-citations").option("--dry-run").option("--wiki <name>");
   program.command("frontmatter-fix").option("--dry-run").option("--wiki <name>");
@@ -3076,9 +3355,22 @@ function buildCliSurface() {
   program.command("mcp");
   const graphCmd = program.commands.find((c) => c.name() === "graph");
   graphCmd.command("build").option("--out <path>").option("--wiki <name>");
+  const vectorsCmd = program.commands.find((c) => c.name() === "vectors");
+  vectorsCmd.command("rebuild").option("--wiki <name>");
+  vectorsCmd.command("status").option("--wiki <name>");
+  vectorsCmd.command("reindex-page").option("--wiki <name>");
+  vectorsCmd.command("prune-page").option("--dry-run").option("--wiki <name>");
   const sourcesCmd = program.commands.find((c) => c.name() === "sources");
   sourcesCmd.command("pending").option("--since <date>").option("--older-than <days>").option("--match <text>").option("--ingested-by <channel>").option("--scope <scope>").option("--sort <order>").option("--limit <n>").option("--all").option("--include-integrated").option("--include-archived").option("--include-duplicates").option("--include-legacy-archived").option("--wiki <name>");
+  sourcesCmd.command("skipped").option("--wiki <name>");
   sourcesCmd.command("disposition").requiredOption("--status <status>").requiredOption("--reason <text>").option("--review-after <date>").option("--duplicate-of <raw-path>").option("--write").option("--approve <token>").option("--wiki <name>");
+  const sourcesCompileCmd = sourcesCmd.command("compile");
+  sourcesCompileCmd.command("claim").requiredOption("--reason <text>").option("--write").option("--approve <token>").option("--wiki <name>");
+  sourcesCompileCmd.command("release").requiredOption("--reason <text>").option("--write").option("--approve <token>").option("--wiki <name>");
+  sourcesCompileCmd.command("published").requiredOption("--pages <paths>").requiredOption("--reason <text>").option("--write").option("--approve <token>").option("--wiki <name>");
+  sourcesCompileCmd.command("status").option("--wiki <name>");
+  sourcesCmd.command("review").requiredOption("--status <status>").requiredOption("--reason <text>").option("--write").option("--approve <token>").option("--wiki <name>");
+  sourcesCmd.command("reviews").option("--wiki <name>");
   sourcesCmd.command("dispose").requiredOption("--reason <text>").option("--write").option("--approve <token>").option("--wiki <name>");
   const canvasCmd = program.commands.find((c) => c.name() === "canvas");
   canvasCmd.command("generate").option("--graph-path <path>").option("--wiki <name>");
@@ -3254,275 +3546,50 @@ function compatible(left, right) {
 }
 function hasAnyIncompatibleSignals(leftSignals, rightSignals) {
   if (leftSignals.length === 0 || rightSignals.length === 0) return false;
-  return leftSignals.some((left) => rightSignals.some((right) => !compatible(left, right)));
-}
-function hasAnyCompatibleSignals(leftSignals, rightSignals) {
-  return leftSignals.some((left) => rightSignals.some((right) => compatible(left, right)));
-}
-function assessSourceIdentity(input) {
-  const pathSignals = collectSignals(input.rawPath);
-  const sourceSignals = collectSignals(input.sourceUrl ?? "");
-  const bodySignals = collectSignals(firstBodyWindow(input.body));
-  const reasons = [];
-  if (hasAnyIncompatibleSignals(pathSignals, sourceSignals)) {
-    reasons.push(`filename/path signals [${pathSignals.join(", ")}] but source_url signals [${sourceSignals.join(", ")}]`);
-  }
-  if (pathSignals.length > 0 && bodySignals.length > 0 && !hasAnyCompatibleSignals(pathSignals, bodySignals)) {
-    reasons.push(`filename/path signals [${pathSignals.join(", ")}] but body signals [${bodySignals.join(", ")}]`);
-  }
-  if (reasons.length > 0) {
-    return { status: "conflict", pathSignals, sourceSignals, bodySignals, reasons };
-  }
-  if (pathSignals.length === 0 && sourceSignals.length > 0 && bodySignals.length > 0 && !hasAnyCompatibleSignals(sourceSignals, bodySignals)) {
-    return {
-      status: "suspicious",
-      pathSignals,
-      sourceSignals,
-      bodySignals,
-      reasons: [`source_url signals [${sourceSignals.join(", ")}] but body signals [${bodySignals.join(", ")}]`]
-    };
-  }
-  return { status: "ok", pathSignals, sourceSignals, bodySignals, reasons };
-}
-
-// src/commands/lint.ts
-var STRUCT_MIN_BODY_LINES = 60;
-var STRUCT_MIN_SECTIONS = 3;
-function hasDuplicateFrontmatter(body) {
-  if (/^---\r?\n/.test(body)) return true;
-  const lines = body.split(/\r?\n/);
-  const limit = Math.min(lines.length, 20);
-  let seenYamlKey = false;
-  for (let i = 0; i < limit; i++) {
-    if (/^\w[\w-]*:/.test(lines[i].trim())) seenYamlKey = true;
-    if (seenYamlKey && lines[i].trim() === "---") return true;
-  }
-  return false;
-}
-var CANONICAL_LOCAL_SOURCE_LABEL = /^\s*(?:>\s*)?(?:[-*+]\s*)?Source (?:file|inspected):/i;
-var LOCAL_ABSOLUTE_SOURCE_REF = /(?:file:\/\/(?:\/)?(?:Users|home)\/|\/(?:Users|home)\/)/;
-function hasCanonicalLocalSourceAssertion(body) {
-  const visibleBody = stripFencedBlocks(body);
-  return visibleBody.split(/\r?\n/).some(
-    (line) => CANONICAL_LOCAL_SOURCE_LABEL.test(line) && LOCAL_ABSOLUTE_SOURCE_REF.test(line)
-  );
-}
-function shouldCheckCanonicalLocalSourceAssertion(page) {
-  if (page.relPath.startsWith("raw/transcripts/")) return false;
-  if (/^projects\/[^/]+\/work\/[^/]+\/log\.md$/.test(page.relPath)) return false;
-  if (page.relPath.startsWith("raw/")) return true;
-  if (/^(entities|concepts|comparisons|queries|meta)\//.test(page.relPath)) return true;
-  if (/^projects\/[^/]+\/compound\//.test(page.relPath)) return true;
-  if (/^projects\/[^/]+\/work\/[^/]+\/(spec|plan)\.md$/.test(page.relPath)) return true;
-  return false;
-}
-function extractSourceEntries(rawFm) {
-  const lines = rawFm.split(/\r?\n/);
-  const sourcesLineIdx = lines.findIndex((l) => /^sources:/.test(l));
-  if (sourcesLineIdx === -1) return [];
-  const sourcesLine = lines[sourcesLineIdx].trim();
-  const inlineMatch = sourcesLine.match(/^sources:\s*\[(.+)]\s*$/);
-  if (inlineMatch) {
-    return [...inlineMatch[1].matchAll(/"[^"]*"|'[^']*'|[^,\s]\S*/g)].map((m) => m[0].replace(/,\s*$/, ""));
-  }
-  const entries = [];
-  for (let i = sourcesLineIdx + 1; i < lines.length; i++) {
-    const line = lines[i];
-    if (!/^\s+- /.test(line)) break;
-    entries.push(line.replace(/^\s+- /, "").trim());
-  }
-  return entries;
-}
-var ERROR_ORDER = ["sensitive_content", "conflict_markers", "broken_wikilinks", "invalid_frontmatter", "raw_source_identity_conflict", "raw_dedup", "broken_sources", "tag_not_in_taxonomy", "path_too_long"];
-var WARNING_ORDER = ["raw_body_duplicate", "raw_subdirectory_duplicate", "file_source_url", "index_incomplete", "index_link_format", "stale_page", "page_too_large", "log_rotate_needed", "orphans", "compound_refs", "legacy_citation_style", "orphaned_citations", "duplicate_frontmatter", "frontmatter_yaml_invalid", "work_item_health", "orphaned_project_pages", "missing_overview", "missing_diagram"];
-var INFO_ORDER = ["bridges", "sparse_community", "page_structure", "topic_map_recommended", "frontmatter_wikilink", "wikilink_citation", "missing_tldr", "stale_sections", "cli_refs"];
-var KNOWN_BUCKETS = [...ERROR_ORDER, ...WARNING_ORDER, ...INFO_ORDER];
-var CLI_REFS_TYPED_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
-function shellQuote(value) {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-function formatExample(item) {
-  if (typeof item === "string") return item;
-  if (item === null || item === void 0) return String(item);
-  try {
-    return JSON.stringify(item);
-  } catch {
-    return String(item);
-  }
-}
-function summarizeBucket(bucket, severity, vaultPath, examplesLimit) {
-  const safeLimit = Math.max(0, Math.min(examplesLimit, 10));
-  const examples = bucket.items.slice(0, safeLimit).map(formatExample);
-  return {
-    kind: bucket.kind,
-    severity,
-    count: bucket.items.length,
-    examples,
-    examples_limit: safeLimit,
-    sample_truncated: bucket.items.length > examples.length,
-    details_command: `skillwiki lint ${shellQuote(vaultPath)} --only ${bucket.kind}`
-  };
-}
-function severityForBucket(kind) {
-  if (ERROR_ORDER.includes(kind)) return "error";
-  if (WARNING_ORDER.includes(kind)) return "warning";
-  return "info";
-}
-function outputForOnlyBucket(input, match, fixed, unresolved, readVault = lintReadVault(input)) {
-  const severity = severityForBucket(input.only);
-  const filtered = severity === "error" ? { error: match, warning: [], info: [] } : severity === "warning" ? { error: [], warning: match, info: [] } : { error: [], warning: [], info: match };
-  const summary = {
-    errors: filtered.error.reduce((n, b) => n + b.items.length, 0),
-    warnings: filtered.warning.reduce((n, b) => n + b.items.length, 0),
-    info: filtered.info.reduce((n, b) => n + b.items.length, 0)
-  };
-  let exitCode = ExitCode.OK;
-  if (summary.errors > 0) exitCode = ExitCode.LINT_HAS_ERRORS;
-  else if (summary.warnings > 0 || summary.info > 0) exitCode = ExitCode.LINT_HAS_WARNINGS;
-  const vault = lintVaultOutput(input, readVault);
-  const hintLines = [
-    ...readMirrorHintLines(vault),
-    `--only ${input.only}`,
-    match.length === 0 ? "0 violations" : match.map((b) => `  ${b.kind}: ${b.items.length}`).join("\n")
-  ];
-  const output = {
-    vault,
-    summary,
-    by_severity: filtered,
-    fixed,
-    unresolved,
-    humanHint: hintLines.join("\n")
-  };
-  if (input.fix) appendLintFixLastOp(input.vault, fixed);
-  return {
-    exitCode,
-    result: ok(input.summary ? summarizeLintOutput(output, input.examplesLimit) : output)
-  };
-}
-function lintReadVault(input) {
-  if (input.fix) {
-    return { readPath: input.vault, readMirror: false };
-  }
-  const resolved = resolveReadOnlyVaultRoot(input.vault);
-  return { readPath: resolved.root, readMirror: resolved.mirrored };
-}
-function lintVaultOutput(input, readVault) {
-  return {
-    path: input.vault,
-    source: input.source ?? "resolved",
-    read_path: readVault.readPath,
-    read_mirror: readVault.readMirror
-  };
-}
-function readMirrorHintLines(vault) {
-  if (!vault.read_mirror) return [];
-  return [
-    `read mirror: ${vault.read_path}`,
-    `requested vault: ${vault.path}`,
-    "if results look stale, refresh the read mirror or rerun with SKILLWIKI_DISABLE_VAULT_READ_MIRROR=1 for a live scan; live scans may be slower"
-  ];
-}
-function appendLintFixLastOp(vault, fixed) {
-  if (fixed.length === 0) return;
-  appendLastOp(vault, {
-    operation: "lint-fix",
-    summary: `fixed ${fixed.length} page(s)`,
-    files: fixed,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
-}
-function summarizeLintOutput(output, examplesLimit = 3) {
-  const buckets = [
-    ...output.by_severity.error.map((bucket) => summarizeBucket(bucket, "error", output.vault.path, examplesLimit)),
-    ...output.by_severity.warning.map((bucket) => summarizeBucket(bucket, "warning", output.vault.path, examplesLimit)),
-    ...output.by_severity.info.map((bucket) => summarizeBucket(bucket, "info", output.vault.path, examplesLimit))
-  ];
-  const lines = [];
-  lines.push(...readMirrorHintLines(output.vault));
-  lines.push(`errors: ${output.summary.errors}`);
-  lines.push(`warnings: ${output.summary.warnings}`);
-  lines.push(`info: ${output.summary.info}`);
-  for (const bucket of buckets) {
-    lines.push(`  ${bucket.kind}: ${bucket.count}`);
-    if (bucket.examples.length > 0) {
-      lines.push(`    e.g. ${bucket.examples[0]}`);
-    }
-  }
-  return {
-    vault: output.vault,
-    summary: output.summary,
-    buckets,
-    details_included: false,
-    truncated: false,
-    fixed: output.fixed,
-    unresolved: output.unresolved,
-    humanHint: lines.join("\n")
-  };
+  return leftSignals.some((left) => rightSignals.some((right) => !compatible(left, right)));
 }
-async function walkMarkdownFiles(absDir, vaultRoot) {
-  const entries = await readdir2(absDir, { withFileTypes: true });
-  const pages = [];
-  for (const entry of entries) {
-    const absPath = join12(absDir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name === ".git" || entry.name === "node_modules") continue;
-      pages.push(...await walkMarkdownFiles(absPath, vaultRoot));
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      pages.push({ absPath, relPath: relative(vaultRoot, absPath).split(sep).join("/") });
-    }
+function hasAnyCompatibleSignals(leftSignals, rightSignals) {
+  return leftSignals.some((left) => rightSignals.some((right) => compatible(left, right)));
+}
+function assessSourceIdentity(input) {
+  const pathSignals = collectSignals(input.rawPath);
+  const sourceSignals = collectSignals(input.sourceUrl ?? "");
+  const bodySignals = collectSignals(firstBodyWindow(input.body));
+  const reasons = [];
+  if (hasAnyIncompatibleSignals(pathSignals, sourceSignals)) {
+    reasons.push(`filename/path signals [${pathSignals.join(", ")}] but source_url signals [${sourceSignals.join(", ")}]`);
   }
-  return pages;
+  if (pathSignals.length > 0 && bodySignals.length > 0 && !hasAnyCompatibleSignals(pathSignals, bodySignals)) {
+    reasons.push(`filename/path signals [${pathSignals.join(", ")}] but body signals [${bodySignals.join(", ")}]`);
+  }
+  if (reasons.length > 0) {
+    return { status: "conflict", pathSignals, sourceSignals, bodySignals, reasons };
+  }
+  if (pathSignals.length === 0 && sourceSignals.length > 0 && bodySignals.length > 0 && !hasAnyCompatibleSignals(sourceSignals, bodySignals)) {
+    return {
+      status: "suspicious",
+      pathSignals,
+      sourceSignals,
+      bodySignals,
+      reasons: [`source_url signals [${sourceSignals.join(", ")}] but body signals [${bodySignals.join(", ")}]`]
+    };
+  }
+  return { status: "ok", pathSignals, sourceSignals, bodySignals, reasons };
 }
+
+// src/lint/rules.ts
 async function collectCliRefsPages(vault) {
-  if (!existsSync4(join12(vault, "SCHEMA.md"))) {
+  if (!existsSync4(join13(vault, "SCHEMA.md"))) {
     return err("VAULT_PATH_INVALID", { root: vault, reason: "SCHEMA.md missing" });
   }
   const pages = [];
   for (const dir of CLI_REFS_TYPED_DIRS) {
-    const absDir = join12(vault, dir);
+    const absDir = join13(vault, dir);
     if (!existsSync4(absDir)) continue;
     pages.push(...await walkMarkdownFiles(absDir, vault));
   }
   return ok(pages);
 }
-async function runCliRefsOnly(input) {
-  const readVault = lintReadVault(input);
-  const lintVault = readVault.readPath;
-  const pages = await collectCliRefsPages(lintVault);
-  if (!pages.ok) {
-    return { exitCode: ExitCode.VAULT_PATH_INVALID, result: pages };
-  }
-  const cliRefFlags = [];
-  const cliSurface = buildCliSurface();
-  for (const page of pages.data) {
-    const text = await readPageCached(page);
-    const violations = validateCliRefs(text, page.relPath, cliSurface);
-    for (const v of violations) {
-      cliRefFlags.push(`${v.page}: ${v.ref} (${v.reason})`);
-    }
-  }
-  const infoOut = cliRefFlags.length > 0 ? [{ kind: "cli_refs", items: cliRefFlags }] : [];
-  const summary = { errors: 0, warnings: 0, info: cliRefFlags.length };
-  const exitCode = cliRefFlags.length > 0 ? ExitCode.LINT_HAS_WARNINGS : ExitCode.OK;
-  const vault = lintVaultOutput(input, readVault);
-  const hintLines = [
-    ...readMirrorHintLines(vault),
-    `--only cli_refs`,
-    cliRefFlags.length === 0 ? "0 violations" : `  cli_refs: ${cliRefFlags.length}`
-  ];
-  const output = {
-    vault,
-    summary,
-    by_severity: { error: [], warning: [], info: infoOut },
-    fixed: [],
-    unresolved: [],
-    humanHint: hintLines.join("\n")
-  };
-  return {
-    exitCode,
-    result: ok(input.summary ? summarizeLintOutput(output, input.examplesLimit) : output)
-  };
-}
 async function collectFileSourceUrlFindings(scan, pageTextCache, options) {
   const fileSourceUrlFlags = /* @__PURE__ */ new Set();
   const fileSourceUrlFrontmatterFlags = /* @__PURE__ */ new Set();
@@ -3654,884 +3721,1466 @@ async function applyFileSourceUrlFix(input, scan, fileSourceUrlFlags, fileSource
   }
   return remaining;
 }
-async function runFileSourceUrlOnly(input) {
-  const readVault = lintReadVault(input);
-  const lintVault = readVault.readPath;
-  const scanResult = await scanVault(lintVault);
-  if (!scanResult.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scanResult };
-  const pageTextCache = /* @__PURE__ */ new Map();
-  const fixed = [];
-  const unresolved = [];
-  const findings = await collectFileSourceUrlFindings(scanResult.data, pageTextCache, { includeRawIdentityConflicts: false });
-  const remaining = await applyFileSourceUrlFix(
-    input,
-    scanResult.data,
-    findings.fileSourceUrlFlags,
-    findings.fileSourceUrlFrontmatterFlags,
-    fixed,
-    unresolved
-  );
-  const match = remaining.size > 0 ? [{ kind: "file_source_url", items: [...remaining] }] : [];
-  return outputForOnlyBucket(input, match, fixed, unresolved, readVault);
-}
-function scanConflictMarkerBlocks(path, text) {
-  const findings = [];
-  const lines = text.split(/\r?\n/);
-  let inFence = false;
-  let openLine = 0;
-  let sawSeparator = false;
-  for (let i = 0; i < lines.length; i += 1) {
-    const line = lines[i];
-    if (line.startsWith("```") || line.startsWith("~~~")) {
-      inFence = !inFence;
-      continue;
+var brokenWikilinksRule = {
+  id: "broken_wikilinks",
+  severity: "error",
+  producedBuckets: ["broken_wikilinks", "invalid_frontmatter"],
+  async run(ctx) {
+    const buckets = {};
+    const links = await runLinks({ vault: ctx.vault, scan: ctx.scan, pageTextCache: ctx.pageTextCache });
+    if (links.result.ok && links.result.data.broken.length > 0) {
+      buckets.broken_wikilinks = links.result.data.broken;
     }
-    if (inFence) continue;
-    if (line.startsWith("<<<<<<< ")) {
-      openLine = i + 1;
-      sawSeparator = false;
-      continue;
+    if (!links.result.ok && links.result.error === "INVALID_FRONTMATTER") {
+      buckets.invalid_frontmatter = [links.result.detail ?? {}];
     }
-    if (line === "=======" && openLine > 0) {
-      sawSeparator = true;
-      continue;
+    return { buckets };
+  }
+};
+var tagNotInTaxonomyRule = {
+  id: "tag_not_in_taxonomy",
+  severity: "error",
+  producedBuckets: ["tag_not_in_taxonomy", "invalid_frontmatter"],
+  async run(ctx) {
+    const buckets = {};
+    const tags = await runTagAudit({ vault: ctx.vault, scan: ctx.scan, pageTextCache: ctx.pageTextCache });
+    if (tags.result.ok && tags.result.data.violations.length > 0) {
+      buckets.tag_not_in_taxonomy = tags.result.data.violations;
+    }
+    if (!tags.result.ok && tags.result.error === "INVALID_FRONTMATTER") {
+      buckets.invalid_frontmatter = [tags.result.detail ?? {}];
+    }
+    return { buckets };
+  }
+};
+var indexIncompleteRule = {
+  id: "index_incomplete",
+  severity: "warning",
+  async run(ctx) {
+    const buckets = {};
+    const idx = await runIndexCheck({ vault: ctx.vault, scan: ctx.scan });
+    if (idx.result.ok && (idx.result.data.missing_from_index.length > 0 || idx.result.data.ghost_entries.length > 0)) {
+      buckets.index_incomplete = [
+        {
+          missing_from_index: idx.result.data.missing_from_index,
+          ghost_entries: idx.result.data.ghost_entries
+        }
+      ];
+    }
+    return { buckets };
+  }
+};
+var indexLinkFormatRule = {
+  id: "index_link_format",
+  severity: "warning",
+  async run(ctx) {
+    const buckets = {};
+    const linkFmt = await runIndexLinkFormat({ vault: ctx.vault });
+    if (linkFmt.result.ok && linkFmt.result.data.markdown_links.length > 0) {
+      buckets.index_link_format = linkFmt.result.data.markdown_links;
+    }
+    return { buckets };
+  }
+};
+var stalePageRule = {
+  id: "stale_page",
+  severity: "warning",
+  async run(ctx) {
+    const buckets = {};
+    const staleResult = await runStale({
+      vault: ctx.vault,
+      days: ctx.days,
+      scan: ctx.scan,
+      pageTextCache: ctx.pageTextCache
+    });
+    if (staleResult.result.ok) {
+      const st = staleResult.result.data;
+      const staleList = [
+        ...st.stale_transcripts.map((t) => t.path),
+        ...(st.unclaimed_transcripts ?? []).map((t) => t.path),
+        ...st.incomplete_work_items.map((w) => w.path),
+        ...(st.done_work_items ?? []).map((w) => w.path)
+      ];
+      if (staleList.length > 0) buckets.stale_page = staleList;
+    }
+    return { buckets };
+  }
+};
+var pageTooLargeRule = {
+  id: "page_too_large",
+  severity: "warning",
+  async run(ctx) {
+    const buckets = {};
+    const pagesize = await runPagesize({
+      vault: ctx.vault,
+      lines: ctx.lines,
+      scan: ctx.scan,
+      pageTextCache: ctx.pageTextCache
+    });
+    if (pagesize.result.ok && pagesize.result.data.oversized.length > 0) {
+      buckets.page_too_large = pagesize.result.data.oversized;
+    }
+    return { buckets };
+  }
+};
+var logRotateNeededRule = {
+  id: "log_rotate_needed",
+  severity: "warning",
+  async run(ctx) {
+    const buckets = {};
+    const rotate = await runLogRotate({ vault: ctx.vault, threshold: ctx.logThreshold, apply: false });
+    if (rotate.result.ok && rotate.exitCode === ExitCode.LOG_ROTATE_NEEDED) {
+      buckets.log_rotate_needed = [{ entries: rotate.result.data.entries, threshold: rotate.result.data.threshold }];
+    }
+    return { buckets };
+  }
+};
+var orphansRule = {
+  id: "orphans",
+  severity: "warning",
+  producedBuckets: ["orphans", "bridges"],
+  async run(ctx) {
+    const buckets = {};
+    const orphans = await runOrphans({ vault: ctx.vault, scan: ctx.scan, pageTextCache: ctx.pageTextCache });
+    if (orphans.result.ok) {
+      if (orphans.result.data.orphans.length > 0) buckets.orphans = orphans.result.data.orphans;
+      if (orphans.result.data.bridges.length > 0) buckets.bridges = orphans.result.data.bridges;
+    }
+    return { buckets };
+  }
+};
+var sparseCommunityRule = {
+  id: "sparse_community",
+  severity: "info",
+  async run(ctx) {
+    const buckets = {};
+    const sparse = await runSparseCommunity({ vault: ctx.vault, scan: ctx.scan, pageTextCache: ctx.pageTextCache });
+    if (sparse.result.ok && sparse.result.data.communities.length > 0) {
+      buckets.sparse_community = sparse.result.data.communities;
+    }
+    return { buckets };
+  }
+};
+var topicMapRecommendedRule = {
+  id: "topic_map_recommended",
+  severity: "info",
+  async run(ctx) {
+    const buckets = {};
+    const topicMap = await runTopicMapCheck({ vault: ctx.vault, scan: ctx.scan });
+    if (topicMap.result.ok && topicMap.result.data.recommended) {
+      buckets.topic_map_recommended = [
+        { page_count: topicMap.result.data.page_count, threshold: topicMap.result.data.threshold }
+      ];
+    }
+    return { buckets };
+  }
+};
+var rawDedupRule = {
+  id: "raw_dedup",
+  severity: "error",
+  async run(ctx) {
+    const buckets = {};
+    const dedup = await runDedup({ vault: ctx.vault, scan: ctx.scan, pageTextCache: ctx.pageTextCache });
+    if (dedup.result.ok && dedup.result.data.duplicates.length > 0) {
+      buckets.raw_dedup = dedup.result.data.duplicates;
+    }
+    return { buckets };
+  }
+};
+var rawBodyDuplicateRule = {
+  id: "raw_body_duplicate",
+  severity: "warning",
+  async run(ctx) {
+    const buckets = {};
+    const bodyDedup = await runRawBodyDedup(ctx.vault, ctx.scan, ctx.pageTextCache);
+    if (bodyDedup.result.ok && bodyDedup.result.data.duplicates.length > 0) {
+      buckets.raw_body_duplicate = bodyDedup.result.data.duplicates.map((d) => ({
+        body_hash: d.bodyHash.slice(0, 12),
+        files: d.files.map((f) => `${f.relPath} (sha256: ${f.sha256 ?? "none"})`)
+      }));
+    }
+    return { buckets };
+  }
+};
+var compoundRefsRule = {
+  id: "compound_refs",
+  severity: "warning",
+  async run(ctx) {
+    const buckets = {};
+    const compoundRefs = await validateCompoundReferences(ctx.vault, ctx.scan, ctx.pageTextCache);
+    if (compoundRefs.ok && compoundRefs.data.length > 0) {
+      buckets.compound_refs = compoundRefs.data;
+    }
+    return { buckets };
+  }
+};
+var pathTooLongRule = {
+  id: "path_too_long",
+  severity: "error",
+  async run(ctx) {
+    const buckets = {};
+    const pathCheck = await runPathTooLong({ vault: ctx.vault, scan: ctx.scan });
+    if (pathCheck.result.ok && pathCheck.result.data.violations.length > 0) {
+      buckets.path_too_long = pathCheck.result.data.violations;
+    }
+    return { buckets };
+  },
+  async fix(ctx, currentBucketItems) {
+    const pathViolations = currentBucketItems;
+    if (!pathViolations || pathViolations.length === 0) return currentBucketItems;
+    const pathFix = await fixPathTooLong({ vault: ctx.input.vault });
+    const pathFixed = pathFix.result.ok ? pathFix.result.data.fixed.map((f) => f.from) : [];
+    if (pathFix.result.ok) ctx.unresolved.push(...pathFix.result.data.unresolved);
+    else ctx.unresolved.push(...pathViolations.map((v) => v.relPath));
+    ctx.fixed.push(...pathFixed);
+    let remaining = pathViolations;
+    if (pathFixed.length > 0) {
+      const fixedSet = new Set(pathFixed);
+      remaining = pathViolations.filter((v) => !fixedSet.has(v.relPath));
+    }
+    if (remaining && remaining.length > 0) {
+      const rawRemaining = remaining.filter((v) => v.relPath.startsWith("raw/"));
+      if (rawRemaining.length > 0) {
+        ctx.unresolved.push(...rawRemaining.map((v) => v.relPath));
+        const nonRaw = remaining.filter((v) => !v.relPath.startsWith("raw/"));
+        return nonRaw.length > 0 ? nonRaw : void 0;
+      }
+      return remaining;
+    }
+    return void 0;
+  }
+};
+var cliRefsRule = {
+  id: "cli_refs",
+  severity: "info",
+  async run(ctx) {
+    const cliRefFlags = [];
+    const allScanPages = [...ctx.scan.typedKnowledge];
+    const cliRefResults = await mapWithConcurrency(allScanPages, vaultIoConcurrency(), async (page) => {
+      const flags = [];
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const violations = validateCliRefs(text, page.relPath, ctx.cliSurface);
+        for (const v of violations) {
+          flags.push(`${v.page}: ${v.ref} (${v.reason})`);
+        }
+      } catch {
+      }
+      return flags;
+    });
+    cliRefFlags.push(...cliRefResults.flat());
+    const buckets = {};
+    if (cliRefFlags.length > 0) buckets.cli_refs = cliRefFlags;
+    return { buckets };
+  },
+  async runFastPath(input) {
+    const readVault = lintReadVault(input);
+    const lintVault = readVault.readPath;
+    const pages = await collectCliRefsPages(lintVault);
+    if (!pages.ok) {
+      return { exitCode: ExitCode.VAULT_PATH_INVALID, result: pages };
+    }
+    const cliRefFlags = [];
+    const cliSurface = buildCliSurface();
+    for (const page of pages.data) {
+      const text = await readPageCached(page);
+      const violations = validateCliRefs(text, page.relPath, cliSurface);
+      for (const v of violations) {
+        cliRefFlags.push(`${v.page}: ${v.ref} (${v.reason})`);
+      }
+    }
+    const infoOut = cliRefFlags.length > 0 ? [{ kind: "cli_refs", items: cliRefFlags }] : [];
+    const summary = { errors: 0, warnings: 0, info: cliRefFlags.length };
+    const exitCode = cliRefFlags.length > 0 ? ExitCode.LINT_HAS_WARNINGS : ExitCode.OK;
+    const vault = lintVaultOutput(input, readVault);
+    const hintLines = [
+      ...readMirrorHintLines(vault),
+      `--only cli_refs`,
+      cliRefFlags.length === 0 ? "0 violations" : `  cli_refs: ${cliRefFlags.length}`
+    ];
+    const output = {
+      vault,
+      summary,
+      by_severity: { error: [], warning: [], info: infoOut },
+      fixed: [],
+      unresolved: [],
+      humanHint: hintLines.join("\n")
+    };
+    return {
+      exitCode,
+      result: ok(input.summary ? summarizeLintOutput(output, input.examplesLimit) : output)
+    };
+  }
+};
+var fileSourceUrlRule = {
+  id: "file_source_url",
+  severity: "warning",
+  producedBuckets: ["file_source_url", "raw_source_identity_conflict"],
+  async run(ctx) {
+    if (!ctx.parsedPagesCache) ctx.parsedPagesCache = {};
+    if (!ctx.parsedPagesCache.fileSourceUrlFindings) {
+      ctx.parsedPagesCache.fileSourceUrlFindings = await collectFileSourceUrlFindings(ctx.scan, ctx.pageTextCache, {
+        includeRawIdentityConflicts: true
+      });
+    }
+    const findings = ctx.parsedPagesCache.fileSourceUrlFindings;
+    const buckets = {};
+    if (findings.fileSourceUrlFlags.size > 0) {
+      buckets.file_source_url = [...findings.fileSourceUrlFlags];
+    }
+    if (findings.rawIdentityConflicts.length > 0) {
+      buckets.raw_source_identity_conflict = findings.rawIdentityConflicts;
+    }
+    return { buckets };
+  },
+  async runFastPath(input) {
+    const readVault = lintReadVault(input);
+    const lintVault = readVault.readPath;
+    const scanResult = await scanVault(lintVault);
+    if (!scanResult.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scanResult };
+    const pageTextCache = /* @__PURE__ */ new Map();
+    const fixed = [];
+    const unresolved = [];
+    const findings = await collectFileSourceUrlFindings(scanResult.data, pageTextCache, {
+      includeRawIdentityConflicts: false
+    });
+    const remaining = await applyFileSourceUrlFix(
+      input,
+      scanResult.data,
+      findings.fileSourceUrlFlags,
+      findings.fileSourceUrlFrontmatterFlags,
+      fixed,
+      unresolved
+    );
+    const match = remaining.size > 0 ? [{ kind: "file_source_url", items: [...remaining] }] : [];
+    return outputForOnlyBucket(input, match, fixed, unresolved, readVault);
+  },
+  async fix(ctx, currentBucketItems) {
+    const findings = ctx.pageTextCache ? await collectFileSourceUrlFindings(ctx.scan, ctx.pageTextCache, { includeRawIdentityConflicts: false }) : { fileSourceUrlFlags: /* @__PURE__ */ new Set(), fileSourceUrlFrontmatterFlags: /* @__PURE__ */ new Set(), rawIdentityConflicts: [] };
+    const remaining = await applyFileSourceUrlFix(
+      ctx.input,
+      ctx.scan,
+      findings.fileSourceUrlFlags,
+      findings.fileSourceUrlFrontmatterFlags,
+      ctx.fixed,
+      ctx.unresolved
+    );
+    return remaining.size > 0 ? [...remaining] : void 0;
+  }
+};
+var sensitiveContentRule = {
+  id: "sensitive_content",
+  severity: "error",
+  async run(ctx) {
+    const sensitiveFlags = [];
+    await mapWithConcurrency(ctx.scan.allMarkdown, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        sensitiveFlags.push(...scanSensitiveContent(text, { file: page.relPath }));
+      } catch {
+      }
+    });
+    const buckets = {};
+    if (sensitiveFlags.length > 0) buckets.sensitive_content = sensitiveFlags;
+    return { buckets };
+  },
+  async fix(ctx, currentBucketItems) {
+    const sensitiveFixed = [];
+    for (const page of ctx.scan.allMarkdown) {
+      try {
+        const raw = await readPage(page);
+        const redacted = redactSensitiveContent(raw, { file: page.relPath });
+        if (!redacted.changed) continue;
+        if (page.relPath.startsWith("raw/")) {
+          ctx.unresolved.push(page.relPath);
+          continue;
+        }
+        const w = await safeWritePage(page.absPath, redacted.text, { minBodyRatio: null });
+        if (!w.ok) {
+          ctx.unresolved.push(page.relPath);
+          continue;
+        }
+        sensitiveFixed.push(page.relPath);
+      } catch {
+        ctx.unresolved.push(page.relPath);
+      }
+    }
+    ctx.fixed.push(...sensitiveFixed);
+    const remainingSensitiveFlags = [];
+    for (const page of ctx.scan.allMarkdown) {
+      try {
+        const text = await readPage(page);
+        remainingSensitiveFlags.push(...scanSensitiveContent(text, { file: page.relPath }));
+      } catch {
+      }
+    }
+    return remainingSensitiveFlags.length > 0 ? remainingSensitiveFlags : void 0;
+  }
+};
+var conflictMarkersRule = {
+  id: "conflict_markers",
+  severity: "error",
+  async run(ctx) {
+    const conflictMarkers = [];
+    await mapWithConcurrency(ctx.scan.allMarkdown, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const lines = text.split(/\r?\n/);
+        let inFence = false;
+        let openLine = 0;
+        let sawSeparator = false;
+        for (let i = 0; i < lines.length; i += 1) {
+          const line = lines[i];
+          if (line.startsWith("```") || line.startsWith("~~~")) {
+            inFence = !inFence;
+            continue;
+          }
+          if (inFence) continue;
+          if (line.startsWith("<<<<<<< ")) {
+            openLine = i + 1;
+            sawSeparator = false;
+            continue;
+          }
+          if (line === "=======" && openLine > 0) {
+            sawSeparator = true;
+            continue;
+          }
+          if (line.startsWith(">>>>>>> ")) {
+            if (openLine > 0 && sawSeparator) {
+              conflictMarkers.push({ path: page.relPath, line: openLine, message: "complete Git conflict-marker block" });
+            }
+            openLine = 0;
+            sawSeparator = false;
+          }
+        }
+      } catch {
+      }
+    });
+    const buckets = {};
+    if (conflictMarkers.length > 0) buckets.conflict_markers = conflictMarkers;
+    return { buckets };
+  }
+};
+var frontmatterYamlInvalidRule = {
+  id: "frontmatter_yaml_invalid",
+  severity: "warning",
+  async run(ctx) {
+    const fmYamlInvalid = [];
+    await mapWithConcurrency(ctx.scan.allMarkdown, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const fm = extractFrontmatter(text);
+        if (!fm.ok && fm.error === "INVALID_FRONTMATTER") {
+          const detail = fm.detail;
+          const message = detail?.message ?? "invalid YAML";
+          fmYamlInvalid.push({ path: page.relPath, message });
+        }
+      } catch {
+      }
+    });
+    const buckets = {};
+    if (fmYamlInvalid.length > 0) buckets.frontmatter_yaml_invalid = fmYamlInvalid;
+    return { buckets };
+  },
+  async fix(ctx, currentBucketItems) {
+    const invalidItems = currentBucketItems;
+    if (!invalidItems) return currentBucketItems;
+    const remaining = [];
+    for (const item of invalidItems) {
+      if (item.path.startsWith("raw/")) {
+        ctx.unresolved.push(item.path);
+        remaining.push(item);
+        continue;
+      }
+      const page = ctx.scan.allMarkdown.find((p) => p.relPath === item.path);
+      if (!page) {
+        ctx.unresolved.push(item.path);
+        remaining.push(item);
+        continue;
+      }
+      try {
+        const text = await readPage(page);
+        const split = splitFrontmatter(text);
+        if (!split.ok) {
+          ctx.unresolved.push(item.path);
+          remaining.push(item);
+          continue;
+        }
+        const newFm = fixFrontmatter(split.data.rawFrontmatter);
+        const newText = `---
+${newFm}
+---
+${split.data.body}`;
+        const recheck = extractFrontmatter(newText);
+        if (!recheck.ok) {
+          ctx.unresolved.push(item.path);
+          remaining.push(item);
+          continue;
+        }
+        const w = await safeWritePage(page.absPath, newText, { minBodyRatio: null });
+        if (!w.ok) {
+          ctx.unresolved.push(item.path);
+          remaining.push(item);
+          continue;
+        }
+        ctx.fixed.push(item.path);
+      } catch {
+        ctx.unresolved.push(item.path);
+        remaining.push(item);
+      }
+    }
+    return remaining.length > 0 ? remaining : void 0;
+  }
+};
+var rawSubdirectoryDuplicateRule = {
+  id: "raw_subdirectory_duplicate",
+  severity: "warning",
+  async run(ctx) {
+    const subDirDupes = [];
+    const flatStems = /* @__PURE__ */ new Map();
+    const deepFiles = [];
+    for (const raw of ctx.scan.raw) {
+      const parts = raw.relPath.split("/");
+      if (parts.length === 3) {
+        const stem = parts[2].replace(/\.md$/, "");
+        flatStems.set(`${parts[1]}/${stem}`, raw.relPath);
+      } else if (parts.length > 3) {
+        const stem = parts[parts.length - 1].replace(/\.md$/, "");
+        deepFiles.push({ relPath: raw.relPath, stem, parentType: parts[1] });
+      }
+    }
+    for (const df of deepFiles) {
+      const flatPath = flatStems.get(`${df.parentType}/${df.stem}`);
+      if (flatPath) {
+        subDirDupes.push(`${df.relPath} -> duplicate of ${flatPath}`);
+      }
     }
-    if (line.startsWith(">>>>>>> ")) {
-      if (openLine > 0 && sawSeparator) {
-        findings.push({ path, line: openLine, message: "complete Git conflict-marker block" });
+    const buckets = {};
+    if (subDirDupes.length > 0) buckets.raw_subdirectory_duplicate = subDirDupes;
+    return { buckets };
+  }
+};
+var legacyCitationStyleRule = {
+  id: "legacy_citation_style",
+  severity: "warning",
+  async run(ctx) {
+    const legacyPages = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const split = splitFrontmatter(text);
+        if (!split.ok) return;
+        if (isLegacyCitationStyle(split.data.body)) legacyPages.push(page.relPath);
+      } catch {
+      }
+    });
+    const buckets = {};
+    if (legacyPages.length > 0) buckets.legacy_citation_style = legacyPages;
+    return { buckets };
+  },
+  async fix(ctx, currentBucketItems) {
+    const legacyPages = currentBucketItems;
+    if (!legacyPages || legacyPages.length === 0) return currentBucketItems;
+    const FENCE_RE = /```[\s\S]*?```/g;
+    const INLINE_MARKER = /\^\[raw\/[^\]]+\]/g;
+    const fixedHere = [];
+    for (const relPath of legacyPages) {
+      try {
+        const absPath = `${ctx.input.vault}/${relPath}`;
+        const raw = await readFile13(absPath, "utf8");
+        const split = splitFrontmatter(raw);
+        if (!split.ok) {
+          ctx.unresolved.push(relPath);
+          continue;
+        }
+        const body = split.data.body;
+        const rawFm = split.data.rawFrontmatter;
+        const stripped = body.replace(FENCE_RE, "");
+        const lines = stripped.split("\n");
+        const inlineMarkers = [];
+        let inSources = false;
+        for (const line of lines) {
+          if (/^## Sources\b/.test(line.trim())) {
+            inSources = true;
+            continue;
+          }
+          if (inSources) continue;
+          for (const m of line.matchAll(INLINE_MARKER)) {
+            inlineMarkers.push(m[0]);
+          }
+        }
+        if (inlineMarkers.length === 0) {
+          ctx.unresolved.push(relPath);
+          continue;
+        }
+        const bodyLines = body.split("\n");
+        let inSrc = false;
+        const newBodyLines = [];
+        for (const line of bodyLines) {
+          if (/^## Sources\b/.test(line.trim())) {
+            inSrc = true;
+            newBodyLines.push(line);
+            continue;
+          }
+          if (inSrc) {
+            newBodyLines.push(line);
+            continue;
+          }
+          INLINE_MARKER.lastIndex = 0;
+          const lineWithoutMarkers = line.replace(INLINE_MARKER, "").trim();
+          INLINE_MARKER.lastIndex = 0;
+          if (lineWithoutMarkers.length === 0 && INLINE_MARKER.test(line)) {
+            continue;
+          }
+          let cleaned = line;
+          for (const marker of inlineMarkers) {
+            const escapedMarker = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const trailingRe = new RegExp(`([.!?]\\s*)${escapedMarker}`);
+            if (trailingRe.test(cleaned)) {
+              cleaned = cleaned.replace(trailingRe, "$1");
+            }
+            const midRe = new RegExp(`${escapedMarker}\\s*`);
+            if (midRe.test(cleaned)) {
+              cleaned = cleaned.replace(midRe, "");
+            }
+          }
+          newBodyLines.push(cleaned);
+        }
+        let newBody = newBodyLines.join("\n");
+        const dedupedMarkers = [...new Set(inlineMarkers)];
+        if (inSrc) {
+          const existingSources = new Set(
+            body.split("\n").filter((l) => /^- \^\[raw\//.test(l.trim())).map((l) => l.trim().replace(/^- /, ""))
+          );
+          const newMarkers = dedupedMarkers.filter((m) => !existingSources.has(m));
+          const sourceLines = newMarkers.map((m) => `- ${m}`);
+          if (sourceLines.length > 0) {
+            newBody = newBody.trimEnd() + "\n" + sourceLines.join("\n") + "\n";
+          }
+        } else {
+          const sourceLines = dedupedMarkers.map((m) => `- ${m}`);
+          newBody = newBody.trimEnd() + "\n\n## Sources\n\n" + sourceLines.join("\n") + "\n";
+        }
+        const newContent = `---
+${rawFm}
+---
+${newBody}`;
+        const w = await safeWritePage(absPath, newContent);
+        if (!w.ok) {
+          ctx.unresolved.push(relPath);
+          continue;
+        }
+        fixedHere.push(relPath);
+      } catch {
+        ctx.unresolved.push(relPath);
       }
-      openLine = 0;
-      sawSeparator = false;
     }
+    ctx.fixed.push(...fixedHere);
+    if (fixedHere.length > 0) {
+      const fixedSet = new Set(fixedHere);
+      const remaining = legacyPages.filter((p) => !fixedSet.has(p));
+      return remaining.length > 0 ? remaining : void 0;
+    }
+    return currentBucketItems;
   }
-  return findings;
-}
-async function runLint(input) {
-  if (input.only && !KNOWN_BUCKETS.includes(input.only)) {
-    return {
-      exitCode: ExitCode.USAGE,
-      result: { ok: false, error: "UNKNOWN_BUCKET", detail: `Unknown bucket "${input.only}". Valid: ${KNOWN_BUCKETS.join(", ")}` }
-    };
-  }
-  if (input.only === "cli_refs") {
-    return runCliRefsOnly(input);
+};
+var orphanedCitationsRule = {
+  id: "orphaned_citations",
+  severity: "warning",
+  async run(ctx) {
+    const orphanedPages = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const split = splitFrontmatter(text);
+        if (split.ok && hasOrphanedCitations(split.data.body)) orphanedPages.push(page.relPath);
+      } catch {
+      }
+    });
+    const buckets = {};
+    if (orphanedPages.length > 0) buckets.orphaned_citations = orphanedPages;
+    return { buckets };
   }
-  if (input.only === "file_source_url") {
-    return runFileSourceUrlOnly(input);
+};
+var pageStructureRule = {
+  id: "page_structure",
+  severity: "info",
+  async run(ctx) {
+    const structFlags = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const split = splitFrontmatter(text);
+        if (!split.ok) return;
+        const body = split.data.body;
+        const bodyLines = body.split("\n").filter((l) => l.trim().length > 0).length;
+        if (bodyLines < STRUCT_MIN_BODY_LINES) {
+          const hasRelated = /^## (Related|Relationships)/m.test(body);
+          const sectionCount = (body.match(/^## /gm) ?? []).length;
+          if (!hasRelated || sectionCount < STRUCT_MIN_SECTIONS) {
+            const reasons = [];
+            if (!hasRelated) reasons.push("no Related or Relationships");
+            if (sectionCount < STRUCT_MIN_SECTIONS) reasons.push(`only ${sectionCount} sections`);
+            structFlags.push(`${page.relPath}: ${bodyLines} lines, ${reasons.join(", ")}`);
+          }
+        }
+      } catch {
+      }
+    });
+    const buckets = {};
+    if (structFlags.length > 0) buckets.page_structure = structFlags;
+    return { buckets };
   }
-  const shouldFix = (bucket) => !!input.fix && (!input.only || input.only === bucket);
-  const readVault = lintReadVault(input);
-  const lintVault = readVault.readPath;
-  const buckets = {};
-  const fixed = [];
-  const unresolved = [];
-  const scanResult = await scanVault(lintVault);
-  if (!scanResult.ok) {
-    return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scanResult };
+};
+var duplicateFrontmatterRule = {
+  id: "duplicate_frontmatter",
+  severity: "warning",
+  async run(ctx) {
+    const dupFrontmatter = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const split = splitFrontmatter(text);
+        if (split.ok && hasDuplicateFrontmatter(split.data.body)) dupFrontmatter.push(page.relPath);
+      } catch {
+      }
+    });
+    const buckets = {};
+    if (dupFrontmatter.length > 0) buckets.duplicate_frontmatter = dupFrontmatter;
+    return { buckets };
   }
-  const scan = scanResult.data;
-  const pageTextCache = /* @__PURE__ */ new Map();
-  if (!input.fix) {
-    await mapWithConcurrency(scan.allMarkdown, vaultIoConcurrency(), async (page) => {
+};
+var missingOverviewRule = {
+  id: "missing_overview",
+  severity: "warning",
+  async run(ctx) {
+    const noOverview = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
       try {
-        await readPageCached(page, pageTextCache);
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const split = splitFrontmatter(text);
+        if (!split.ok) return;
+        if (!/^## Overview/m.test(split.data.body)) noOverview.push(page.relPath);
       } catch {
       }
     });
+    const buckets = {};
+    if (noOverview.length > 0) buckets.missing_overview = noOverview;
+    return { buckets };
+  },
+  async fix(ctx, currentBucketItems) {
+    const noOverview = currentBucketItems;
+    if (!noOverview || noOverview.length === 0) return currentBucketItems;
+    const fixedHere = [];
+    for (const relPath of noOverview) {
+      try {
+        const absPath = `${ctx.input.vault}/${relPath}`;
+        const raw = await readFile13(absPath, "utf8");
+        const split = splitFrontmatter(raw);
+        if (!split.ok) {
+          ctx.unresolved.push(relPath);
+          continue;
+        }
+        const body = split.data.body;
+        const rawFm = split.data.rawFrontmatter;
+        const fm = extractFrontmatter(raw);
+        const title = fm.ok && typeof fm.data.title === "string" ? fm.data.title : "";
+        const overviewSection = `## Overview
+
+${title}`;
+        const trimmedBody = body.replace(/^\n+/, "");
+        const newContent = `---
+${rawFm}
+---
+
+${overviewSection}
+
+${trimmedBody}`;
+        const w = await safeWritePage(absPath, newContent);
+        if (!w.ok) {
+          ctx.unresolved.push(relPath);
+          continue;
+        }
+        fixedHere.push(relPath);
+      } catch {
+        ctx.unresolved.push(relPath);
+      }
+    }
+    ctx.fixed.push(...fixedHere);
+    if (fixedHere.length > 0) {
+      const fixedSet = new Set(fixedHere);
+      const remaining = noOverview.filter((p) => !fixedSet.has(p));
+      return remaining.length > 0 ? remaining : void 0;
+    }
+    return currentBucketItems;
   }
-  const links = await runLinks({ vault: lintVault, scan, pageTextCache });
-  if (links.result.ok && links.result.data.broken.length > 0) buckets.broken_wikilinks = links.result.data.broken;
-  if (!links.result.ok && links.result.error === "INVALID_FRONTMATTER") {
-    buckets.invalid_frontmatter = [links.result.detail ?? {}];
-  }
-  const tags = await runTagAudit({ vault: lintVault, scan, pageTextCache });
-  if (tags.result.ok && tags.result.data.violations.length > 0) buckets.tag_not_in_taxonomy = tags.result.data.violations;
-  if (!tags.result.ok && tags.result.error === "INVALID_FRONTMATTER") {
-    buckets.invalid_frontmatter = [...buckets.invalid_frontmatter ?? [], tags.result.detail ?? {}];
-  }
-  const idx = await runIndexCheck({ vault: lintVault, scan });
-  if (idx.result.ok && (idx.result.data.missing_from_index.length > 0 || idx.result.data.ghost_entries.length > 0)) {
-    buckets.index_incomplete = [{
-      missing_from_index: idx.result.data.missing_from_index,
-      ghost_entries: idx.result.data.ghost_entries
-    }];
-  }
-  const linkFmt = await runIndexLinkFormat({ vault: lintVault });
-  if (linkFmt.result.ok && linkFmt.result.data.markdown_links.length > 0) {
-    buckets.index_link_format = linkFmt.result.data.markdown_links;
-  }
-  const staleResult = await runStale({ vault: lintVault, days: input.days, scan, pageTextCache });
-  if (staleResult.result.ok) {
-    const st = staleResult.result.data;
-    const staleList = [...st.stale_transcripts.map((t) => t.path), ...(st.unclaimed_transcripts ?? []).map((t) => t.path), ...st.incomplete_work_items.map((w) => w.path), ...(st.done_work_items ?? []).map((w) => w.path)];
-    if (staleList.length > 0) buckets.stale_page = staleList;
-  }
-  const pagesize = await runPagesize({ vault: lintVault, lines: input.lines, scan, pageTextCache });
-  if (pagesize.result.ok && pagesize.result.data.oversized.length > 0) buckets.page_too_large = pagesize.result.data.oversized;
-  const rotate = await runLogRotate({ vault: lintVault, threshold: input.logThreshold, apply: false });
-  if (rotate.result.ok && rotate.exitCode === ExitCode.LOG_ROTATE_NEEDED) {
-    buckets.log_rotate_needed = [{ entries: rotate.result.data.entries, threshold: rotate.result.data.threshold }];
-  }
-  const orphans = await runOrphans({ vault: lintVault, scan, pageTextCache });
-  if (orphans.result.ok) {
-    if (orphans.result.data.orphans.length > 0) buckets.orphans = orphans.result.data.orphans;
-    if (orphans.result.data.bridges.length > 0) buckets.bridges = orphans.result.data.bridges;
-  }
-  const sparse = await runSparseCommunity({ vault: lintVault, scan, pageTextCache });
-  if (sparse.result.ok && sparse.result.data.communities.length > 0) {
-    buckets.sparse_community = sparse.result.data.communities;
-  }
-  const topicMap = await runTopicMapCheck({ vault: lintVault, scan });
-  if (topicMap.result.ok && topicMap.result.data.recommended) {
-    buckets.topic_map_recommended = [{ page_count: topicMap.result.data.page_count, threshold: topicMap.result.data.threshold }];
-  }
-  const dedup = await runDedup({ vault: lintVault, scan, pageTextCache });
-  if (dedup.result.ok && dedup.result.data.duplicates.length > 0) buckets.raw_dedup = dedup.result.data.duplicates;
-  const bodyDedup = await runRawBodyDedup(lintVault, scan, pageTextCache);
-  if (bodyDedup.result.ok && bodyDedup.result.data.duplicates.length > 0) {
-    buckets.raw_body_duplicate = bodyDedup.result.data.duplicates.map((d) => ({
-      body_hash: d.bodyHash.slice(0, 12),
-      files: d.files.map((f) => `${f.relPath} (sha256: ${f.sha256 ?? "none"})`)
-    }));
-  }
-  const compoundRefs = await validateCompoundReferences(lintVault, scan, pageTextCache);
-  if (compoundRefs.ok && compoundRefs.data.length > 0) buckets.compound_refs = compoundRefs.data;
-  const pathCheck = await runPathTooLong({ vault: lintVault, scan });
-  if (pathCheck.result.ok && pathCheck.result.data.violations.length > 0) buckets.path_too_long = pathCheck.result.data.violations;
-  const wikilinkResolver = buildWikilinkResolver(scan.allMarkdown);
-  {
-    const allPageResults = await mapWithConcurrency(scan.allMarkdown, vaultIoConcurrency(), async (page) => {
-      const sensitiveFlags2 = [];
-      const conflictMarkers2 = [];
-      let fmYamlInvalid2 = null;
+};
+var frontmatterWikilinkRule = {
+  id: "frontmatter_wikilink",
+  severity: "info",
+  async run(ctx) {
+    const fmWikilinkFlags = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
       try {
-        const text = await readPageCached(page, pageTextCache);
-        sensitiveFlags2.push(...scanSensitiveContent(text, { file: page.relPath }));
-        conflictMarkers2.push(...scanConflictMarkerBlocks(page.relPath, text));
-        const fm = extractFrontmatter(text);
-        if (!fm.ok && fm.error === "INVALID_FRONTMATTER") {
-          const detail = fm.detail;
-          const message = detail?.message ?? "invalid YAML";
-          fmYamlInvalid2 = { path: page.relPath, message };
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const split = splitFrontmatter(text);
+        if (!split.ok) return;
+        const rawFm = split.data.rawFrontmatter;
+        const fmLinks = rawFm.match(/\[\[([^\[\]|]+)(?:\|[^\[\]]*)?\]\]/g) ?? [];
+        for (const link of fmLinks) {
+          const target = link.replace(/^\[\[/, "").replace(/(?:\|[^\[\]]*)?\]\]$/, "").trim();
+          if (!ctx.wikilinkResolver.resolve(target).path) {
+            fmWikilinkFlags.push(`${page.relPath}: [[${target}]] does not resolve`);
+          }
         }
       } catch {
       }
-      return { sensitiveFlags: sensitiveFlags2, conflictMarkers: conflictMarkers2, fmYamlInvalid: fmYamlInvalid2 };
     });
-    const sensitiveFlags = allPageResults.flatMap((result) => result.sensitiveFlags);
-    if (sensitiveFlags.length > 0) buckets.sensitive_content = sensitiveFlags;
-    const conflictMarkers = allPageResults.flatMap((result) => result.conflictMarkers);
-    if (conflictMarkers.length > 0) buckets.conflict_markers = conflictMarkers;
-    const fmYamlInvalid = allPageResults.map((result) => result.fmYamlInvalid).filter((item) => item !== null);
-    if (fmYamlInvalid.length > 0) buckets.frontmatter_yaml_invalid = fmYamlInvalid;
-    const subDirDupes = [];
-    const flatStems = /* @__PURE__ */ new Map();
-    const deepFiles = [];
-    for (const raw of scan.raw) {
-      const parts = raw.relPath.split("/");
-      if (parts.length === 3) {
-        const stem = parts[2].replace(/\.md$/, "");
-        flatStems.set(`${parts[1]}/${stem}`, raw.relPath);
-      } else if (parts.length > 3) {
-        const stem = parts[parts.length - 1].replace(/\.md$/, "");
-        deepFiles.push({ relPath: raw.relPath, stem, parentType: parts[1] });
+    const buckets = {};
+    if (fmWikilinkFlags.length > 0) buckets.frontmatter_wikilink = fmWikilinkFlags;
+    return { buckets };
+  }
+};
+var wikilinkCitationRule = {
+  id: "wikilink_citation",
+  severity: "info",
+  async run(ctx) {
+    const wikilinkCitationFlags = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const split = splitFrontmatter(text);
+        if (split.ok && hasWikilinkCitations(split.data.body)) wikilinkCitationFlags.push(page.relPath);
+      } catch {
       }
-    }
-    for (const df of deepFiles) {
-      const flatPath = flatStems.get(`${df.parentType}/${df.stem}`);
-      if (flatPath) {
-        subDirDupes.push(`${df.relPath} -> duplicate of ${flatPath}`);
+    });
+    const buckets = {};
+    if (wikilinkCitationFlags.length > 0) buckets.wikilink_citation = wikilinkCitationFlags;
+    return { buckets };
+  },
+  async fix(ctx, currentBucketItems) {
+    const wikilinkCitationFlags = currentBucketItems;
+    if (!wikilinkCitationFlags || wikilinkCitationFlags.length === 0) return currentBucketItems;
+    const WIKILINK_RE = /\[\[raw\/([^\]|]+)(?:\|[^\]]*)?\]\]/g;
+    const FENCE_RE = /```[\s\S]*?```/g;
+    const wikilinkFixed = [];
+    for (const relPath of wikilinkCitationFlags) {
+      try {
+        const absPath = `${ctx.input.vault}/${relPath}`;
+        const raw = await readFile13(absPath, "utf8");
+        const split = splitFrontmatter(raw);
+        if (!split.ok) {
+          ctx.unresolved.push(relPath);
+          continue;
+        }
+        const body = split.data.body;
+        const rawFm = split.data.rawFrontmatter;
+        const stripped = body.replace(FENCE_RE, "");
+        const wikilinkMatches = [...stripped.matchAll(WIKILINK_RE)];
+        if (wikilinkMatches.length === 0) {
+          ctx.unresolved.push(relPath);
+          continue;
+        }
+        const wikilinkPaths = [...new Set(wikilinkMatches.map((m) => m[1]))];
+        const bodyLines = body.split("\n");
+        let inSrc = false;
+        const newBodyLines = [];
+        for (const line of bodyLines) {
+          if (/^## Sources\b/.test(line.trim())) {
+            inSrc = true;
+            newBodyLines.push(line);
+            continue;
+          }
+          if (inSrc) {
+            newBodyLines.push(line);
+            continue;
+          }
+          let cleaned = line.replace(/\[\[raw\/[^\]|]+(?:\|[^\]]*)?\]\]/g, "");
+          cleaned = cleaned.replace(/\s+\./g, ".").replace(/\s{2,}/g, " ").replace(/\s+$/, "");
+          if (cleaned.length > 0 || line.trim().length === 0) {
+            newBodyLines.push(cleaned);
+          }
+        }
+        let newBody = newBodyLines.join("\n");
+        const citationMarkers = wikilinkPaths.map((p) => `^[raw/${p}]`);
+        const sourceEntries = extractSourceEntries(rawFm);
+        const fmMarkers = [];
+        for (const entry of sourceEntries) {
+          let rawPath = entry.replace(/^"/, "").replace(/"$/, "").replace(/^'/, "").replace(/'$/, "");
+          rawPath = rawPath.replace(/^\^\[/, "").replace(/\]$/, "");
+          if (rawPath.startsWith("raw/")) {
+            fmMarkers.push(`^[${rawPath}]`);
+          }
+        }
+        const allMarkers = [.../* @__PURE__ */ new Set([...citationMarkers, ...fmMarkers])];
+        const hasSourcesSection = /^## Sources\b/m.test(newBody);
+        if (hasSourcesSection) {
+          const existingSources = new Set(
+            newBody.split("\n").filter((l) => /^- \^\[raw\//.test(l.trim())).map((l) => l.trim().replace(/^- /, ""))
+          );
+          const newMarkers = allMarkers.filter((m) => !existingSources.has(m));
+          const sourceLines = newMarkers.map((m) => `- ${m}`);
+          if (sourceLines.length > 0) {
+            newBody = newBody.trimEnd() + "\n" + sourceLines.join("\n") + "\n";
+          }
+        } else {
+          const sourceLines = allMarkers.map((m) => `- ${m}`);
+          newBody = newBody.trimEnd() + "\n\n## Sources\n\n" + sourceLines.join("\n") + "\n";
+        }
+        const newContent = `---
+${rawFm}
+---
+${newBody}`;
+        const w = await safeWritePage(absPath, newContent);
+        if (!w.ok) {
+          ctx.unresolved.push(relPath);
+          continue;
+        }
+        wikilinkFixed.push(relPath);
+      } catch {
+        ctx.unresolved.push(relPath);
       }
     }
-    if (subDirDupes.length > 0) {
-      buckets.raw_subdirectory_duplicate = subDirDupes;
+    ctx.fixed.push(...wikilinkFixed);
+    if (wikilinkFixed.length > 0) {
+      const fixedSet = new Set(wikilinkFixed);
+      const remaining = wikilinkCitationFlags.filter((p) => !fixedSet.has(p));
+      return remaining.length > 0 ? remaining : void 0;
     }
-    const fileSourceUrlFindings = await collectFileSourceUrlFindings(scan, pageTextCache, { includeRawIdentityConflicts: true });
-    let fileSourceUrlFlags = fileSourceUrlFindings.fileSourceUrlFlags;
-    const fileSourceUrlFrontmatterFlags = fileSourceUrlFindings.fileSourceUrlFrontmatterFlags;
-    const rawIdentityConflicts = fileSourceUrlFindings.rawIdentityConflicts;
-    if (fileSourceUrlFlags.size > 0) buckets.file_source_url = [...fileSourceUrlFlags];
-    if (rawIdentityConflicts.length > 0) buckets.raw_source_identity_conflict = rawIdentityConflicts;
-    const legacyPages = [];
-    const orphanedPages = [];
-    const structFlags = [];
-    const dupFrontmatter = [];
-    const noOverview = [];
-    const fmWikilinkFlags = [];
-    const wikilinkCitationFlags = [];
+    return currentBucketItems;
+  }
+};
+var brokenSourcesRule = {
+  id: "broken_sources",
+  severity: "error",
+  async run(ctx) {
     const brokenSourceFlags = /* @__PURE__ */ new Set();
-    const missingTldrFlags = [];
-    const missingDiagramFlags = [];
-    const typedPageResults = await mapWithConcurrency(scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
-      const result = {
-        legacyPages: [],
-        orphanedPages: [],
-        structFlags: [],
-        dupFrontmatter: [],
-        noOverview: [],
-        fmWikilinkFlags: [],
-        wikilinkCitationFlags: [],
-        brokenSourceFlags: [],
-        missingTldrFlags: [],
-        missingDiagramFlags: []
-      };
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
       try {
-        const text = await readPageCached(page, pageTextCache);
+        const text = await readPageCached(page, ctx.pageTextCache);
         const split = splitFrontmatter(text);
-        if (!split.ok) return result;
+        if (!split.ok) return;
         const body = split.data.body;
         const rawFm = split.data.rawFrontmatter;
-        if (hasDuplicateFrontmatter(body)) result.dupFrontmatter.push(page.relPath);
-        if (isLegacyCitationStyle(body)) result.legacyPages.push(page.relPath);
-        if (hasOrphanedCitations(body)) result.orphanedPages.push(page.relPath);
-        if (hasWikilinkCitations(body)) result.wikilinkCitationFlags.push(page.relPath);
         const sourcesEntries = extractSourceEntries(rawFm);
         for (const entry of sourcesEntries) {
           const rawPath = normalizeRawSourceTarget(entry);
           if (!rawPath) continue;
-          if (!rawSourceTargetExistsSync(lintVault, rawPath)) {
-            result.brokenSourceFlags.push(`${page.relPath}: ${rawPath}`);
+          if (!rawSourceTargetExistsSync(ctx.vault, rawPath)) {
+            brokenSourceFlags.add(`${page.relPath}: ${rawPath}`);
           }
         }
         for (const marker of extractCitationMarkers(body)) {
-          if (!rawSourceTargetExistsSync(lintVault, marker.target)) {
-            result.brokenSourceFlags.push(`${page.relPath}: ${marker.target}`);
+          if (!rawSourceTargetExistsSync(ctx.vault, marker.target)) {
+            brokenSourceFlags.add(`${page.relPath}: ${marker.target}`);
           }
         }
-        const fmLinks = rawFm.match(/\[\[([^\[\]|]+)(?:\|[^\[\]]*)?\]\]/g) ?? [];
-        for (const link of fmLinks) {
-          const target = link.replace(/^\[\[/, "").replace(/(?:\|[^\[\]]*)?\]\]$/, "").trim();
-          if (!wikilinkResolver.resolve(target).path) {
-            result.fmWikilinkFlags.push(`${page.relPath}: [[${target}]] does not resolve`);
+      } catch {
+      }
+    });
+    const buckets = {};
+    if (brokenSourceFlags.size > 0) buckets.broken_sources = [...brokenSourceFlags];
+    return { buckets };
+  }
+};
+var missingTldrRule = {
+  id: "missing_tldr",
+  severity: "info",
+  async run(ctx) {
+    const missingTldrFlags = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const split = splitFrontmatter(text);
+        if (!split.ok) return;
+        const body = split.data.body;
+        const bodyFirst15 = body.split("\n").slice(0, 15).join("\n");
+        if (!/^>\s*\*\*TL;DR:?\*\*/m.test(bodyFirst15) && !/^##\s+TL;\s*DR/m.test(bodyFirst15)) {
+          missingTldrFlags.push(page.relPath);
+        }
+      } catch {
+      }
+    });
+    const buckets = {};
+    if (missingTldrFlags.length > 0) buckets.missing_tldr = missingTldrFlags;
+    return { buckets };
+  },
+  async fix(ctx, currentBucketItems) {
+    const missingTldrFlags = currentBucketItems;
+    if (!missingTldrFlags || missingTldrFlags.length === 0) return currentBucketItems;
+    const fixedHere = [];
+    for (const relPath of missingTldrFlags) {
+      try {
+        const absPath = `${ctx.input.vault}/${relPath}`;
+        const raw = await readFile13(absPath, "utf8");
+        const split = splitFrontmatter(raw);
+        if (!split.ok) {
+          ctx.unresolved.push(relPath);
+          continue;
+        }
+        const body = split.data.body;
+        const rawFm = split.data.rawFrontmatter;
+        const lines = body.split("\n");
+        let insertIndex = 0;
+        for (let i = 0; i < lines.length; i++) {
+          if (/^# /.test(lines[i])) {
+            insertIndex = i + 1;
+            while (insertIndex < lines.length && lines[insertIndex].trim() === "") {
+              insertIndex++;
+            }
+            break;
           }
         }
-        const bodyLines = body.split("\n").filter((l) => l.trim().length > 0).length;
-        const hasOverview = /^## Overview/m.test(body);
-        if (!hasOverview) result.noOverview.push(page.relPath);
-        const bodyFirst15 = body.split("\n").slice(0, 15).join("\n");
-        if (!/^>\s*\*\*TL;DR:?\*\*/m.test(bodyFirst15) && !/^##\s+TL;\s*DR/m.test(bodyFirst15)) result.missingTldrFlags.push(page.relPath);
+        if (insertIndex === 0) {
+          lines.splice(0, 0, "", "> **TL;DR:** ");
+        } else {
+          lines.splice(insertIndex, 0, "> **TL;DR:** ");
+        }
+        const trimmedFm = rawFm.endsWith("\n") ? rawFm : rawFm + "\n";
+        const newContent = `---
+${trimmedFm}---
+${lines.join("\n")}`;
+        const w = await safeWritePage(absPath, newContent);
+        if (!w.ok) {
+          ctx.unresolved.push(relPath);
+          continue;
+        }
+        fixedHere.push(relPath);
+      } catch {
+        ctx.unresolved.push(relPath);
+      }
+    }
+    ctx.fixed.push(...fixedHere);
+    if (fixedHere.length > 0) {
+      const fixedSet = new Set(fixedHere);
+      const remaining = missingTldrFlags.filter((p) => !fixedSet.has(p));
+      return remaining.length > 0 ? remaining : void 0;
+    }
+    return currentBucketItems;
+  }
+};
+var missingDiagramRule = {
+  id: "missing_diagram",
+  severity: "warning",
+  async run(ctx) {
+    const missingDiagramFlags = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
         const fmData = extractFrontmatter(text);
         const pageTags = fmData.ok && Array.isArray(fmData.data.tags) ? fmData.data.tags : [];
-        if (pageTags.includes("architecture") && !body.includes("```mermaid")) {
-          result.missingDiagramFlags.push(page.relPath);
-        }
-        if (bodyLines < STRUCT_MIN_BODY_LINES) {
-          const hasRelated = /^## (Related|Relationships)/m.test(body);
-          const sectionCount = (body.match(/^## /gm) ?? []).length;
-          if (!hasRelated || sectionCount < STRUCT_MIN_SECTIONS) {
-            const reasons = [];
-            if (!hasRelated) reasons.push("no Related or Relationships");
-            if (sectionCount < STRUCT_MIN_SECTIONS) reasons.push(`only ${sectionCount} sections`);
-            result.structFlags.push(`${page.relPath}: ${bodyLines} lines, ${reasons.join(", ")}`);
-          }
+        if (pageTags.includes("architecture") && !text.includes("```mermaid")) {
+          missingDiagramFlags.push(page.relPath);
         }
       } catch {
       }
-      return result;
     });
-    for (const result of typedPageResults) {
-      legacyPages.push(...result.legacyPages);
-      orphanedPages.push(...result.orphanedPages);
-      structFlags.push(...result.structFlags);
-      dupFrontmatter.push(...result.dupFrontmatter);
-      noOverview.push(...result.noOverview);
-      fmWikilinkFlags.push(...result.fmWikilinkFlags);
-      wikilinkCitationFlags.push(...result.wikilinkCitationFlags);
-      for (const flag of result.brokenSourceFlags) brokenSourceFlags.add(flag);
-      missingTldrFlags.push(...result.missingTldrFlags);
-      missingDiagramFlags.push(...result.missingDiagramFlags);
-    }
-    if (legacyPages.length > 0) buckets.legacy_citation_style = legacyPages;
-    if (orphanedPages.length > 0) buckets.orphaned_citations = orphanedPages;
-    if (structFlags.length > 0) buckets.page_structure = structFlags;
-    if (dupFrontmatter.length > 0) buckets.duplicate_frontmatter = dupFrontmatter;
-    if (noOverview.length > 0) buckets.missing_overview = noOverview;
-    if (fmWikilinkFlags.length > 0) buckets.frontmatter_wikilink = fmWikilinkFlags;
-    if (wikilinkCitationFlags.length > 0) buckets.wikilink_citation = wikilinkCitationFlags;
-    if (brokenSourceFlags.size > 0) buckets.broken_sources = [...brokenSourceFlags];
-    if (missingTldrFlags.length > 0) buckets.missing_tldr = missingTldrFlags;
+    const buckets = {};
     if (missingDiagramFlags.length > 0) buckets.missing_diagram = missingDiagramFlags;
+    return { buckets };
+  }
+};
+var workItemHealthRule = {
+  id: "work_item_health",
+  severity: "warning",
+  async run(ctx) {
     const workItemHealth = [];
     const workItemDirs = /* @__PURE__ */ new Map();
-    for (const page of scan.workItems) {
+    for (const page of ctx.scan.workItems) {
       const dir = page.relPath.replace(/\/(spec|plan|log)\.md$/, "");
       const pages = workItemDirs.get(dir) ?? [];
       pages.push(page);
       workItemDirs.set(dir, pages);
     }
-    const workItemHealthResults = await mapWithConcurrency([...workItemDirs.entries()], vaultIoConcurrency(), async ([dir, pages]) => {
-      const flags = [];
-      const specPage = pages.find((p) => p.relPath.endsWith("/spec.md"));
-      const hasPlan = pages.some((p) => p.relPath.endsWith("/plan.md"));
-      let specStatus;
-      let specStarted;
-      if (specPage) {
-        const text = await readPageCached(specPage, pageTextCache);
-        const fm = extractFrontmatter(text);
-        if (fm.ok) {
-          specStatus = typeof fm.data.status === "string" ? fm.data.status : void 0;
-          specStarted = fm.data.started;
+    const workItemHealthResults = await mapWithConcurrency(
+      [...workItemDirs.entries()],
+      vaultIoConcurrency(),
+      async ([dir, pages]) => {
+        const flags = [];
+        const specPage = pages.find((p) => p.relPath.endsWith("/spec.md"));
+        const hasPlan = pages.some((p) => p.relPath.endsWith("/plan.md"));
+        let specStatus;
+        let specStarted;
+        if (specPage) {
+          const text = await readPageCached(specPage, ctx.pageTextCache);
+          const fm = extractFrontmatter(text);
+          if (fm.ok) {
+            specStatus = typeof fm.data.status === "string" ? fm.data.status : void 0;
+            specStarted = fm.data.started;
+          }
         }
-      }
-      const isClosed = specStatus === "completed" || specStatus === "abandoned";
-      if (specPage && !hasPlan && !isClosed) {
-        const lastSegment = dir.split("/").pop();
-        const dateMatch = lastSegment.match(/^(\d{4}-\d{2}-\d{2})/);
-        if (dateMatch) {
-          const dirDate = Date.parse(dateMatch[1]);
-          if (!isNaN(dirDate) && Date.now() - dirDate > 24 * 60 * 60 * 1e3) {
-            flags.push(`${dir}/spec.md: has spec but no plan after 24h`);
+        const isClosed = specStatus === "completed" || specStatus === "abandoned";
+        if (specPage && !hasPlan && !isClosed) {
+          const lastSegment = dir.split("/").pop();
+          const dateMatch = lastSegment.match(/^(\d{4}-\d{2}-\d{2})/);
+          if (dateMatch) {
+            const dirDate = Date.parse(dateMatch[1]);
+            if (!isNaN(dirDate) && Date.now() - dirDate > 24 * 60 * 60 * 1e3) {
+              flags.push(`${dir}/spec.md: has spec but no plan after 24h`);
+            }
           }
         }
+        if (specPage && specStatus === "in-progress" && !specStarted) {
+          flags.push(`${specPage.relPath}: in-progress without started date`);
+        }
+        return flags;
       }
-      if (specPage && specStatus === "in-progress" && !specStarted) {
-        flags.push(`${specPage.relPath}: in-progress without started date`);
-      }
-      return flags;
-    });
+    );
     workItemHealth.push(...workItemHealthResults.flat());
+    const buckets = {};
     if (workItemHealth.length > 0) buckets.work_item_health = workItemHealth;
+    return { buckets };
+  }
+};
+var orphanedProjectPagesRule = {
+  id: "orphaned_project_pages",
+  severity: "warning",
+  async run(ctx) {
     const orphanedProjectPages = [];
     const knowledgeContentCache = /* @__PURE__ */ new Map();
     const readKnowledgeContent = (slug) => {
       const existing = knowledgeContentCache.get(slug);
       if (existing) return existing;
-      const knowledgePath = join12(lintVault, "projects", slug, "knowledge.md");
+      const knowledgePath = join13(ctx.vault, "projects", slug, "knowledge.md");
       const pending = existsSync4(knowledgePath) ? readFile13(knowledgePath, "utf8").catch(() => null) : Promise.resolve(null);
       knowledgeContentCache.set(slug, pending);
       return pending;
     };
-    const orphanedProjectPageResults = await mapWithConcurrency(scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
-      const flags = [];
-      try {
-        const text = await readPageCached(page, pageTextCache);
-        const fm = extractFrontmatter(text);
-        if (!fm.ok) return flags;
-        const pp = fm.data.provenance_projects;
-        if (!Array.isArray(pp)) return flags;
-        for (const entry of pp) {
-          const slugMatch = String(entry).match(/\[\[([^\]]+)\]\]/);
-          if (!slugMatch) continue;
-          const slug = slugMatch[1];
-          const knowledgeContent = await readKnowledgeContent(slug);
-          if (knowledgeContent === null) continue;
-          const pageRef = page.relPath.replace(/\.md$/, "");
-          if (!knowledgeContent.includes(`[[${pageRef}]]`)) {
-            flags.push(`${page.relPath}: not in projects/${slug}/knowledge.md`);
-          }
-        }
-      } catch {
-      }
-      return flags;
-    });
-    orphanedProjectPages.push(...orphanedProjectPageResults.flat());
-    if (orphanedProjectPages.length > 0) buckets.orphaned_project_pages = orphanedProjectPages;
-    const cliRefFlags = [];
-    const cliSurface = buildCliSurface();
-    const allScanPages = [...scan.typedKnowledge];
-    const cliRefResults = await mapWithConcurrency(allScanPages, vaultIoConcurrency(), async (page) => {
-      const flags = [];
-      try {
-        const text = await readPageCached(page, pageTextCache);
-        const violations = validateCliRefs(text, page.relPath, cliSurface);
-        for (const v of violations) {
-          flags.push(`${v.page}: ${v.ref} (${v.reason})`);
+    const orphanedProjectPageResults = await mapWithConcurrency(
+      ctx.scan.typedKnowledge,
+      vaultIoConcurrency(),
+      async (page) => {
+        const flags = [];
+        try {
+          const text = await readPageCached(page, ctx.pageTextCache);
+          const fm = extractFrontmatter(text);
+          if (!fm.ok) return flags;
+          const pp = fm.data.provenance_projects;
+          if (!Array.isArray(pp)) return flags;
+          for (const entry of pp) {
+            const slugMatch = String(entry).match(/\[\[([^\]]+)\]\]/);
+            if (!slugMatch) continue;
+            const slug = slugMatch[1];
+            const knowledgeContent = await readKnowledgeContent(slug);
+            if (knowledgeContent === null) continue;
+            const pageRef = page.relPath.replace(/\.md$/, "");
+            if (!knowledgeContent.includes(`[[${pageRef}]]`)) {
+              flags.push(`${page.relPath}: not in projects/${slug}/knowledge.md`);
+            }
+          }
+        } catch {
         }
-      } catch {
+        return flags;
       }
-      return flags;
-    });
-    cliRefFlags.push(...cliRefResults.flat());
-    if (cliRefFlags.length > 0) buckets.cli_refs = cliRefFlags;
+    );
+    orphanedProjectPages.push(...orphanedProjectPageResults.flat());
+    const buckets = {};
+    if (orphanedProjectPages.length > 0) buckets.orphaned_project_pages = orphanedProjectPages;
+    return { buckets };
+  }
+};
+var staleSectionsRule = {
+  id: "stale_sections",
+  severity: "info",
+  async run(ctx) {
     const staleSectionFlags = [];
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const approachingThreshold = 7;
-    const staleSectionResults = await mapWithConcurrency(scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
-      const flags = [];
-      try {
-        const text = await readPageCached(page, pageTextCache);
-        const annotations = parseExpiryAnnotations(text, page.relPath);
-        for (const ann of annotations) {
-          if (ann.expires < today) {
-            flags.push(`${page.relPath}: section "${ann.heading}" expired on ${ann.expires}`);
-          } else {
-            const daysUntilExpiry = Math.floor((Date.parse(ann.expires) - Date.now()) / 864e5);
-            if (daysUntilExpiry <= approachingThreshold) {
-              flags.push(`${page.relPath}: section "${ann.heading}" expires in ${daysUntilExpiry} day(s) (${ann.expires})`);
+    const staleSectionResults = await mapWithConcurrency(
+      ctx.scan.typedKnowledge,
+      vaultIoConcurrency(),
+      async (page) => {
+        const flags = [];
+        try {
+          const text = await readPageCached(page, ctx.pageTextCache);
+          const annotations = parseExpiryAnnotations(text, page.relPath);
+          for (const ann of annotations) {
+            if (ann.expires < today) {
+              flags.push(`${page.relPath}: section "${ann.heading}" expired on ${ann.expires}`);
+            } else {
+              const daysUntilExpiry = Math.floor((Date.parse(ann.expires) - Date.now()) / 864e5);
+              if (daysUntilExpiry <= approachingThreshold) {
+                flags.push(
+                  `${page.relPath}: section "${ann.heading}" expires in ${daysUntilExpiry} day(s) (${ann.expires})`
+                );
+              }
             }
           }
+        } catch {
         }
-      } catch {
+        return flags;
       }
-      return flags;
-    });
+    );
     staleSectionFlags.push(...staleSectionResults.flat());
+    const buckets = {};
     if (staleSectionFlags.length > 0) buckets.stale_sections = staleSectionFlags;
-    if (shouldFix("sensitive_content") && buckets.sensitive_content) {
-      const sensitiveFixed = [];
-      for (const page of scan.allMarkdown) {
-        try {
-          const raw = await readPage(page);
-          const redacted = redactSensitiveContent(raw, { file: page.relPath });
-          if (!redacted.changed) continue;
-          if (page.relPath.startsWith("raw/")) {
-            unresolved.push(page.relPath);
-            continue;
-          }
-          const w = await safeWritePage(page.absPath, redacted.text, { minBodyRatio: null });
-          if (!w.ok) {
-            unresolved.push(page.relPath);
-            continue;
+    return { buckets };
+  }
+};
+var cycleTrapsRule = {
+  id: "cycle_traps",
+  severity: "warning",
+  async run(ctx) {
+    const pages = ctx.scan.typedKnowledge;
+    const pagePaths = new Set(pages.map((p) => p.relPath));
+    const adj = /* @__PURE__ */ new Map();
+    for (const p of pages) {
+      adj.set(p.relPath, []);
+    }
+    const perPageTargets = await mapWithConcurrency(pages, vaultIoConcurrency(), async (p) => {
+      try {
+        const text = await readPageCached(p, ctx.pageTextCache);
+        const split = splitFrontmatter(text);
+        const body = split.ok ? split.data.body : text;
+        const targets = [];
+        for (const slug of extractBodyWikilinks(body)) {
+          const resolution = ctx.wikilinkResolver.resolve(slug);
+          if (resolution.path && pagePaths.has(resolution.path)) {
+            targets.push(resolution.path);
           }
-          sensitiveFixed.push(page.relPath);
-        } catch {
-          unresolved.push(page.relPath);
         }
+        return { relPath: p.relPath, targets };
+      } catch {
+        return { relPath: p.relPath, targets: [] };
       }
-      fixed.push(...sensitiveFixed);
-      const remainingSensitiveFlags = [];
-      for (const page of scan.allMarkdown) {
-        try {
-          const text = await readPage(page);
-          remainingSensitiveFlags.push(...scanSensitiveContent(text, { file: page.relPath }));
-        } catch {
+    });
+    for (const item of perPageTargets) {
+      adj.set(item.relPath, item.targets);
+    }
+    let index = 0;
+    const indices = /* @__PURE__ */ new Map();
+    const lowlink = /* @__PURE__ */ new Map();
+    const onStack = /* @__PURE__ */ new Set();
+    const stack = [];
+    const cyclePages = /* @__PURE__ */ new Set();
+    function strongConnect(v) {
+      indices.set(v, index);
+      lowlink.set(v, index);
+      index++;
+      stack.push(v);
+      onStack.add(v);
+      const neighbors = adj.get(v) ?? [];
+      for (const w of neighbors) {
+        if (!indices.has(w)) {
+          strongConnect(w);
+          lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
+        } else if (onStack.has(w)) {
+          lowlink.set(v, Math.min(lowlink.get(v), indices.get(w)));
         }
       }
-      if (remainingSensitiveFlags.length > 0) buckets.sensitive_content = remainingSensitiveFlags;
-      else delete buckets.sensitive_content;
-    }
-    if (shouldFix("legacy_citation_style") && legacyPages.length > 0) {
-      const FENCE_RE = /```[\s\S]*?```/g;
-      const INLINE_MARKER = /\^\[raw\/[^\]]+\]/g;
-      for (const relPath of legacyPages) {
-        try {
-          const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile13(absPath, "utf8");
-          const split = splitFrontmatter(raw);
-          if (!split.ok) {
-            unresolved.push(relPath);
-            continue;
-          }
-          const body = split.data.body;
-          const rawFm = split.data.rawFrontmatter;
-          const stripped = body.replace(FENCE_RE, "");
-          const lines = stripped.split("\n");
-          const inlineMarkers = [];
-          let inSources = false;
-          for (const line of lines) {
-            if (/^## Sources\b/.test(line.trim())) {
-              inSources = true;
-              continue;
-            }
-            if (inSources) continue;
-            for (const m of line.matchAll(INLINE_MARKER)) {
-              inlineMarkers.push(m[0]);
-            }
-          }
-          if (inlineMarkers.length === 0) {
-            unresolved.push(relPath);
-            continue;
-          }
-          const bodyLines = body.split("\n");
-          let inSrc = false;
-          const newBodyLines = [];
-          for (const line of bodyLines) {
-            if (/^## Sources\b/.test(line.trim())) {
-              inSrc = true;
-              newBodyLines.push(line);
-              continue;
-            }
-            if (inSrc) {
-              newBodyLines.push(line);
-              continue;
-            }
-            INLINE_MARKER.lastIndex = 0;
-            const lineWithoutMarkers = line.replace(INLINE_MARKER, "").trim();
-            INLINE_MARKER.lastIndex = 0;
-            if (lineWithoutMarkers.length === 0 && INLINE_MARKER.test(line)) {
-              continue;
-            }
-            let cleaned = line;
-            for (const marker of inlineMarkers) {
-              const escapedMarker = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-              const trailingRe = new RegExp(`([.!?]\\s*)${escapedMarker}`);
-              if (trailingRe.test(cleaned)) {
-                cleaned = cleaned.replace(trailingRe, "$1");
-              }
-              const midRe = new RegExp(`${escapedMarker}\\s*`);
-              if (midRe.test(cleaned)) {
-                cleaned = cleaned.replace(midRe, "");
-              }
-            }
-            newBodyLines.push(cleaned);
-          }
-          let newBody = newBodyLines.join("\n");
-          const dedupedMarkers = [...new Set(inlineMarkers)];
-          if (inSrc) {
-            const existingSources = new Set(
-              body.split("\n").filter((l) => /^- \^\[raw\//.test(l.trim())).map((l) => l.trim().replace(/^- /, ""))
-            );
-            const newMarkers = dedupedMarkers.filter((m) => !existingSources.has(m));
-            const sourceLines = newMarkers.map((m) => `- ${m}`);
-            if (sourceLines.length > 0) {
-              newBody = newBody.trimEnd() + "\n" + sourceLines.join("\n") + "\n";
-            }
-          } else {
-            const sourceLines = dedupedMarkers.map((m) => `- ${m}`);
-            newBody = newBody.trimEnd() + "\n\n## Sources\n\n" + sourceLines.join("\n") + "\n";
+      if (lowlink.get(v) === indices.get(v)) {
+        const scc = [];
+        let node;
+        do {
+          node = stack.pop();
+          onStack.delete(node);
+          scc.push(node);
+        } while (node !== v);
+        if (scc.length > 1) {
+          for (const member of scc) {
+            cyclePages.add(member);
           }
-          const newContent = `---
-${rawFm}
----
-${newBody}`;
-          const w = await safeWritePage(absPath, newContent);
-          if (!w.ok) {
-            unresolved.push(relPath);
-            continue;
+        } else if (scc.length === 1) {
+          const single = scc[0];
+          if ((adj.get(single) ?? []).includes(single)) {
+            cyclePages.add(single);
           }
-          fixed.push(relPath);
-        } catch {
-          unresolved.push(relPath);
         }
       }
-      if (fixed.length > 0) {
-        const fixedSet = new Set(fixed);
-        const remaining = legacyPages.filter((p) => !fixedSet.has(p));
-        if (remaining.length > 0) buckets.legacy_citation_style = remaining;
-        else delete buckets.legacy_citation_style;
+    }
+    for (const p of pages) {
+      if (!indices.has(p.relPath)) {
+        strongConnect(p.relPath);
       }
     }
-    if (shouldFix("missing_overview") && noOverview.length > 0) {
-      for (const relPath of noOverview) {
-        try {
-          const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile13(absPath, "utf8");
-          const split = splitFrontmatter(raw);
-          if (!split.ok) {
-            unresolved.push(relPath);
-            continue;
-          }
-          const body = split.data.body;
-          const rawFm = split.data.rawFrontmatter;
-          const fm = extractFrontmatter(raw);
-          const title = fm.ok && typeof fm.data.title === "string" ? fm.data.title : "";
-          const overviewSection = `## Overview
-
-${title}`;
-          const trimmedBody = body.replace(/^\n+/, "");
-          const newContent = `---
-${rawFm}
----
-
-${overviewSection}
+    const buckets = {};
+    if (cyclePages.size > 0) {
+      buckets.cycle_traps = [...cyclePages].sort();
+    }
+    return { buckets };
+  }
+};
+var LINT_RULES = [
+  brokenWikilinksRule,
+  tagNotInTaxonomyRule,
+  indexIncompleteRule,
+  indexLinkFormatRule,
+  stalePageRule,
+  pageTooLargeRule,
+  logRotateNeededRule,
+  orphansRule,
+  sparseCommunityRule,
+  topicMapRecommendedRule,
+  rawDedupRule,
+  rawBodyDuplicateRule,
+  compoundRefsRule,
+  pathTooLongRule,
+  sensitiveContentRule,
+  conflictMarkersRule,
+  frontmatterYamlInvalidRule,
+  rawSubdirectoryDuplicateRule,
+  fileSourceUrlRule,
+  legacyCitationStyleRule,
+  orphanedCitationsRule,
+  pageStructureRule,
+  duplicateFrontmatterRule,
+  missingOverviewRule,
+  frontmatterWikilinkRule,
+  wikilinkCitationRule,
+  brokenSourcesRule,
+  missingTldrRule,
+  missingDiagramRule,
+  workItemHealthRule,
+  orphanedProjectPagesRule,
+  cliRefsRule,
+  staleSectionsRule,
+  cycleTrapsRule
+];
 
-${trimmedBody}`;
-          const w = await safeWritePage(absPath, newContent);
-          if (!w.ok) {
-            unresolved.push(relPath);
-            continue;
-          }
-          fixed.push(relPath);
-        } catch {
-          unresolved.push(relPath);
+// src/lint/runner.ts
+var LintRunner = class {
+  rules;
+  constructor(rules = LINT_RULES) {
+    this.rules = rules;
+  }
+  getRegisteredRules() {
+    return this.rules;
+  }
+  findRuleForBucket(bucketName) {
+    return this.rules.find((r) => r.id === bucketName || r.producedBuckets?.includes(bucketName));
+  }
+  async run(input) {
+    if (input.only && !KNOWN_BUCKETS.includes(input.only)) {
+      return {
+        exitCode: ExitCode.USAGE,
+        result: {
+          ok: false,
+          error: "UNKNOWN_BUCKET",
+          detail: `Unknown bucket "${input.only}". Valid: ${KNOWN_BUCKETS.join(", ")}`
         }
+      };
+    }
+    if (input.only) {
+      const rule = this.findRuleForBucket(input.only);
+      if (rule && rule.id === input.only && rule.runFastPath) {
+        return rule.runFastPath(input);
       }
-      const fixedBeforeOverview = fixed.length;
-      const fixedSet = new Set(fixed);
-      const remaining = noOverview.filter((p) => !fixedSet.has(p));
-      if (remaining.length > 0) buckets.missing_overview = remaining;
-      else delete buckets.missing_overview;
     }
-    if (shouldFix("missing_tldr") && missingTldrFlags.length > 0) {
-      for (const relPath of missingTldrFlags) {
+    const shouldFix = (bucket) => !!input.fix && (!input.only || input.only === bucket);
+    const readVault = lintReadVault(input);
+    const lintVault = readVault.readPath;
+    const buckets = {};
+    const fixed = [];
+    const unresolved = [];
+    const scanResult = await scanVault(lintVault);
+    if (!scanResult.ok) {
+      return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scanResult };
+    }
+    const scan = scanResult.data;
+    const pageTextCache = /* @__PURE__ */ new Map();
+    if (!input.fix) {
+      await mapWithConcurrency(scan.allMarkdown, vaultIoConcurrency(), async (page) => {
         try {
-          const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile13(absPath, "utf8");
-          const split = splitFrontmatter(raw);
-          if (!split.ok) {
-            unresolved.push(relPath);
-            continue;
-          }
-          const body = split.data.body;
-          const rawFm = split.data.rawFrontmatter;
-          const lines = body.split("\n");
-          let insertIndex = 0;
-          for (let i = 0; i < lines.length; i++) {
-            if (/^# /.test(lines[i])) {
-              insertIndex = i + 1;
-              while (insertIndex < lines.length && lines[insertIndex].trim() === "") {
-                insertIndex++;
-              }
-              break;
-            }
-          }
-          if (insertIndex === 0) {
-            lines.splice(0, 0, "", "> **TL;DR:** ");
-          } else {
-            lines.splice(insertIndex, 0, "> **TL;DR:** ");
-          }
-          const trimmedFm = rawFm.endsWith("\n") ? rawFm : rawFm + "\n";
-          const newContent = `---
-${trimmedFm}---
-${lines.join("\n")}`;
-          const w = await safeWritePage(absPath, newContent);
-          if (!w.ok) {
-            unresolved.push(relPath);
-            continue;
-          }
-          fixed.push(relPath);
+          await readPageCached(page, pageTextCache);
         } catch {
-          unresolved.push(relPath);
         }
-      }
-      const fixedSet = new Set(fixed);
-      const remaining = missingTldrFlags.filter((p) => !fixedSet.has(p));
-      if (remaining.length > 0) buckets.missing_tldr = remaining;
-      else delete buckets.missing_tldr;
-    }
-    if (shouldFix("wikilink_citation") && wikilinkCitationFlags.length > 0) {
-      const WIKILINK_RE = /\[\[raw\/([^\]|]+)(?:\|[^\]]*)?\]\]/g;
-      const FENCE_RE = /```[\s\S]*?```/g;
-      const wikilinkFixed = [];
-      for (const relPath of wikilinkCitationFlags) {
-        try {
-          const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile13(absPath, "utf8");
-          const split = splitFrontmatter(raw);
-          if (!split.ok) {
-            unresolved.push(relPath);
-            continue;
-          }
-          const body = split.data.body;
-          const rawFm = split.data.rawFrontmatter;
-          const stripped = body.replace(FENCE_RE, "");
-          const wikilinkMatches = [...stripped.matchAll(WIKILINK_RE)];
-          if (wikilinkMatches.length === 0) {
-            unresolved.push(relPath);
-            continue;
-          }
-          const wikilinkPaths = [...new Set(wikilinkMatches.map((m) => m[1]))];
-          const bodyLines = body.split("\n");
-          let inSrc = false;
-          const newBodyLines = [];
-          for (const line of bodyLines) {
-            if (/^## Sources\b/.test(line.trim())) {
-              inSrc = true;
-              newBodyLines.push(line);
-              continue;
-            }
-            if (inSrc) {
-              newBodyLines.push(line);
-              continue;
-            }
-            let cleaned = line.replace(/\[\[raw\/[^\]|]+(?:\|[^\]]*)?\]\]/g, "");
-            cleaned = cleaned.replace(/\s+\./g, ".").replace(/\s{2,}/g, " ").replace(/\s+$/, "");
-            if (cleaned.length > 0 || line.trim().length === 0) {
-              newBodyLines.push(cleaned);
-            }
-          }
-          let newBody = newBodyLines.join("\n");
-          const citationMarkers = wikilinkPaths.map((p) => `^[raw/${p}]`);
-          const sourceEntries = extractSourceEntries(rawFm);
-          const fmMarkers = [];
-          for (const entry of sourceEntries) {
-            let rawPath = entry.replace(/^"/, "").replace(/"$/, "").replace(/^'/, "").replace(/'$/, "");
-            rawPath = rawPath.replace(/^\^\[/, "").replace(/\]$/, "");
-            if (rawPath.startsWith("raw/")) {
-              fmMarkers.push(`^[${rawPath}]`);
-            }
-          }
-          const allMarkers = [.../* @__PURE__ */ new Set([...citationMarkers, ...fmMarkers])];
-          const hasSourcesSection = /^## Sources\b/m.test(newBody);
-          if (hasSourcesSection) {
-            const existingSources = new Set(
-              newBody.split("\n").filter((l) => /^- \^\[raw\//.test(l.trim())).map((l) => l.trim().replace(/^- /, ""))
-            );
-            const newMarkers = allMarkers.filter((m) => !existingSources.has(m));
-            const sourceLines = newMarkers.map((m) => `- ${m}`);
-            if (sourceLines.length > 0) {
-              newBody = newBody.trimEnd() + "\n" + sourceLines.join("\n") + "\n";
-            }
+      });
+    }
+    const wikilinkResolver = buildWikilinkResolver(scan.allMarkdown);
+    const cliSurface = buildCliSurface();
+    const ctx = {
+      vault: lintVault,
+      scan,
+      pageTextCache,
+      days: input.days,
+      lines: input.lines,
+      logThreshold: input.logThreshold,
+      wikilinkResolver,
+      cliSurface
+    };
+    for (const rule of this.rules) {
+      const ruleRes = await rule.run(ctx);
+      for (const [kind, items] of Object.entries(ruleRes.buckets)) {
+        if (items && items.length > 0) {
+          if (buckets[kind]) {
+            buckets[kind] = [...buckets[kind], ...items];
           } else {
-            const sourceLines = allMarkers.map((m) => `- ${m}`);
-            newBody = newBody.trimEnd() + "\n\n## Sources\n\n" + sourceLines.join("\n") + "\n";
-          }
-          const newContent = `---
-${rawFm}
----
-${newBody}`;
-          const w = await safeWritePage(absPath, newContent);
-          if (!w.ok) {
-            unresolved.push(relPath);
-            continue;
+            buckets[kind] = items;
           }
-          wikilinkFixed.push(relPath);
-        } catch {
-          unresolved.push(relPath);
-        }
-      }
-      fixed.push(...wikilinkFixed);
-      if (wikilinkFixed.length > 0) {
-        const fixedSet = new Set(wikilinkFixed);
-        const remaining = wikilinkCitationFlags.filter((p) => !fixedSet.has(p));
-        if (remaining.length > 0) buckets.wikilink_citation = remaining;
-        else delete buckets.wikilink_citation;
-      }
-    }
-    if (shouldFix("file_source_url") && fileSourceUrlFrontmatterFlags.size > 0) {
-      fileSourceUrlFlags = await applyFileSourceUrlFix(input, scan, fileSourceUrlFlags, fileSourceUrlFrontmatterFlags, fixed, unresolved);
-      if (fileSourceUrlFlags.size > 0) buckets.file_source_url = [...fileSourceUrlFlags];
-      else delete buckets.file_source_url;
-    }
-    const pathViolations = buckets.path_too_long;
-    if (shouldFix("path_too_long") && pathViolations && pathViolations.length > 0) {
-      const pathFix = await fixPathTooLong({ vault: input.vault });
-      const pathFixed = pathFix.result.ok ? pathFix.result.data.fixed.map((f) => f.from) : [];
-      if (pathFix.result.ok) unresolved.push(...pathFix.result.data.unresolved);
-      else unresolved.push(...pathViolations.map((v) => v.relPath));
-      fixed.push(...pathFixed);
-      if (pathFixed.length > 0) {
-        const fixedSet = new Set(pathFixed);
-        const remaining = pathViolations.filter((v) => !fixedSet.has(v.relPath));
-        if (remaining.length > 0) buckets.path_too_long = remaining;
-        else delete buckets.path_too_long;
-      }
-      if (buckets.path_too_long) {
-        const rawRemaining = buckets.path_too_long.filter((v) => v.relPath.startsWith("raw/"));
-        if (rawRemaining.length > 0) {
-          unresolved.push(...rawRemaining.map((v) => v.relPath));
-          const nonRaw = buckets.path_too_long.filter((v) => !v.relPath.startsWith("raw/"));
-          if (nonRaw.length > 0) buckets.path_too_long = nonRaw;
-          else delete buckets.path_too_long;
         }
       }
     }
-    if (shouldFix("frontmatter_yaml_invalid") && buckets.frontmatter_yaml_invalid) {
-      const invalidItems = buckets.frontmatter_yaml_invalid;
-      const remaining = [];
-      for (const item of invalidItems) {
-        if (item.path.startsWith("raw/")) {
-          unresolved.push(item.path);
-          remaining.push(item);
-          continue;
-        }
-        const page = scan.allMarkdown.find((p) => p.relPath === item.path);
-        if (!page) {
-          unresolved.push(item.path);
-          remaining.push(item);
-          continue;
-        }
-        try {
-          const text = await readPage(page);
-          const split = splitFrontmatter(text);
-          if (!split.ok) {
-            unresolved.push(item.path);
-            remaining.push(item);
-            continue;
-          }
-          const newFm = fixFrontmatter(split.data.rawFrontmatter);
-          const newText = `---
-${newFm}
----
-${split.data.body}`;
-          const recheck = extractFrontmatter(newText);
-          if (!recheck.ok) {
-            unresolved.push(item.path);
-            remaining.push(item);
-            continue;
-          }
-          const w = await safeWritePage(page.absPath, newText, { minBodyRatio: null });
-          if (!w.ok) {
-            unresolved.push(item.path);
-            remaining.push(item);
-            continue;
+    if (input.fix) {
+      const fixCtx = {
+        vault: lintVault,
+        scan,
+        pageTextCache,
+        input,
+        fixed,
+        unresolved
+      };
+      for (const rule of this.rules) {
+        const produced = rule.producedBuckets ?? [rule.id];
+        for (const bucketName of produced) {
+          if (shouldFix(bucketName) && buckets[bucketName] && rule.fix) {
+            const remaining = await rule.fix(fixCtx, buckets[bucketName]);
+            if (remaining && remaining.length > 0) {
+              buckets[bucketName] = remaining;
+            } else {
+              delete buckets[bucketName];
+            }
           }
-          fixed.push(item.path);
-        } catch {
-          unresolved.push(item.path);
-          remaining.push(item);
         }
       }
-      if (remaining.length > 0) buckets.frontmatter_yaml_invalid = remaining;
-      else delete buckets.frontmatter_yaml_invalid;
-    }
-  }
-  const errorOut = ERROR_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
-  const warningOut = WARNING_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
-  const infoOut = INFO_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
-  if (input.only) {
-    const match = [...errorOut, ...warningOut, ...infoOut].filter((b) => b.kind === input.only);
-    return outputForOnlyBucket(input, match, fixed, unresolved, readVault);
-  }
-  const summary = {
-    errors: errorOut.reduce((n, b) => n + b.items.length, 0),
-    warnings: warningOut.reduce((n, b) => n + b.items.length, 0),
-    info: infoOut.reduce((n, b) => n + b.items.length, 0)
-  };
-  let exitCode = ExitCode.OK;
-  if (summary.errors > 0) exitCode = ExitCode.LINT_HAS_ERRORS;
-  else if (summary.warnings > 0 || summary.info > 0) exitCode = ExitCode.LINT_HAS_WARNINGS;
-  const vault = lintVaultOutput(input, readVault);
-  const hintLines = [];
-  hintLines.push(...readMirrorHintLines(vault));
-  if (summary.errors > 0) hintLines.push(`errors: ${summary.errors}`);
-  if (summary.warnings > 0) hintLines.push(`warnings: ${summary.warnings}`);
-  if (summary.info > 0) hintLines.push(`info: ${summary.info}`);
-  const allBuckets = [...errorOut, ...warningOut, ...infoOut];
-  for (const b of allBuckets) {
-    hintLines.push(`  ${b.kind}: ${b.items.length}`);
-  }
-  if (hintLines.length === 0) hintLines.push("0 errors, 0 warnings, 0 info");
-  if (input.fix) appendLintFixLastOp(input.vault, fixed);
-  const output = {
-    vault,
-    summary,
-    by_severity: { error: errorOut, warning: warningOut, info: infoOut },
-    fixed,
-    unresolved,
-    humanHint: hintLines.join("\n")
-  };
-  return {
-    exitCode,
-    result: ok(input.summary ? summarizeLintOutput(output, input.examplesLimit) : output)
-  };
-}
-function lintIssueFingerprint(bucket, item) {
-  const page = extractIssuePage(item);
-  const detail = normalizeIssueDetail(item);
-  return `${bucket}\0${page}\0${detail}`;
-}
-function extractIssuePage(item) {
-  if (typeof item === "string") {
-    const m = item.match(/^([^:]+?)(?::\s|$)/);
-    return (m?.[1] ?? item).trim();
-  }
-  if (item && typeof item === "object") {
-    const obj = item;
-    for (const key of ["path", "file", "page", "relPath"]) {
-      if (typeof obj[key] === "string") return obj[key];
-    }
-  }
-  return "";
-}
-function normalizeIssueDetail(item) {
-  if (typeof item === "string") {
-    return item.replace(/\s+/g, " ").trim();
-  }
-  try {
-    return JSON.stringify(item, Object.keys(item).sort());
-  } catch {
-    return String(item);
-  }
-}
-function collectLintErrorFingerprints(output) {
-  const fps = /* @__PURE__ */ new Set();
-  for (const bucket of output.by_severity.error) {
-    for (const item of bucket.items) {
-      fps.add(lintIssueFingerprint(bucket.kind, item));
     }
+    const errorOut = ERROR_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
+    const warningOut = WARNING_ORDER.flatMap(
+      (k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []
+    );
+    const infoOut = INFO_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
+    if (input.only) {
+      const match = [...errorOut, ...warningOut, ...infoOut].filter((b) => b.kind === input.only);
+      const out = outputForOnlyBucket(input, match, fixed, unresolved, readVault);
+      if (input.fix) appendLintFixLastOp(input.vault, fixed);
+      return out;
+    }
+    const summary = {
+      errors: errorOut.reduce((n, b) => n + b.items.length, 0),
+      warnings: warningOut.reduce((n, b) => n + b.items.length, 0),
+      info: infoOut.reduce((n, b) => n + b.items.length, 0)
+    };
+    let exitCode = ExitCode.OK;
+    if (summary.errors > 0) exitCode = ExitCode.LINT_HAS_ERRORS;
+    else if (summary.warnings > 0 || summary.info > 0) exitCode = ExitCode.LINT_HAS_WARNINGS;
+    const vault = lintVaultOutput(input, readVault);
+    const hintLines = [];
+    hintLines.push(...readMirrorHintLines(vault));
+    if (summary.errors > 0) hintLines.push(`errors: ${summary.errors}`);
+    if (summary.warnings > 0) hintLines.push(`warnings: ${summary.warnings}`);
+    if (summary.info > 0) hintLines.push(`info: ${summary.info}`);
+    const allBuckets = [...errorOut, ...warningOut, ...infoOut];
+    for (const b of allBuckets) {
+      hintLines.push(`  ${b.kind}: ${b.items.length}`);
+    }
+    if (hintLines.length === 0) hintLines.push("0 errors, 0 warnings, 0 info");
+    if (input.fix) appendLintFixLastOp(input.vault, fixed);
+    const output = {
+      vault,
+      summary,
+      by_severity: { error: errorOut, warning: warningOut, info: infoOut },
+      fixed,
+      unresolved,
+      humanHint: hintLines.join("\n")
+    };
+    return {
+      exitCode,
+      result: ok(input.summary ? summarizeLintOutput(output, input.examplesLimit) : output)
+    };
   }
-  return fps;
+};
+var defaultLintRunner = new LintRunner();
+function runLint(input) {
+  return defaultLintRunner.run(input);
 }
 async function runSyncLintDelta(input) {
   const { mkdtempSync, rmSync, existsSync: fsExists } = await import("fs");
@@ -4665,7 +5314,7 @@ function gitStrict(cwd, args) {
 
 // src/utils/sync-lock.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { createHash as createHash5, randomBytes } from "crypto";
 function getEnvSessionId() {
   if (process.env.CLAUDE_SESSION_ID) return process.env.CLAUDE_SESSION_ID;
@@ -4688,7 +5337,7 @@ function getCliSessionId(cwd) {
   return `cli-${getCwdHash(cwd)}`;
 }
 function lockPath(vault) {
-  return join13(vault, ".skillwiki", "sync.lock");
+  return join14(vault, ".skillwiki", "sync.lock");
 }
 function readLock(vault) {
   const path = lockPath(vault);
@@ -4707,7 +5356,7 @@ function isStale(lock, now) {
 }
 function acquireLock(vault, opts = {}) {
   const path = lockPath(vault);
-  const dir = join13(vault, ".skillwiki");
+  const dir = join14(vault, ".skillwiki");
   if (!existsSync5(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
@@ -4792,7 +5441,7 @@ function acquireOwnedSyncLock(vault, opts) {
   };
   const path = lockPath(vault);
   try {
-    mkdirSync3(join13(vault, ".skillwiki"), { recursive: true });
+    mkdirSync3(join14(vault, ".skillwiki"), { recursive: true });
   } catch (error) {
     return err("WRITE_FAILED", { path, message: String(error) });
   }
@@ -4844,7 +5493,7 @@ function stageVaultContentChanges(vault) {
 
 // src/utils/remote-health.ts
 import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 var REMOTE_PROBE_TIMEOUT_MS = 3e3;
 var defaultExec = (file, args, cwd) => execFileSync2(file, args, {
@@ -4855,7 +5504,7 @@ var defaultExec = (file, args, cwd) => execFileSync2(file, args, {
 }).trim();
 function readWikiS3RemoteConfigured(home) {
   try {
-    const content = readFileSync4(join14(home, ".skillwiki", ".env"), "utf8");
+    const content = readFileSync4(join15(home, ".skillwiki", ".env"), "utf8");
     for (const line of content.split(/\r?\n/)) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
@@ -4880,7 +5529,7 @@ function resolveWikiS3Remote(input) {
   return readWikiS3RemoteConfigured(input.home);
 }
 function probeGithubReachability(vaultPath, exec = defaultExec) {
-  if (!existsSync6(join14(vaultPath, ".git"))) return "unknown";
+  if (!existsSync6(join15(vaultPath, ".git"))) return "unknown";
   try {
     exec("git", ["remote", "get-url", "origin"], vaultPath);
   } catch {
@@ -4948,7 +5597,7 @@ function probeRemoteHealth(input) {
 import { spawnSync } from "child_process";
 import { existsSync as existsSync7 } from "fs";
 import { homedir, platform } from "os";
-import { dirname as dirname6, join as join15 } from "path";
+import { dirname as dirname6, join as join16 } from "path";
 import { fileURLToPath } from "url";
 var HELPER_NAME = "wiki-pull-with-auto-resolve.sh";
 function candidateHelperPaths(input = { vault: "" }) {
@@ -4965,10 +5614,10 @@ function candidateHelperPaths(input = { vault: "" }) {
     }
   }
   if (here) {
-    paths.push(join15(here, "vault-sync", "scripts", HELPER_NAME));
-    paths.push(join15(here, "..", "vault-sync", "scripts", HELPER_NAME));
-    paths.push(join15(here, "..", "..", "vault-sync", "scripts", HELPER_NAME));
-    paths.push(join15(here, "..", "..", "..", "vault-sync", "scripts", HELPER_NAME));
+    paths.push(join16(here, "vault-sync", "scripts", HELPER_NAME));
+    paths.push(join16(here, "..", "vault-sync", "scripts", HELPER_NAME));
+    paths.push(join16(here, "..", "..", "vault-sync", "scripts", HELPER_NAME));
+    paths.push(join16(here, "..", "..", "..", "vault-sync", "scripts", HELPER_NAME));
   }
   const home = input.home ?? env.HOME ?? env.USERPROFILE ?? (() => {
     try {
@@ -4981,11 +5630,11 @@ function candidateHelperPaths(input = { vault: "" }) {
     const xdg = env.XDG_DATA_HOME;
     const isDarwin = platform() === "darwin";
     if (isDarwin) {
-      paths.push(join15(home, "Library", "Application Support", "vault-sync", "bin", HELPER_NAME));
+      paths.push(join16(home, "Library", "Application Support", "vault-sync", "bin", HELPER_NAME));
     }
-    paths.push(join15(xdg || join15(home, ".local", "share"), "vault-sync", "bin", HELPER_NAME));
+    paths.push(join16(xdg || join16(home, ".local", "share"), "vault-sync", "bin", HELPER_NAME));
     if (!isDarwin) {
-      paths.push(join15(home, "Library", "Application Support", "vault-sync", "bin", HELPER_NAME));
+      paths.push(join16(home, "Library", "Application Support", "vault-sync", "bin", HELPER_NAME));
     }
   }
   return paths;
@@ -5079,7 +5728,7 @@ function refHasPath(vault, ref, path) {
 function runSyncStatus(input) {
   const vault = input.vault;
   const includeStashes = input.includeStashes ?? false;
-  if (!existsSync8(join16(vault, ".git"))) {
+  if (!existsSync8(join17(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: ok({
@@ -5186,7 +5835,7 @@ function runSyncStatus(input) {
 }
 async function runSyncPush(input) {
   const vault = input.vault;
-  if (!existsSync8(join16(vault, ".git"))) {
+  if (!existsSync8(join17(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -5346,7 +5995,7 @@ function enableGitLongPathsOnWindows(vault) {
 }
 async function runSyncPull(input) {
   const vault = input.vault;
-  if (!existsSync8(join16(vault, ".git"))) {
+  if (!existsSync8(join17(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -5643,11 +6292,11 @@ import {
   writeFileSync as writeFileSync4
 } from "fs";
 import { hostname } from "os";
-import { dirname as dirname7, join as join17, resolve as resolve4 } from "path";
+import { dirname as dirname7, join as join18, resolve as resolve4 } from "path";
 function managedWriteLockPath(vault) {
   const gitPath = git(vault, ["rev-parse", "--git-path", "vault-sync/managed-write.lock"]);
-  if (gitPath) return gitPath.startsWith("/") ? gitPath : join17(vault, gitPath);
-  return join17(vault, ".skillwiki", "managed-write.lock");
+  if (gitPath) return gitPath.startsWith("/") ? gitPath : join18(vault, gitPath);
+  return join18(vault, ".skillwiki", "managed-write.lock");
 }
 function readLockRecord(path) {
   try {
@@ -5670,12 +6319,12 @@ function hasUnsafeGitState(vault) {
   if (!isGitBackedVault(vault)) return false;
   const gitDirRaw = git(vault, ["rev-parse", "--git-dir"]);
   if (!gitDirRaw) return true;
-  const gitDir = gitDirRaw.startsWith("/") ? gitDirRaw : join17(vault, gitDirRaw);
+  const gitDir = gitDirRaw.startsWith("/") ? gitDirRaw : join18(vault, gitDirRaw);
   for (const rel of ["rebase-merge", "rebase-apply"]) {
-    if (existsSync9(join17(gitDir, rel))) return true;
+    if (existsSync9(join18(gitDir, rel))) return true;
   }
   for (const rel of ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD"]) {
-    if (existsSync9(join17(gitDir, rel))) return true;
+    if (existsSync9(join18(gitDir, rel))) return true;
   }
   const unmerged = git(vault, ["ls-files", "-u"]);
   return Boolean(unmerged && unmerged.trim().length > 0);
@@ -5713,10 +6362,10 @@ function reclaimDeadManagedWriteLockOwner(vault, options = {}) {
     });
   }
   try {
-    const recoveryDir = join17(dirname7(path), "recovery");
+    const recoveryDir = join18(dirname7(path), "recovery");
     mkdirSync4(recoveryDir, { recursive: true });
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
-    const recoveryPath = join17(recoveryDir, `stale-managed-write-lock-${stamp}-${process.pid}.json`);
+    const recoveryPath = join18(recoveryDir, `stale-managed-write-lock-${stamp}-${process.pid}.json`);
     const meta = {
       recovered_at: (/* @__PURE__ */ new Date()).toISOString(),
       recovery_reason: "owner_pid_dead",
@@ -5795,11 +6444,11 @@ import {
   renameSync as renameSync2,
   writeFileSync as writeFileSync5
 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 function journalDir(vault) {
   const gitPath = git(vault, ["rev-parse", "--git-path", "vault-sync/operations"]);
   if (!gitPath) return null;
-  return gitPath.startsWith("/") ? gitPath : join18(vault, gitPath);
+  return gitPath.startsWith("/") ? gitPath : join19(vault, gitPath);
 }
 function parseJournalEnv(text) {
   return Object.fromEntries(
@@ -5823,7 +6472,7 @@ function serializeJournalEnv(fields, preferredOrder = []) {
 function readJournal(vault, opId) {
   const dir = journalDir(vault);
   if (!dir) return null;
-  const path = join18(dir, `${opId}.env`);
+  const path = join19(dir, `${opId}.env`);
   if (!existsSync10(path)) return null;
   try {
     return parseJournalEnv(readFileSync6(path, "utf8"));
@@ -5836,7 +6485,7 @@ function writeJournal(vault, opId, fields) {
   if (!dir) return false;
   try {
     mkdirSync5(dir, { recursive: true });
-    const path = join18(dir, `${opId}.env`);
+    const path = join19(dir, `${opId}.env`);
     const tmp = `${path}.tmp.${process.pid}`;
     const order = [
       "operation_id",
@@ -5902,9 +6551,9 @@ function hasActiveGitSequencer(vault) {
   const gitDir = git(vault, ["rev-parse", "--absolute-git-dir"]);
   if (!gitDir) return false;
   for (const m of ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD"]) {
-    if (existsSync10(join18(gitDir, m))) return true;
+    if (existsSync10(join19(gitDir, m))) return true;
   }
-  if (existsSync10(join18(gitDir, "rebase-merge")) || existsSync10(join18(gitDir, "rebase-apply"))) {
+  if (existsSync10(join19(gitDir, "rebase-merge")) || existsSync10(join19(gitDir, "rebase-apply"))) {
     return true;
   }
   return false;
@@ -5975,7 +6624,7 @@ function supersedeStaleReviewRequiredJournals(vault, opts = {}) {
 
 // src/utils/snapshot-worktree.ts
 import { readFileSync as readFileSync7 } from "fs";
-import { join as join19, resolve as resolve5 } from "path";
+import { join as join20, resolve as resolve5 } from "path";
 function readSkillWikiConfig(path) {
   try {
     return parseDotenvText(readFileSync7(path, "utf8"));
@@ -6002,7 +6651,7 @@ function readSnapshotProfile(path) {
 }
 function resolveConfiguredSnapshotWorktree(home) {
   if (!home) return void 0;
-  const config = readSkillWikiConfig(join19(home, ".skillwiki", ".env"));
+  const config = readSkillWikiConfig(join20(home, ".skillwiki", ".env"));
   const explicit = config["vault_sync.snapshot_worktree"];
   if (explicit) return resolve5(explicit);
   const snapshotProfile = config["vault_sync.snapshot_profile"];
@@ -6154,7 +6803,7 @@ function preflightBlocker(vault) {
   return null;
 }
 function hasFleetManifest(vault) {
-  return existsSync11(join20(vault, FLEET_REL_PATH));
+  return existsSync11(join21(vault, FLEET_REL_PATH));
 }
 function isGitVault(vault) {
   return Boolean(git(vault, ["rev-parse", "--absolute-git-dir"]));
@@ -6421,35 +7070,21 @@ export {
   getCliSessionId,
   acquireOwnedSyncLock,
   releaseOwnedSyncLock,
+  extractBodyWikilinks,
+  buildWikilinkResolver,
   buildWikilinkAdjacency,
   toUndirectedWeighted,
   louvain,
   communityCohesion,
-  CONFIG_KEYS,
-  isValidWikiProfileKey,
-  profileKey,
-  parseDotenvText,
-  parseDotenvFile,
-  writeDotenv,
-  resolveInitTimePath,
-  resolveRuntimePath,
-  runOrphans,
-  runAudit,
+  extractIssuePage,
+  runLinks,
   extractTaxonomy,
   taxonomyCommentForPage,
   reconcileTaxonomyDocument,
   mergeTaxonomyConflict,
-  runLinks,
   runTagAudit,
   runIndexCheck,
-  FLEET_REL_PATH,
-  runFleetValidate,
-  runFleetContext,
-  loadFleetManifestAndHost,
-  snapshotterAliasForLocalHost,
-  satelliteGateFromFleetLoad,
-  loadFleetManifest,
-  resolveFleetHostId,
+  runIndexLinkFormat,
   planRawStructuralMove,
   applyRawStructuralMove,
   REDACTED_MALFORMED_REFERENCE,
@@ -6460,8 +7095,16 @@ export {
   runStale,
   runPagesize,
   runLogRotate,
+  CONFIG_KEYS,
+  isValidWikiProfileKey,
+  profileKey,
+  parseDotenvText,
+  parseDotenvFile,
+  writeDotenv,
+  resolveInitTimePath,
+  resolveRuntimePath,
+  runOrphans,
   runTopicMapCheck,
-  runIndexLinkFormat,
   normalizeRemoteRoot,
   buildRemoteObjectPath,
   isValidRemoteDeleteCap,
@@ -6470,10 +7113,20 @@ export {
   rewriteRawSourceReferences,
   snapshotMaintainedPageState,
   runDedup,
+  runAudit,
   runFrontmatterFix,
   assessSourceIdentity,
+  defaultLintRunner,
   runLint,
   runSyncLintDelta,
+  FLEET_REL_PATH,
+  runFleetValidate,
+  runFleetContext,
+  loadFleetManifestAndHost,
+  snapshotterAliasForLocalHost,
+  satelliteGateFromFleetLoad,
+  loadFleetManifest,
+  resolveFleetHostId,
   git,
   gitStrict,
   VAULT_COMMIT_PATHSPEC,