skillwiki 0.9.43 → 0.9.45

package/dist/{chunk-XBYPWCIS.js → chunk-RYTUYQFQ.js}

@@ -663,6 +663,24 @@ import { readFile as readFile2, readdir, stat } from "fs/promises";
 import { join as join2, relative as relative2, sep as sep2 } from "path";
 var TYPED_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
 var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules"]);
+var DEFAULT_IO_CONCURRENCY = 12;
+function vaultIoConcurrency() {
+  const raw = Number.parseInt(process.env.SKILLWIKI_VAULT_IO_CONCURRENCY ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? Math.min(raw, 64) : DEFAULT_IO_CONCURRENCY;
+}
+async function mapWithConcurrency(items, limit, mapper) {
+  const out = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(Math.max(1, limit), items.length) }, async () => {
+    for (; ; ) {
+      const index = next++;
+      if (index >= items.length) return;
+      out[index] = await mapper(items[index], index);
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
 async function scanVault(root) {
   try {
     await stat(join2(root, "SCHEMA.md"));
@@ -683,18 +701,29 @@ async function scanVault(root) {
 async function walk(dir) {
   const entries = await readdir(dir, { withFileTypes: true });
   const out = [];
+  const subdirs = [];
   for (const e of entries) {
     const p = join2(dir, e.name);
     if (e.isDirectory()) {
       if (SKIP_DIRS.has(e.name)) continue;
-      out.push(...await walk(p));
+      subdirs.push(p);
     } else if (e.isFile() && e.name.endsWith(".md")) out.push(p);
   }
+  const nested = await mapWithConcurrency(subdirs, Math.min(8, vaultIoConcurrency()), walk);
+  for (const files of nested) out.push(...files);
   return out;
 }
 async function readPage(p) {
   return readFile2(p.absPath, "utf8");
 }
+async function readPageCached(p, cache) {
+  if (!cache) return readPage(p);
+  const existing = cache.get(p.absPath);
+  if (existing) return existing;
+  const pending = readPage(p);
+  cache.set(p.absPath, pending);
+  return pending;
+}
 
 // src/parsers/wikilinks.ts
 var FENCE = /```[\s\S]*?```|`[^`\n]*`/g;
@@ -715,20 +744,20 @@ function extractBodyWikilinks(body) {
 }
 
 // src/utils/community.ts
-async function buildWikilinkAdjacency(typedKnowledge) {
+async function buildWikilinkAdjacency(typedKnowledge, pageTextCache) {
   const adjacency = {};
   const slugToPath = {};
   for (const p of typedKnowledge) {
     const slug = p.relPath.replace(/\.md$/, "").split("/").pop();
     slugToPath[slug] = p.relPath;
   }
-  for (const p of typedKnowledge) {
-    const text = await readPage(p);
+  await mapWithConcurrency(typedKnowledge, vaultIoConcurrency(), async (p) => {
+    const text = await readPageCached(p, pageTextCache);
     const split = splitFrontmatter(text);
     const body = split.ok ? split.data.body : text;
     const links = extractBodyWikilinks(body);
     adjacency[p.relPath] = links.map((slug) => slugToPath[slug.split("/").pop()]).filter((x) => Boolean(x));
-  }
+  });
   return adjacency;
 }
 function toUndirectedWeighted(adj) {
@@ -1123,7 +1152,7 @@ async function runOrphans(input) {
     }
     vault = r.data.path;
   }
-  const scan = await scanVault(vault);
+  const scan = input.scan ? ok(input.scan) : await scanVault(vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
   const slugToPath = {};
   for (const p of scan.data.typedKnowledge) {
@@ -1134,8 +1163,8 @@ async function runOrphans(input) {
   }
   const adj = {};
   for (const p of scan.data.typedKnowledge) adj[p.relPath] = /* @__PURE__ */ new Set();
-  for (const p of scan.data.typedKnowledge) {
-    const text = await readPage(p);
+  await mapWithConcurrency(scan.data.typedKnowledge, vaultIoConcurrency(), async (p) => {
+    const text = await readPageCached(p, input.pageTextCache);
     const split = splitFrontmatter(text);
     const body = split.ok ? split.data.body : text;
     for (const slug of extractBodyWikilinks(body)) {
@@ -1145,7 +1174,7 @@ async function runOrphans(input) {
         adj[tgt].add(p.relPath);
       }
     }
-  }
+  });
   const orphans = Object.keys(adj).filter((k) => adj[k].size === 0);
   const componentOf = {};
   let cid = 0;
@@ -1459,24 +1488,27 @@ function buildSlugMap(pages) {
 
 // src/commands/links.ts
 async function runLinks(input) {
-  const scan = await scanVault(input.vault);
-  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
-  const allPages = [...scan.data.typedKnowledge, ...scan.data.raw, ...scan.data.workItems, ...scan.data.compound];
+  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 allPages = [...scan.typedKnowledge, ...scan.raw, ...scan.workItems, ...scan.compound];
   const slugs = buildSlugMap(allPages);
-  const broken = [];
-  for (const p of scan.data.typedKnowledge) {
-    const text = await readPage(p);
+  const perPage = await mapWithConcurrency(scan.typedKnowledge, vaultIoConcurrency(), async (p) => {
+    const text = await readPageCached(p, input.pageTextCache);
     const split = splitFrontmatter(text);
     const body = split.ok ? split.data.body : text;
     const lines = body.split("\n");
+    const broken2 = [];
     for (const slug of extractBodyWikilinks(body)) {
       const tail = slug.split("/").pop().replace(/\.md$/, "");
       if (!slugs.has(tail.toLowerCase())) {
         const line = lines.findIndex((l) => l.includes(`[[${slug}`));
-        broken.push({ page: p.relPath, slug, line: line >= 0 ? line + 1 : 0 });
+        broken2.push({ page: p.relPath, slug, line: line >= 0 ? line + 1 : 0 });
       }
     }
-  }
+    return broken2;
+  });
+  const broken = perPage.flat();
   if (broken.length > 0) {
     return { exitCode: ExitCode.BROKEN_WIKILINKS, result: ok({ broken, humanHint: `broken: ${broken.length}
 ${broken.map((b) => `  ${b.page}:[[${b.slug}]] (line ${b.line})`).join("\n")}` }) };
@@ -1515,24 +1547,33 @@ function extractTaxonomy(schemaText) {
 
 // src/commands/tag-audit.ts
 async function runTagAudit(input) {
-  const scan = await scanVault(input.vault);
-  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  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 readFile5(join6(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);
   const violations = [];
-  for (const p of scan.data.typedKnowledge) {
-    const text = await readPage(p);
+  const perPage = await mapWithConcurrency(scan.typedKnowledge, vaultIoConcurrency(), async (p) => {
+    const text = await readPageCached(p, input.pageTextCache);
     const fm = extractFrontmatter(text);
-    if (!fm.ok) return { exitCode: ExitCode.INVALID_FRONTMATTER, result: fm };
+    if (!fm.ok) return fm;
+    const pageViolations = [];
     const tags = fm.data.tags;
-    if (!Array.isArray(tags)) continue;
+    if (!Array.isArray(tags)) return pageViolations;
     for (const t of tags) {
       if (typeof t === "string" && !allowed.has(t)) {
-        violations.push({ page: p.relPath, tag: t });
+        pageViolations.push({ page: p.relPath, tag: t });
       }
     }
+    return pageViolations;
+  });
+  for (const result of perPage) {
+    if (!Array.isArray(result)) {
+      return { exitCode: ExitCode.INVALID_FRONTMATTER, result };
+    }
+    violations.push(...result);
   }
   if (violations.length > 0) {
     return { exitCode: ExitCode.TAG_NOT_IN_TAXONOMY, result: ok({ violations, taxonomy: tax.data, humanHint: violations.map((v) => `${v.page}: "${v.tag}" not in taxonomy`).join("\n") }) };
@@ -1544,7 +1585,7 @@ async function runTagAudit(input) {
 import { readFile as readFile6 } from "fs/promises";
 import { join as join7 } from "path";
 async function runIndexCheck(input) {
-  const scan = await scanVault(input.vault);
+  const scan = input.scan ? ok(input.scan) : await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
   let indexText = "";
   try {
@@ -1671,8 +1712,9 @@ function daysSince(isoDate2) {
   return Math.floor((Date.now() - Date.parse(isoDate2)) / 864e5);
 }
 async function runStale(input) {
-  const scan = await scanVault(input.vault);
-  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  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 staleTranscripts = [];
   const incompleteWorkItems = [];
   const archived = [];
@@ -1734,16 +1776,16 @@ async function runStale(input) {
   const TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "abandoned", "done", "invalid"]);
   const KIND_FROM_FILENAME = /^(?:\d{4}-\d{2}-\d{2})-(task|bug|idea|note|observation)-.+\.md$/;
   const LOOP_CYCLE_PATTERN = /loop-cycle-/;
-  let transcripts = scan.data.raw.filter((p) => p.relPath.startsWith("raw/transcripts/") && p.relPath.endsWith(".md"));
+  let transcripts = scan.raw.filter((p) => p.relPath.startsWith("raw/transcripts/") && p.relPath.endsWith(".md"));
   const claimedPaths = /* @__PURE__ */ new Set();
   const transcriptMeta = /* @__PURE__ */ new Map();
-  for (const t of transcripts) {
+  const transcriptEntries = await mapWithConcurrency(transcripts, vaultIoConcurrency(), async (t) => {
     try {
-      const content = await readFile7(join9(input.vault, t.relPath), "utf8");
+      const content = await readPageCached(t, input.pageTextCache);
       const fm = extractFrontmatter(content);
       let kind = fm.ok && typeof fm.data.kind === "string" ? fm.data.kind : "";
       let project = fm.ok && typeof fm.data.project === "string" ? fm.data.project : "";
-      if (input.project && !project.includes(input.project)) continue;
+      if (input.project && !project.includes(input.project)) return null;
       let inferred = false;
       if (input.forceScan && !kind) {
         const basename3 = t.relPath.split("/").pop();
@@ -1769,9 +1811,13 @@ async function runStale(input) {
           }
         }
       }
-      transcriptMeta.set(t.relPath, { kind, project, slug: extractSlug(project), inferred });
+      return [t.relPath, { kind, project, slug: extractSlug(project), inferred }];
     } catch {
+      return null;
     }
+  });
+  for (const entry of transcriptEntries) {
+    if (entry) transcriptMeta.set(entry[0], entry[1]);
   }
   for (const t of transcripts) {
     const datePrefix = t.relPath.split("/").pop().slice(0, 10);
@@ -1806,7 +1852,7 @@ async function runStale(input) {
       }
     }
   }
-  for (const [relDir] of workDirs) {
+  await mapWithConcurrency([...workDirs.keys()], vaultIoConcurrency(), async (relDir) => {
     const specPath = join9(input.vault, relDir, "spec.md");
     try {
       const specContent = await readFile7(specPath, "utf8");
@@ -1817,7 +1863,7 @@ async function runStale(input) {
       }
     } catch {
     }
-  }
+  });
   const unclaimedTranscripts = [];
   const CLAIMABLE_KINDS = /* @__PURE__ */ new Set(["task", "bug"]);
   for (const t of transcripts) {
@@ -1852,42 +1898,45 @@ async function runStale(input) {
     }
   }
   const stale = [];
-  for (const page of scan.data.typedKnowledge) {
+  const stalePageResults = await mapWithConcurrency(scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
     try {
-      const text = await readFile7(join9(input.vault, page.relPath), "utf8");
+      const text = await readPageCached(page, input.pageTextCache);
       const fm = extractFrontmatter(text);
       if (fm.ok && typeof fm.data.updated === "string") {
         if (input.project) {
           const pp = fm.data.provenance_projects;
           const linked = Array.isArray(pp) && pp.some((p) => String(p).includes(input.project));
-          if (!linked) continue;
+          if (!linked) return null;
         }
         const age = daysSince(fm.data.updated);
         const threshold = typeof fm.data.stale_ttl === "number" && fm.data.stale_ttl > 0 ? fm.data.stale_ttl : input.days;
         if (age >= threshold) {
-          stale.push({ page: page.relPath, reason: `updated ${age} days ago (threshold: ${threshold})` });
+          return { page: page.relPath, reason: `updated ${age} days ago (threshold: ${threshold})` };
         }
       }
     } catch {
     }
-  }
+    return null;
+  });
+  stale.push(...stalePageResults.filter((item) => item !== null));
   const staleSections = [];
-  for (const page of scan.data.typedKnowledge) {
+  const staleSectionResults = await mapWithConcurrency(scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+    const pageSections = [];
     try {
-      const text = await readFile7(join9(input.vault, page.relPath), "utf8");
+      const text = await readPageCached(page, input.pageTextCache);
       const projectFilter = input.project;
       if (projectFilter) {
         const fm = extractFrontmatter(text);
         if (fm.ok) {
           const pp = fm.data.provenance_projects;
           const linked = Array.isArray(pp) && pp.some((p) => String(p).includes(projectFilter));
-          if (!linked) continue;
+          if (!linked) return pageSections;
         }
       }
       const annotations = parseExpiryAnnotations(text, page.relPath);
       for (const ann of annotations) {
         if (daysSince(ann.expires) >= 0) {
-          staleSections.push({
+          pageSections.push({
             page: ann.page,
             heading: ann.heading,
             line: ann.line,
@@ -1900,14 +1949,16 @@ async function runStale(input) {
       }
     } catch {
     }
-  }
+    return pageSections;
+  });
+  staleSections.push(...staleSectionResults.flat());
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   if (input.archive) {
     const archiveDir = join9(input.vault, "_archive", today);
     await mkdir3(archiveDir, { recursive: true });
     const citedRawPaths = /* @__PURE__ */ new Set();
-    for (const page of scan.data.typedKnowledge) {
-      const text = await readFile7(join9(input.vault, page.relPath), "utf8").catch(() => "");
+    for (const page of scan.typedKnowledge) {
+      const text = await readPageCached(page, input.pageTextCache).catch(() => "");
       for (const line of text.split("\n")) {
         for (const m of line.matchAll(/\^\[(raw\/[^\]]+)\]/g)) {
           citedRawPaths.add(m[1]);
@@ -1982,16 +2033,16 @@ async function runStale(input) {
 
 // src/commands/pagesize.ts
 async function runPagesize(input) {
-  const scan = await scanVault(input.vault);
-  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
-  const oversized = [];
-  for (const p of scan.data.typedKnowledge) {
-    const text = await readPage(p);
+  const scanResult = input.scan ? ok(input.scan) : await scanVault(input.vault);
+  if (!scanResult.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scanResult };
+  const perPage = await mapWithConcurrency(scanResult.data.typedKnowledge, vaultIoConcurrency(), async (p) => {
+    const text = await readPageCached(p, input.pageTextCache);
     const split = splitFrontmatter(text);
     const body = split.ok ? split.data.body : text;
     const count = body.split("\n").length;
-    if (count > input.lines) oversized.push({ page: p.relPath, lines: count });
-  }
+    return count > input.lines ? { page: p.relPath, lines: count } : null;
+  });
+  const oversized = perPage.filter((item) => item !== null);
   if (oversized.length > 0) return { exitCode: ExitCode.PAGE_TOO_LARGE, result: ok({ oversized, humanHint: oversized.map((p) => `${p.page}: ${p.lines} lines`).join("\n") }) };
   return { exitCode: ExitCode.OK, result: ok({ oversized, humanHint: "all pages within size limit" }) };
 }
@@ -2055,7 +2106,7 @@ Chronological action log. Newest entries last. Skill writes append entries; lint
 var DEFAULT_THRESHOLD = 200;
 async function runTopicMapCheck(input) {
   const threshold = input.threshold ?? DEFAULT_THRESHOLD;
-  const scan = await scanVault(input.vault);
+  const scan = input.scan ? ok(input.scan) : await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
   const page_count = scan.data.typedKnowledge.length;
   const recommended = page_count >= threshold;
@@ -2152,23 +2203,28 @@ async function runDedup(input) {
   if (input.remoteDelete && !input.apply && !input.manifestIn) {
     return { exitCode: ExitCode.USAGE, result: err("USAGE", { message: "--remote-delete requires --apply or --manifest-in" }) };
   }
-  const scan = await scanVault(input.vault);
-  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  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 manifestFromFile = input.manifestIn ? readManifest(input.manifestIn) : null;
   if (manifestFromFile && !manifestFromFile.ok) {
     return { exitCode: ExitCode.INVALID_FRONTMATTER, result: manifestFromFile };
   }
   const hashMap = /* @__PURE__ */ new Map();
   let totalFiles = 0;
-  for (const raw of scan.data.raw) {
-    const fm = extractFrontmatter(await readPage(raw));
-    if (!fm.ok) continue;
+  const rawEntries = await mapWithConcurrency(scan.raw, vaultIoConcurrency(), async (raw) => {
+    const fm = extractFrontmatter(await readPageCached(raw, input.pageTextCache));
+    if (!fm.ok) return null;
     const sha = typeof fm.data.sha256 === "string" ? fm.data.sha256 : null;
-    if (!sha || sha.length !== 64) continue;
+    if (!sha || sha.length !== 64) return null;
+    return { sha, relPath: raw.relPath };
+  });
+  for (const entry of rawEntries) {
+    if (!entry) continue;
     totalFiles++;
-    const existing = hashMap.get(sha);
-    if (existing) existing.push(raw.relPath);
-    else hashMap.set(sha, [raw.relPath]);
+    const existing = hashMap.get(entry.sha);
+    if (existing) existing.push(entry.relPath);
+    else hashMap.set(entry.sha, [entry.relPath]);
   }
   const canonicalPolicy = input.canonicalPolicy ?? "stable-path";
   const duplicates = [...hashMap.entries()].filter(([, files]) => files.length > 1).map(([sha256, files]) => ({ sha256, files: orderFiles(files, canonicalPolicy) }));
@@ -2205,7 +2261,7 @@ async function runDedup(input) {
         replacements.set(duplicate, entry.canonical);
       }
     }
-    for (const page of scan.data.allMarkdown.filter((p) => !p.relPath.startsWith("raw/"))) {
+    for (const page of scan.allMarkdown.filter((p) => !p.relPath.startsWith("raw/"))) {
       const text = readFileSync2(join12(input.vault, page.relPath), "utf-8");
       let updated = text;
       let changed = false;
@@ -2504,9 +2560,9 @@ import { join as join15, relative as relative3, sep as sep3 } from "path";
 
 // src/commands/sparse-community.ts
 async function runSparseCommunity(input) {
-  const scan = await scanVault(input.vault);
+  const scan = input.scan ? ok(input.scan) : await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
-  const adjacency = await buildWikilinkAdjacency(scan.data.typedKnowledge);
+  const adjacency = await buildWikilinkAdjacency(scan.data.typedKnowledge, input.pageTextCache);
   const communities = findSparseCommunities(adjacency, {
     minSize: input.minSize,
     maxCohesion: input.maxCohesion
@@ -2517,28 +2573,29 @@ async function runSparseCommunity(input) {
 
 // src/commands/raw-body-dedup.ts
 import { createHash as createHash3 } from "crypto";
-async function runRawBodyDedup(vault) {
-  const scan = await scanVault(vault);
-  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+async function runRawBodyDedup(vault, scan, pageTextCache) {
+  const scanResult = scan ? ok(scan) : await scanVault(vault);
+  if (!scanResult.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scanResult };
   const bodyHashMap = /* @__PURE__ */ new Map();
-  let totalFiles = 0;
-  for (const raw of scan.data.raw) {
-    const text = await readPage(raw);
+  const rawEntries = await mapWithConcurrency(scanResult.data.raw, vaultIoConcurrency(), async (raw) => {
+    const text = await readPageCached(raw, pageTextCache);
     const split = splitFrontmatter(text);
-    if (!split.ok) continue;
-    totalFiles++;
+    if (!split.ok) return null;
     const bodyHash = createHash3("sha256").update(split.data.body).digest("hex");
     const fm = extractFrontmatter(text);
     let fmSha256 = null;
     if (fm.ok && typeof fm.data.sha256 === "string" && fm.data.sha256.length === 64) {
       fmSha256 = fm.data.sha256;
     }
-    const existing = bodyHashMap.get(bodyHash);
-    if (existing) {
-      existing.push({ relPath: raw.relPath, sha256: fmSha256 });
-    } else {
-      bodyHashMap.set(bodyHash, [{ relPath: raw.relPath, sha256: fmSha256 }]);
-    }
+    return { bodyHash, relPath: raw.relPath, sha256: fmSha256 };
+  });
+  let totalFiles = 0;
+  for (const entry of rawEntries) {
+    if (!entry) continue;
+    totalFiles++;
+    const existing = bodyHashMap.get(entry.bodyHash);
+    if (existing) existing.push({ relPath: entry.relPath, sha256: entry.sha256 });
+    else bodyHashMap.set(entry.bodyHash, [{ relPath: entry.relPath, sha256: entry.sha256 }]);
   }
   const duplicates = [];
   for (const [bodyHash, files] of bodyHashMap) {
@@ -2562,7 +2619,7 @@ import { dirname as dirname6, join as join14, posix, resolve as resolve4 } from
 var MAX_PATH_LENGTH = 240;
 var WINDOWS_ABSOLUTE_PATH_LIMIT = 259;
 async function runPathTooLong(input) {
-  const scan = await scanVault(input.vault);
+  const scan = input.scan ? ok(input.scan) : await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
   const violations = findPathTooLongViolations(scan.data.allMarkdown, MAX_PATH_LENGTH);
   if (violations.length > 0) {
@@ -3038,6 +3095,37 @@ function summarizeBucket(bucket, severity, vaultPath, examplesLimit) {
     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) {
+  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 output = {
+    vault: { path: input.vault, source: input.source ?? "resolved" },
+    summary,
+    by_severity: filtered,
+    fixed,
+    unresolved,
+    humanHint: `--only ${input.only}
+${match.length === 0 ? "0 violations" : match.map((b) => `  ${b.kind}: ${b.items.length}`).join("\n")}`
+  };
+  if (input.fix) appendLintFixLastOp(input.vault, fixed);
+  return {
+    exitCode,
+    result: ok(input.summary ? summarizeLintOutput(output, input.examplesLimit) : output)
+  };
+}
 function recomputeRawSha256IfPresent(content) {
   const split = splitFrontmatter(content);
   if (!split.ok) return content;
@@ -3119,7 +3207,7 @@ async function runCliRefsOnly(input) {
   const cliRefFlags = [];
   const cliSurface = buildCliSurface();
   for (const page of pages.data) {
-    const text = await readPage(page);
+    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})`);
@@ -3142,6 +3230,151 @@ ${cliRefFlags.length === 0 ? "0 violations" : `  cli_refs: ${cliRefFlags.length}
     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();
+  const rawIdentityConflicts = [];
+  const rawPageBodyByPath = /* @__PURE__ */ new Map();
+  const rawResults = await mapWithConcurrency(scan.raw, vaultIoConcurrency(), async (raw) => {
+    const flags = [];
+    const frontmatterFlags = [];
+    const conflicts = [];
+    let body;
+    try {
+      const text = await readPageCached(raw, pageTextCache);
+      const split = splitFrontmatter(text);
+      if (!split.ok) return { relPath: raw.relPath, body, flags, frontmatterFlags, conflicts };
+      body = split.data.body;
+      if (/^source_url:\s*file:\/\//m.test(split.data.rawFrontmatter)) {
+        flags.push(raw.relPath);
+        frontmatterFlags.push(raw.relPath);
+      }
+      if (options.includeRawIdentityConflicts) {
+        const sourceUrl = split.data.rawFrontmatter.match(/^source_url:\s*(.+)$/m)?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "";
+        const assessment = assessSourceIdentity({
+          rawPath: raw.relPath,
+          sourceUrl,
+          body: split.data.body
+        });
+        if (assessment.status === "conflict") {
+          conflicts.push({
+            file: raw.relPath,
+            status: assessment.status,
+            reasons: assessment.reasons,
+            pathSignals: assessment.pathSignals,
+            sourceSignals: assessment.sourceSignals,
+            bodySignals: assessment.bodySignals
+          });
+        }
+      }
+    } catch {
+    }
+    return { relPath: raw.relPath, body, flags, frontmatterFlags, conflicts };
+  });
+  for (const result of rawResults) {
+    if (result.body !== void 0) rawPageBodyByPath.set(result.relPath, result.body);
+    for (const flag of result.flags) fileSourceUrlFlags.add(flag);
+    for (const flag of result.frontmatterFlags) fileSourceUrlFrontmatterFlags.add(flag);
+    rawIdentityConflicts.push(...result.conflicts);
+  }
+  const canonicalSourcePages = [
+    ...scan.raw,
+    ...scan.typedKnowledge,
+    ...scan.compound,
+    ...scan.workItems
+  ].filter(shouldCheckCanonicalLocalSourceAssertion);
+  const canonicalFlags = await mapWithConcurrency(canonicalSourcePages, vaultIoConcurrency(), async (page) => {
+    try {
+      let body = rawPageBodyByPath.get(page.relPath);
+      if (body === void 0) {
+        const text = await readPageCached(page, pageTextCache);
+        const split = splitFrontmatter(text);
+        if (!split.ok) return null;
+        body = split.data.body;
+      }
+      return hasCanonicalLocalSourceAssertion(body) ? page.relPath : null;
+    } catch {
+      return null;
+    }
+  });
+  for (const flag of canonicalFlags) {
+    if (flag) fileSourceUrlFlags.add(flag);
+  }
+  return { fileSourceUrlFlags, fileSourceUrlFrontmatterFlags, rawIdentityConflicts };
+}
+async function applyFileSourceUrlFix(input, scan, fileSourceUrlFlags, fileSourceUrlFrontmatterFlags, fixed, unresolved) {
+  if (!input.fix || fileSourceUrlFrontmatterFlags.size === 0) return fileSourceUrlFlags;
+  const fileFixed = [];
+  for (const relPath of fileSourceUrlFrontmatterFlags) {
+    try {
+      const absPath = `${input.vault}/${relPath}`;
+      const raw = await readFile12(absPath, "utf8");
+      const parts = raw.split("---", 3);
+      if (parts.length < 3) {
+        unresolved.push(relPath);
+        continue;
+      }
+      const rawFm = parts[1];
+      const rest = parts[2];
+      const sourceMatch = rest.match(/^source:\s*"?(https?:\/\/[^\s\n"]+)"?\s*$/m);
+      if (!sourceMatch) {
+        unresolved.push(relPath);
+        continue;
+      }
+      const realUrl = sourceMatch[1];
+      const newRawFm = rawFm.replace(/^source_url:\s*file:\/\/[^\n]+/m, `source_url: ${realUrl}`);
+      const newContent = `---${newRawFm}---${rest}`;
+      const w = await safeWritePage(absPath, newContent);
+      if (!w.ok) {
+        unresolved.push(relPath);
+        continue;
+      }
+      fileFixed.push(relPath);
+    } catch {
+      unresolved.push(relPath);
+    }
+  }
+  fixed.push(...fileFixed);
+  if (fileFixed.length === 0) return fileSourceUrlFlags;
+  const remaining = new Set(fileSourceUrlFlags);
+  for (const relPath of fileFixed) {
+    try {
+      const page = scan.allMarkdown.find((p) => p.relPath === relPath);
+      if (!page) {
+        remaining.delete(relPath);
+        continue;
+      }
+      const text = await readPage(page);
+      const split = splitFrontmatter(text);
+      if (!split.ok) continue;
+      const stillHasFileSourceUrl = /^source_url:\s*file:\/\//m.test(split.data.rawFrontmatter);
+      const stillHasCanonicalBodyAssertion = shouldCheckCanonicalLocalSourceAssertion(page) && hasCanonicalLocalSourceAssertion(split.data.body);
+      if (!stillHasFileSourceUrl && !stillHasCanonicalBodyAssertion) {
+        remaining.delete(relPath);
+      }
+    } catch {
+    }
+  }
+  return remaining;
+}
+async function runFileSourceUrlOnly(input) {
+  const scanResult = await scanVault(input.vault);
+  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);
+}
 async function runLint(input) {
   if (input.only && !KNOWN_BUCKETS.includes(input.only)) {
     return {
@@ -3152,21 +3385,38 @@ async function runLint(input) {
   if (input.only === "cli_refs") {
     return runCliRefsOnly(input);
   }
+  if (input.only === "file_source_url") {
+    return runFileSourceUrlOnly(input);
+  }
   const shouldFix = (bucket) => !!input.fix && (!input.only || input.only === bucket);
   const buckets = {};
   const fixed = [];
   const unresolved = [];
-  const links = await runLinks({ vault: input.vault });
+  const scanResult = await scanVault(input.vault);
+  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 {
+        await readPageCached(page, pageTextCache);
+      } catch {
+      }
+    });
+  }
+  const links = await runLinks({ vault: input.vault, 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: input.vault });
+  const tags = await runTagAudit({ vault: input.vault, 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: input.vault });
+  const idx = await runIndexCheck({ vault: input.vault, 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,
@@ -3177,34 +3427,34 @@ async function runLint(input) {
   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: input.vault, days: input.days });
+  const staleResult = await runStale({ vault: input.vault, 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: input.vault, lines: input.lines });
+  const pagesize = await runPagesize({ vault: input.vault, 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: input.vault, 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: input.vault });
+  const orphans = await runOrphans({ vault: input.vault, 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: input.vault });
+  const sparse = await runSparseCommunity({ vault: input.vault, scan, pageTextCache });
   if (sparse.result.ok && sparse.result.data.communities.length > 0) {
     buckets.sparse_community = sparse.result.data.communities;
   }
-  const topicMap = await runTopicMapCheck({ vault: input.vault });
+  const topicMap = await runTopicMapCheck({ vault: input.vault, 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: input.vault });
+  const dedup = await runDedup({ vault: input.vault, scan, pageTextCache });
   if (dedup.result.ok && dedup.result.data.duplicates.length > 0) buckets.raw_dedup = dedup.result.data.duplicates;
-  const bodyDedup = await runRawBodyDedup(input.vault);
+  const bodyDedup = await runRawBodyDedup(input.vault, 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),
@@ -3213,40 +3463,35 @@ async function runLint(input) {
   }
   const compoundRefs = await validateCompoundReferences(input.vault);
   if (compoundRefs.ok && compoundRefs.data.length > 0) buckets.compound_refs = compoundRefs.data;
-  const pathCheck = await runPathTooLong({ vault: input.vault });
+  const pathCheck = await runPathTooLong({ vault: input.vault, scan });
   if (pathCheck.result.ok && pathCheck.result.data.violations.length > 0) buckets.path_too_long = pathCheck.result.data.violations;
-  const scan = await scanVault(input.vault);
-  const allPages = scan.ok ? [...scan.data.typedKnowledge, ...scan.data.raw, ...scan.data.workItems, ...scan.data.compound] : [];
-  const slugs = scan.ok ? buildSlugMap(allPages) : /* @__PURE__ */ new Map();
-  if (scan.ok) {
-    const sensitiveFlags = [];
-    for (const page of scan.data.allMarkdown) {
-      try {
-        const text = await readPage(page);
-        const findings = scanSensitiveContent(text, { file: page.relPath });
-        sensitiveFlags.push(...findings);
-      } catch {
-      }
-    }
-    if (sensitiveFlags.length > 0) buckets.sensitive_content = sensitiveFlags;
-    const fmYamlInvalid = [];
-    for (const page of scan.data.allMarkdown) {
+  const allPages = [...scan.typedKnowledge, ...scan.raw, ...scan.workItems, ...scan.compound];
+  const slugs = buildSlugMap(allPages);
+  {
+    const allPageResults = await mapWithConcurrency(scan.allMarkdown, vaultIoConcurrency(), async (page) => {
+      const sensitiveFlags2 = [];
+      let fmYamlInvalid2 = null;
       try {
-        const text = await readPage(page);
+        const text = await readPageCached(page, pageTextCache);
+        sensitiveFlags2.push(...scanSensitiveContent(text, { file: page.relPath }));
         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 });
+          fmYamlInvalid2 = { path: page.relPath, message };
         }
       } catch {
       }
-    }
+      return { sensitiveFlags: sensitiveFlags2, fmYamlInvalid: fmYamlInvalid2 };
+    });
+    const sensitiveFlags = allPageResults.flatMap((result) => result.sensitiveFlags);
+    if (sensitiveFlags.length > 0) buckets.sensitive_content = sensitiveFlags;
+    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.data.raw) {
+    for (const raw of scan.raw) {
       const parts = raw.relPath.split("/");
       if (parts.length === 3) {
         const stem = parts[2].replace(/\.md$/, "");
@@ -3265,55 +3510,10 @@ async function runLint(input) {
     if (subDirDupes.length > 0) {
       buckets.raw_subdirectory_duplicate = subDirDupes;
     }
-    const fileSourceUrlFlags = /* @__PURE__ */ new Set();
-    const fileSourceUrlFrontmatterFlags = /* @__PURE__ */ new Set();
-    const rawIdentityConflicts = [];
-    const rawPageBodyByPath = /* @__PURE__ */ new Map();
-    for (const raw of scan.data.raw) {
-      const text = await readPage(raw);
-      const split = splitFrontmatter(text);
-      if (!split.ok) continue;
-      rawPageBodyByPath.set(raw.relPath, split.data.body);
-      if (/^source_url:\s*file:\/\//m.test(split.data.rawFrontmatter)) {
-        fileSourceUrlFlags.add(raw.relPath);
-        fileSourceUrlFrontmatterFlags.add(raw.relPath);
-      }
-      const sourceUrl = split.data.rawFrontmatter.match(/^source_url:\s*(.+)$/m)?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "";
-      const assessment = assessSourceIdentity({
-        rawPath: raw.relPath,
-        sourceUrl,
-        body: split.data.body
-      });
-      if (assessment.status === "conflict") {
-        rawIdentityConflicts.push({
-          file: raw.relPath,
-          status: assessment.status,
-          reasons: assessment.reasons,
-          pathSignals: assessment.pathSignals,
-          sourceSignals: assessment.sourceSignals,
-          bodySignals: assessment.bodySignals
-        });
-      }
-    }
-    const canonicalSourcePages = [
-      ...scan.data.raw,
-      ...scan.data.typedKnowledge,
-      ...scan.data.compound,
-      ...scan.data.workItems
-    ];
-    for (const page of canonicalSourcePages) {
-      if (!shouldCheckCanonicalLocalSourceAssertion(page)) continue;
-      let body = rawPageBodyByPath.get(page.relPath);
-      if (body === void 0) {
-        const text = await readPage(page);
-        const split = splitFrontmatter(text);
-        if (!split.ok) continue;
-        body = split.data.body;
-      }
-      if (hasCanonicalLocalSourceAssertion(body)) {
-        fileSourceUrlFlags.add(page.relPath);
-      }
-    }
+    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 = [];
@@ -3326,57 +3526,85 @@ async function runLint(input) {
     const brokenSourceFlags = /* @__PURE__ */ new Set();
     const missingTldrFlags = [];
     const missingDiagramFlags = [];
-    for (const page of scan.data.typedKnowledge) {
-      const text = await readPage(page);
-      const split = splitFrontmatter(text);
-      if (!split.ok) continue;
-      const body = split.data.body;
-      const rawFm = split.data.rawFrontmatter;
-      if (hasDuplicateFrontmatter(body)) dupFrontmatter.push(page.relPath);
-      if (isLegacyCitationStyle(body)) legacyPages.push(page.relPath);
-      if (hasOrphanedCitations(body)) orphanedPages.push(page.relPath);
-      if (hasWikilinkCitations(body)) wikilinkCitationFlags.push(page.relPath);
-      const sourcesEntries = extractSourceEntries(rawFm);
-      for (const entry of sourcesEntries) {
-        const rawPath = normalizeRawSourceTarget(entry);
-        if (!rawPath) continue;
-        if (!rawSourceTargetExistsSync(input.vault, rawPath)) {
-          brokenSourceFlags.add(`${page.relPath}: ${rawPath}`);
+    const typedPageResults = await mapWithConcurrency(scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      const result = {
+        legacyPages: [],
+        orphanedPages: [],
+        structFlags: [],
+        dupFrontmatter: [],
+        noOverview: [],
+        fmWikilinkFlags: [],
+        wikilinkCitationFlags: [],
+        brokenSourceFlags: [],
+        missingTldrFlags: [],
+        missingDiagramFlags: []
+      };
+      try {
+        const text = await readPageCached(page, pageTextCache);
+        const split = splitFrontmatter(text);
+        if (!split.ok) return result;
+        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(input.vault, rawPath)) {
+            result.brokenSourceFlags.push(`${page.relPath}: ${rawPath}`);
+          }
         }
-      }
-      for (const marker of extractCitationMarkers(body)) {
-        if (!rawSourceTargetExistsSync(input.vault, marker.target)) {
-          brokenSourceFlags.add(`${page.relPath}: ${marker.target}`);
+        for (const marker of extractCitationMarkers(body)) {
+          if (!rawSourceTargetExistsSync(input.vault, marker.target)) {
+            result.brokenSourceFlags.push(`${page.relPath}: ${marker.target}`);
+          }
         }
-      }
-      const fmLinks = rawFm.match(/\[\[([^\[\]|]+)(?:\|[^\[\]]*)?\]\]/g) ?? [];
-      for (const link of fmLinks) {
-        const target = link.replace(/^\[\[/, "").replace(/(?:\|[^\[\]]*)?\]\]$/, "").trim();
-        const tail = target.split("/").pop().replace(/\.md$/, "");
-        if (!slugs.has(tail.toLowerCase())) {
-          fmWikilinkFlags.push(`${page.relPath}: [[${target}]] does not resolve`);
+        const fmLinks = rawFm.match(/\[\[([^\[\]|]+)(?:\|[^\[\]]*)?\]\]/g) ?? [];
+        for (const link of fmLinks) {
+          const target = link.replace(/^\[\[/, "").replace(/(?:\|[^\[\]]*)?\]\]$/, "").trim();
+          const tail = target.split("/").pop().replace(/\.md$/, "");
+          if (!slugs.has(tail.toLowerCase())) {
+            result.fmWikilinkFlags.push(`${page.relPath}: [[${target}]] does not resolve`);
+          }
         }
-      }
-      const bodyLines = body.split("\n").filter((l) => l.trim().length > 0).length;
-      const hasOverview = /^## Overview/m.test(body);
-      if (!hasOverview) 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)) missingTldrFlags.push(page.relPath);
-      const fmData = extractFrontmatter(text);
-      const pageTags = fmData.ok && Array.isArray(fmData.data.tags) ? fmData.data.tags : [];
-      if (pageTags.includes("architecture") && !body.includes("```mermaid")) {
-        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`);
-          structFlags.push(`${page.relPath}: ${bodyLines} lines, ${reasons.join(", ")}`);
+        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);
+        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(", ")}`);
+          }
         }
+      } 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;
@@ -3390,19 +3618,20 @@ async function runLint(input) {
     if (missingDiagramFlags.length > 0) buckets.missing_diagram = missingDiagramFlags;
     const workItemHealth = [];
     const workItemDirs = /* @__PURE__ */ new Map();
-    for (const page of scan.data.workItems) {
+    for (const page of scan.workItems) {
       const dir = page.relPath.replace(/\/(spec|plan|log)\.md$/, "");
       const pages = workItemDirs.get(dir) ?? [];
       pages.push(page);
       workItemDirs.set(dir, pages);
     }
-    for (const [dir, pages] of workItemDirs) {
+    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 readPage(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;
@@ -3416,74 +3645,96 @@ async function runLint(input) {
         if (dateMatch) {
           const dirDate = Date.parse(dateMatch[1]);
           if (!isNaN(dirDate) && Date.now() - dirDate > 24 * 60 * 60 * 1e3) {
-            workItemHealth.push(`${dir}/spec.md: has spec but no plan after 24h`);
+            flags.push(`${dir}/spec.md: has spec but no plan after 24h`);
           }
         }
       }
       if (specPage && specStatus === "in-progress" && !specStarted) {
-        workItemHealth.push(`${specPage.relPath}: in-progress without started date`);
+        flags.push(`${specPage.relPath}: in-progress without started date`);
       }
-    }
+      return flags;
+    });
+    workItemHealth.push(...workItemHealthResults.flat());
     if (workItemHealth.length > 0) buckets.work_item_health = workItemHealth;
     const orphanedProjectPages = [];
-    for (const page of scan.data.typedKnowledge) {
-      const text = await readPage(page);
-      const fm = extractFrontmatter(text);
-      if (!fm.ok) continue;
-      const pp = fm.data.provenance_projects;
-      if (!Array.isArray(pp)) continue;
-      for (const entry of pp) {
-        const slugMatch = String(entry).match(/\[\[([^\]]+)\]\]/);
-        if (!slugMatch) continue;
-        const slug = slugMatch[1];
-        const knowledgePath = join15(input.vault, "projects", slug, "knowledge.md");
-        if (!existsSync4(knowledgePath)) continue;
-        const pageRef = page.relPath.replace(/\.md$/, "");
-        try {
-          const knowledgeContent = await readFile12(knowledgePath, "utf8");
+    const knowledgeContentCache = /* @__PURE__ */ new Map();
+    const readKnowledgeContent = (slug) => {
+      const existing = knowledgeContentCache.get(slug);
+      if (existing) return existing;
+      const knowledgePath = join15(input.vault, "projects", slug, "knowledge.md");
+      const pending = existsSync4(knowledgePath) ? readFile12(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}]]`)) {
-            orphanedProjectPages.push(`${page.relPath}: not in projects/${slug}/knowledge.md`);
+            flags.push(`${page.relPath}: not in projects/${slug}/knowledge.md`);
           }
-        } catch {
         }
+      } catch {
       }
-    }
+      return flags;
+    });
+    orphanedProjectPages.push(...orphanedProjectPageResults.flat());
     if (orphanedProjectPages.length > 0) buckets.orphaned_project_pages = orphanedProjectPages;
     const cliRefFlags = [];
     const cliSurface = buildCliSurface();
-    const allScanPages = [...scan.data.typedKnowledge];
-    for (const page of allScanPages) {
-      const text = await readPage(page);
-      const violations = validateCliRefs(text, page.relPath, cliSurface);
-      for (const v of violations) {
-        cliRefFlags.push(`${v.page}: ${v.ref} (${v.reason})`);
+    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})`);
+        }
+      } catch {
       }
-    }
+      return flags;
+    });
+    cliRefFlags.push(...cliRefResults.flat());
     if (cliRefFlags.length > 0) buckets.cli_refs = cliRefFlags;
     const staleSectionFlags = [];
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const approachingThreshold = 7;
-    for (const page of scan.data.typedKnowledge) {
+    const staleSectionResults = await mapWithConcurrency(scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      const flags = [];
       try {
-        const text = await readPage(page);
+        const text = await readPageCached(page, pageTextCache);
         const annotations = parseExpiryAnnotations(text, page.relPath);
         for (const ann of annotations) {
           if (ann.expires < today) {
-            staleSectionFlags.push(`${page.relPath}: section "${ann.heading}" expired on ${ann.expires}`);
+            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) {
-              staleSectionFlags.push(`${page.relPath}: section "${ann.heading}" expires in ${daysUntilExpiry} day(s) (${ann.expires})`);
+              flags.push(`${page.relPath}: section "${ann.heading}" expires in ${daysUntilExpiry} day(s) (${ann.expires})`);
             }
           }
         }
       } catch {
       }
-    }
+      return flags;
+    });
+    staleSectionFlags.push(...staleSectionResults.flat());
     if (staleSectionFlags.length > 0) buckets.stale_sections = staleSectionFlags;
     if (shouldFix("sensitive_content") && buckets.sensitive_content) {
       const sensitiveFixed = [];
-      for (const page of scan.data.allMarkdown) {
+      for (const page of scan.allMarkdown) {
         try {
           const raw = await readPage(page);
           const redacted = redactSensitiveContent(raw, { file: page.relPath });
@@ -3501,7 +3752,7 @@ async function runLint(input) {
       }
       fixed.push(...sensitiveFixed);
       const remainingSensitiveFlags = [];
-      for (const page of scan.data.allMarkdown) {
+      for (const page of scan.allMarkdown) {
         try {
           const text = await readPage(page);
           remainingSensitiveFlags.push(...scanSensitiveContent(text, { file: page.relPath }));
@@ -3790,60 +4041,9 @@ ${newBody}`;
       }
     }
     if (shouldFix("file_source_url") && fileSourceUrlFrontmatterFlags.size > 0) {
-      const FILE_FIXED = [];
-      for (const relPath of fileSourceUrlFrontmatterFlags) {
-        try {
-          const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile12(absPath, "utf8");
-          const parts = raw.split("---", 3);
-          if (parts.length < 3) {
-            unresolved.push(relPath);
-            continue;
-          }
-          const rawFm = parts[1];
-          const rest = parts[2];
-          const sourceMatch = rest.match(/^source:\s*"?(https?:\/\/[^\s\n"]+)"?\s*$/m);
-          if (!sourceMatch) {
-            unresolved.push(relPath);
-            continue;
-          }
-          const realUrl = sourceMatch[1];
-          const newRawFm = rawFm.replace(/^source_url:\s*file:\/\/[^\n]+/m, `source_url: ${realUrl}`);
-          const newContent = `---${newRawFm}---${rest}`;
-          const w = await safeWritePage(absPath, newContent);
-          if (!w.ok) {
-            unresolved.push(relPath);
-            continue;
-          }
-          FILE_FIXED.push(relPath);
-        } catch {
-          unresolved.push(relPath);
-        }
-      }
-      fixed.push(...FILE_FIXED);
-      if (FILE_FIXED.length > 0) {
-        const remaining = new Set(fileSourceUrlFlags);
-        for (const relPath of FILE_FIXED) {
-          try {
-            const page = scan.data.allMarkdown.find((p) => p.relPath === relPath);
-            if (!page) {
-              remaining.delete(relPath);
-              continue;
-            }
-            const text = await readPage(page);
-            const split = splitFrontmatter(text);
-            if (!split.ok) continue;
-            const stillHasFileSourceUrl = /^source_url:\s*file:\/\//m.test(split.data.rawFrontmatter);
-            const stillHasCanonicalBodyAssertion = shouldCheckCanonicalLocalSourceAssertion(page) && hasCanonicalLocalSourceAssertion(split.data.body);
-            if (!stillHasFileSourceUrl && !stillHasCanonicalBodyAssertion) {
-              remaining.delete(relPath);
-            }
-          } catch {
-          }
-        }
-        if (remaining.size > 0) buckets.file_source_url = [...remaining];
-        else delete buckets.file_source_url;
-      }
+      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) {
@@ -3863,7 +4063,7 @@ ${newBody}`;
       const invalidItems = buckets.frontmatter_yaml_invalid;
       const remaining = [];
       for (const item of invalidItems) {
-        const page = scan.data.allMarkdown.find((p) => p.relPath === item.path);
+        const page = scan.allMarkdown.find((p) => p.relPath === item.path);
         if (!page) {
           unresolved.push(item.path);
           remaining.push(item);
@@ -3909,30 +4109,7 @@ ${split.data.body}`;
   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 severity = ERROR_ORDER.includes(input.only) ? "error" : WARNING_ORDER.includes(input.only) ? "warning" : "info";
-    const filtered = severity === "error" ? { error: match, warning: [], info: [] } : severity === "warning" ? { error: [], warning: match, info: [] } : { error: [], warning: [], info: match };
-    const fSummary = {
-      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 fExit = ExitCode.OK;
-    if (fSummary.errors > 0) fExit = ExitCode.LINT_HAS_ERRORS;
-    else if (fSummary.warnings > 0 || fSummary.info > 0) fExit = ExitCode.LINT_HAS_WARNINGS;
-    const output2 = {
-      vault: { path: input.vault, source: input.source ?? "resolved" },
-      summary: fSummary,
-      by_severity: filtered,
-      fixed,
-      unresolved,
-      humanHint: `--only ${input.only}
-${match.length === 0 ? "0 violations" : match.map((b) => `  ${b.kind}: ${b.items.length}`).join("\n")}`
-    };
-    if (input.fix) appendLintFixLastOp(input.vault, fixed);
-    return {
-      exitCode: fExit,
-      result: ok(input.summary ? summarizeLintOutput(output2, input.examplesLimit) : output2)
-    };
+    return outputForOnlyBucket(input, match, fixed, unresolved);
   }
   const summary = {
     errors: errorOut.reduce((n, b) => n + b.items.length, 0),