skillwiki 0.10.47 → 0.10.49

package/dist/cli.js

@@ -40,7 +40,7 @@ import {
   scanConflictMarkerBlocksInText,
   snapshotterHealthChecks,
   upsertIndexEntry
-} from "./chunk-5JYOYMST.js";
+} from "./chunk-F7LXKP4T.js";
 import {
   normalizeDistTag,
   readCache,
@@ -56,6 +56,7 @@ import {
 } from "./chunk-GAU4D25O.js";
 import {
   FLEET_REL_PATH,
+  REDACTED_MALFORMED_REFERENCE,
   VAULT_COMMIT_PATHSPEC,
   acquireOwnedSyncLock,
   appendLastOp,
@@ -79,7 +80,9 @@ import {
   loadFleetManifestAndHost,
   markJournalSuperseded,
   mergeTaxonomyConflict,
+  normalizeProjectSlug,
   normalizeRemoteRoot,
+  parseActiveWorkPath,
   parseDotenvFile,
   parseDotenvText,
   parseJournalEnv,
@@ -119,6 +122,7 @@ import {
   runSyncUnlock,
   runTagAudit,
   runTopicMapCheck,
+  safeDiagnosticValue,
   safeWritePage,
   serializeJournalEnv,
   snapshotMaintainedPageState,
@@ -127,7 +131,7 @@ import {
   supersedeStaleReviewRequiredJournals,
   taxonomyCommentForPage,
   writeDotenv
-} from "./chunk-4SINVFR3.js";
+} from "./chunk-FXASPB3C.js";
 import {
   assertTargetInsideVault,
   atomicWriteText,
@@ -166,17 +170,20 @@ import {
   err,
   extractFrontmatter,
   isBlockedHost,
+  mapWithConcurrency,
   ok,
   readPage,
+  readPageCached,
   redactSensitiveContent,
   resolveReadOnlyVaultRoot,
   scanSensitiveContent,
   scanVault,
-  splitFrontmatter
+  splitFrontmatter,
+  vaultIoConcurrency
 } from "./chunk-EVQASYII.js";
 
 // src/cli.ts
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 import { Command } from "commander";
 
 // src/utils/output.ts
@@ -2016,9 +2023,6 @@ function extractDate(filename) {
 function extractSlugFromFilename(filename) {
   return filename.replace(/^\d{4}-\d{2}-\d{2}-/, "").replace(/^(task|bug|idea|note|observation)-/, "").replace(/\.md$/, "");
 }
-function extractProjectSlug(projectField) {
-  return projectField.replace(/^\[\[/, "").replace(/\]\]$/, "").replace(/^"|"$/g, "");
-}
 async function runClaim(input) {
   if (!existsSync2(input.vault) || !statSync(input.vault).isDirectory()) {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { path: input.vault }) };
@@ -2029,10 +2033,19 @@ async function runClaim(input) {
   }
   const content = await readFile5(absTranscript, "utf8");
   const fm = extractFrontmatter(content);
-  let projectSlug = input.project;
-  if (!projectSlug && fm.ok && typeof fm.data.project === "string") {
-    projectSlug = extractProjectSlug(fm.data.project);
+  const explicitProject = fm.ok ? normalizeProjectSlug(fm.data.project) : void 0;
+  if (input.project && explicitProject && explicitProject !== input.project) {
+    return {
+      exitCode: ExitCode.SCHEME_REJECTED,
+      result: err("PROJECT_MISMATCH", {
+        message: `--project ${input.project} does not match the capture's explicit project ${explicitProject}`,
+        project: input.project,
+        captureProject: explicitProject,
+        transcript: input.transcript
+      })
+    };
   }
+  const projectSlug = explicitProject ?? input.project;
   if (!projectSlug) {
     return {
       exitCode: ExitCode.SCHEME_REJECTED,
@@ -3525,10 +3538,10 @@ async function runRemove(input) {
   const tombstonePath = await writeDeleteIntent(input.vault, intent);
   await unlink2(join19(input.vault, relPath));
   if (relPath.endsWith(".md") && !relPath.startsWith("raw/")) {
-    const { readFile: readFile20 } = await import("fs/promises");
+    const { readFile: readFile21 } = await import("fs/promises");
     const { join: pathJoin } = await import("path");
     const { renderRootIndex: renderRootIndex2, writeRootIndexProjection: writeRootIndexProjection2 } = await import("./index-projection-BJNZUPH6.js");
-    const before = await readFile20(pathJoin(input.vault, "index.md"), "utf8").catch(() => "");
+    const before = await readFile21(pathJoin(input.vault, "index.md"), "utf8").catch(() => "");
     const fullTarget = relPath.replace(/\.md$/, "");
     const bare = fullTarget.split("/").pop() ?? fullTarget;
     const hadIndexEntry = before.includes(`[[${fullTarget}]]`) || before.includes(`[[${bare}]]`);
@@ -4161,11 +4174,148 @@ async function runTranscripts(input) {
   return { exitCode: ExitCode.OK, result: ok({ transcripts, humanHint: hint }) };
 }
 
+// src/commands/claims-audit.ts
+import { readFile as readFile10 } from "fs/promises";
+import { join as join23 } from "path";
+function safeProjectPresentation(raw) {
+  if (safeDiagnosticValue(raw) === REDACTED_MALFORMED_REFERENCE) {
+    return REDACTED_MALFORMED_REFERENCE;
+  }
+  return normalizeProjectSlug(raw) ?? REDACTED_MALFORMED_REFERENCE;
+}
+async function runClaimsAudit(input) {
+  const scanResult = await scanVault(input.vault);
+  if (!scanResult.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scanResult };
+  const activeTranscripts = scanResult.data.raw.filter((p) => p.relPath.startsWith("raw/transcripts/") && p.relPath.endsWith(".md")).sort((a, b) => a.relPath.localeCompare(b.relPath));
+  const activePathSet = new Set(activeTranscripts.map((p) => p.relPath));
+  const workItemDirs = /* @__PURE__ */ new Set();
+  const specDirs = /* @__PURE__ */ new Set();
+  for (const page of scanResult.data.workItems) {
+    const slash = page.relPath.lastIndexOf("/");
+    if (slash < 0) continue;
+    const dir = page.relPath.slice(0, slash);
+    if (!parseActiveWorkPath(dir)) continue;
+    workItemDirs.add(dir);
+    if (page.relPath.endsWith("/spec.md")) specDirs.add(dir);
+  }
+  const sortedDirs = [...workItemDirs].sort();
+  const slugByDir = new Map(sortedDirs.map((dir) => [dir, parseActiveWorkPath(dir)?.project]));
+  if (input.project) {
+    const knownSlugs = new Set(
+      [...slugByDir.values()].filter((slug) => Boolean(slug))
+    );
+    if (!knownSlugs.has(input.project)) {
+      return {
+        exitCode: ExitCode.PROJECT_NOT_FOUND,
+        result: err("UNKNOWN_PROJECT", `Project "${input.project}" not found. Available: ${[...knownSlugs].sort().join(", ") || "(none)"}`)
+      };
+    }
+  }
+  const scopedSpecDirs = sortedDirs.filter((relDir) => {
+    if (!specDirs.has(relDir)) return false;
+    return !input.project || slugByDir.get(relDir) === input.project;
+  });
+  const claimSourceResults = await mapWithConcurrency(scopedSpecDirs, vaultIoConcurrency(), async (relDir) => {
+    const specPath = join23(input.vault, relDir, "spec.md");
+    try {
+      const specText = await readFile10(specPath, "utf8");
+      const fm = extractFrontmatter(specText);
+      if (!fm.ok) return null;
+      return {
+        relDir,
+        source: fm.data.source,
+        sources: fm.data.sources,
+        closes: fm.data.closes
+      };
+    } catch {
+      return null;
+    }
+  });
+  const claimIndex = collectClaimedTranscripts(
+    claimSourceResults.filter((source) => source !== null)
+  );
+  const claimedByPath = claimIndex.claimedByPath;
+  const transcriptMeta = /* @__PURE__ */ new Map();
+  const transcriptEntries = await mapWithConcurrency(activeTranscripts, vaultIoConcurrency(), async (t) => {
+    try {
+      const text = await readPageCached(t);
+      const fm = extractFrontmatter(text);
+      if (!fm.ok) return null;
+      const projectRaw = typeof fm.data.project === "string" ? fm.data.project.trim() : void 0;
+      const workItemRaw = typeof fm.data.work_item === "string" ? fm.data.work_item.trim() : void 0;
+      const meta = {};
+      if (projectRaw) {
+        meta.projectRaw = projectRaw;
+        meta.project = normalizeProjectSlug(projectRaw);
+      }
+      if (workItemRaw) meta.workItem = workItemRaw;
+      return [t.relPath, meta];
+    } catch {
+      return null;
+    }
+  });
+  for (const entry of transcriptEntries) {
+    if (entry) transcriptMeta.set(entry[0], entry[1]);
+  }
+  const findings = [];
+  for (const d of claimIndex.diagnostics) {
+    if (d.kind === "duplicate") {
+      findings.push({ kind: "duplicate_claim", path: d.path, owners: d.owners });
+    } else {
+      findings.push({ kind: "malformed_claim_reference", relDir: d.relDir, field: d.field, value: d.value });
+    }
+  }
+  for (const [path, owner] of claimedByPath) {
+    if (!activePathSet.has(path)) {
+      findings.push({ kind: "dangling_claim_reference", path, claimedBy: owner });
+    }
+  }
+  for (const [path, owner] of claimedByPath) {
+    const meta = transcriptMeta.get(path);
+    const ownerProject = slugByDir.get(owner) ?? parseActiveWorkPath(owner)?.project;
+    if (meta?.project && ownerProject !== meta.project) {
+      findings.push({
+        kind: "project_mismatch",
+        path,
+        captureProject: safeProjectPresentation(meta.projectRaw ?? ""),
+        claimedByProject: ownerProject ?? "",
+        claimedBy: owner
+      });
+    }
+  }
+  for (const t of activeTranscripts) {
+    const meta = transcriptMeta.get(t.relPath);
+    if (!meta?.workItem) continue;
+    if (input.project && meta.project && meta.project !== input.project) continue;
+    if (claimedByPath.has(t.relPath)) continue;
+    findings.push({ kind: "work_item_unbacked_claim", path: t.relPath, workItem: safeDiagnosticValue(meta.workItem) });
+  }
+  const summary = {
+    duplicate_claim: 0,
+    malformed_claim_reference: 0,
+    dangling_claim_reference: 0,
+    project_mismatch: 0,
+    work_item_unbacked_claim: 0
+  };
+  const hintLines = [];
+  for (const f of findings) {
+    summary[f.kind] += 1;
+    if (f.kind === "duplicate_claim") hintLines.push(`duplicate_claim: ${f.path} \u2014 ${f.owners.join(", ")}`);
+    else if (f.kind === "malformed_claim_reference") hintLines.push(`malformed_claim_reference: ${f.relDir} ${f.field}=${f.value}`);
+    else if (f.kind === "dangling_claim_reference") hintLines.push(`dangling_claim_reference: ${f.path} \u2014 claimed by ${f.claimedBy}`);
+    else if (f.kind === "project_mismatch") hintLines.push(`project_mismatch: ${f.path} \u2014 ${f.captureProject} claimed by ${f.claimedByProject}`);
+    else hintLines.push(`work_item_unbacked_claim: ${f.path} \u2014 ${f.workItem}`);
+  }
+  if (hintLines.length === 0) hintLines.push("no claim-integrity findings");
+  const humanHint = hintLines.join("\n");
+  return { exitCode: ExitCode.OK, result: ok({ findings, summary, humanHint }) };
+}
+
 // src/commands/compound.ts
 import { writeFile as writeFile6, mkdir as mkdir7, readdir as readdir6, unlink as unlink3 } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 var RETRO_HEADING_RE = /^## \[(\d{4}-\d{2}-\d{2})(?:\s+[^\]]+)?\] retro \| loop cycle(?: (\d+))?: (.+)$/;
 var FIELD_RE = {
   improve: /^-\s+\*?\*?Improve:?\*?\*?\s*(.+)$/m,
@@ -4263,17 +4413,17 @@ function extractRetroFields(date, cycleName, block) {
   };
 }
 async function runCompound(input) {
-  const logPath = join23(input.vault, "log.md");
+  const logPath = join24(input.vault, "log.md");
   let logText;
   try {
-    logText = await readFile10(logPath, "utf8");
+    logText = await readFile11(logPath, "utf8");
   } catch {
     return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: logPath }) };
   }
   const entries = parseRetroEntries(logText);
   const promoted = [];
   const skipped = [];
-  const compoundDir = join23(input.vault, "projects", input.project, "compound");
+  const compoundDir = join24(input.vault, "projects", input.project, "compound");
   for (const entry of entries) {
     const generalizeValue = entry.generalize.trim();
     if (!/^yes/i.test(generalizeValue)) {
@@ -4281,7 +4431,7 @@ async function runCompound(input) {
       continue;
     }
     const slug = slugify(entry.cycleName);
-    const compoundPath = join23(compoundDir, `${slug}.md`);
+    const compoundPath = join24(compoundDir, `${slug}.md`);
     if (existsSync7(compoundPath)) {
       skipped.push(entry.date);
       continue;
@@ -4342,7 +4492,7 @@ async function runCompound(input) {
   };
 }
 async function runCompoundDelete(input) {
-  const projectDir = join23(input.vault, "projects", input.project);
+  const projectDir = join24(input.vault, "projects", input.project);
   if (!existsSync7(projectDir)) {
     return {
       exitCode: ExitCode.PROJECT_NOT_FOUND,
@@ -4350,7 +4500,7 @@ async function runCompoundDelete(input) {
     };
   }
   const entryName = input.entry.replace(/\.md$/, "");
-  const compoundPath = join23(projectDir, "compound", `${entryName}.md`);
+  const compoundPath = join24(projectDir, "compound", `${entryName}.md`);
   if (!existsSync7(compoundPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -4384,7 +4534,7 @@ knowledge.md regenerated`
   };
 }
 async function runCompoundList(input) {
-  const compoundDir = join23(input.vault, "projects", input.project, "compound");
+  const compoundDir = join24(input.vault, "projects", input.project, "compound");
   if (!existsSync7(compoundDir)) {
     return {
       exitCode: ExitCode.OK,
@@ -4415,10 +4565,10 @@ could not read compound directory`
   const entries = [];
   for (const dirent of dirents) {
     if (!dirent.isFile() || !dirent.name.endsWith(".md")) continue;
-    const filePath = join23(compoundDir, dirent.name);
+    const filePath = join24(compoundDir, dirent.name);
     let text;
     try {
-      text = await readFile10(filePath, "utf8");
+      text = await readFile11(filePath, "utf8");
     } catch {
       continue;
     }
@@ -4447,8 +4597,8 @@ no compound entries found`;
 }
 
 // src/commands/session-brief.ts
-import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile7 } from "fs/promises";
-import { join as join24, relative, sep } from "path";
+import { mkdir as mkdir8, readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
+import { join as join25, relative, sep } from "path";
 var MAX_WORDS = 900;
 async function runSessionBrief(input) {
   const { root: scanRoot } = resolveReadOnlyVaultRoot(input.vault);
@@ -4557,7 +4707,7 @@ async function resolveProject(input) {
   const envProject = input.env?.SKILLWIKI_PROJECT;
   if (envProject) return envProject;
   const cwd = input.cwd ?? process.cwd();
-  const projectDotenv = await readProjectSlug(join24(cwd, ".skillwiki", ".env"));
+  const projectDotenv = await readProjectSlug(join25(cwd, ".skillwiki", ".env"));
   if (projectDotenv) return projectDotenv;
   const inferred = inferProjectFromPath(input.vault, cwd);
   if (inferred) return inferred;
@@ -4566,7 +4716,7 @@ async function resolveProject(input) {
 async function readProjectSlug(file) {
   let text;
   try {
-    text = await readFile11(file, "utf8");
+    text = await readFile12(file, "utf8");
   } catch {
     return void 0;
   }
@@ -4657,7 +4807,7 @@ async function loadTrendDigests(typedPages) {
   return out;
 }
 async function loadSessionPins(vault, project) {
-  const text = await readIfExists(join24(vault, "meta", "session-pins.md"));
+  const text = await readIfExists(join25(vault, "meta", "session-pins.md"));
   if (!text) return [];
   const fm = extractFrontmatter(text);
   if (!fm.ok) return [];
@@ -4776,7 +4926,7 @@ function satelliteHealthWarnings(warning) {
   return warning ? [warning] : [];
 }
 async function loadHealthWarnings(vault) {
-  const text = await readIfExists(join24(vault, ".skillwiki", "health.json"));
+  const text = await readIfExists(join25(vault, ".skillwiki", "health.json"));
   if (!text) return [];
   try {
     const parsed = JSON.parse(text);
@@ -4789,7 +4939,7 @@ async function loadHealthWarnings(vault) {
   }
 }
 async function loadMemoryTopics(vault, project) {
-  const text = await readIfExists(join24(vault, ".skillwiki", "memory", project, "topics.json"));
+  const text = await readIfExists(join25(vault, ".skillwiki", "memory", project, "topics.json"));
   if (!text) return [];
   try {
     const parsed = JSON.parse(text);
@@ -4814,11 +4964,11 @@ async function loadMemoryTopics(vault, project) {
   }
 }
 async function writeBriefArtifacts(vault, input) {
-  const metaPath = join24(vault, "meta", "latest-session-brief.md");
-  const cacheMdPath = join24(vault, ".skillwiki", "session-brief.md");
-  const cacheJsonPath = join24(vault, ".skillwiki", "session-brief.json");
-  await mkdir8(join24(vault, "meta"), { recursive: true });
-  await mkdir8(join24(vault, ".skillwiki"), { recursive: true });
+  const metaPath = join25(vault, "meta", "latest-session-brief.md");
+  const cacheMdPath = join25(vault, ".skillwiki", "session-brief.md");
+  const cacheJsonPath = join25(vault, ".skillwiki", "session-brief.json");
+  await mkdir8(join25(vault, "meta"), { recursive: true });
+  await mkdir8(join25(vault, ".skillwiki"), { recursive: true });
   const committed = renderCommittedBrief(input);
   const previousComparable = comparableBrief(await readIfExists(metaPath));
   const nextComparable = comparableBrief(committed);
@@ -4888,7 +5038,7 @@ function renderCommittedBrief(input) {
   ].filter((line) => line !== "").join("\n");
 }
 async function rebuildRootIndexProjection(vault) {
-  const before = await readIfExists(join24(vault, "index.md"));
+  const before = await readIfExists(join25(vault, "index.md"));
   if (!before) return false;
   const projection = await renderRootIndex({ vault, currentText: before });
   if (!projection.ok) return false;
@@ -4898,7 +5048,7 @@ async function rebuildRootIndexProjection(vault) {
 }
 async function readIfExists(path) {
   try {
-    return await readFile11(path, "utf8");
+    return await readFile12(path, "utf8");
   } catch {
     return "";
   }
@@ -4940,14 +5090,14 @@ function dateFromPath(path) {
 }
 
 // src/commands/ingest.ts
-import { readFile as readFile13, open, unlink as unlink4, mkdir as mkdir10 } from "fs/promises";
-import { join as join26 } from "path";
+import { readFile as readFile14, open, unlink as unlink4, mkdir as mkdir10 } from "fs/promises";
+import { join as join27 } from "path";
 import { createHash as createHash4 } from "crypto";
 
 // src/commands/page-publish.ts
 import { readFileSync as readFileSync12, realpathSync } from "fs";
-import { mkdir as mkdir9, readFile as readFile12 } from "fs/promises";
-import { dirname as dirname6, join as join25, resolve as resolve3 } from "path";
+import { mkdir as mkdir9, readFile as readFile13 } from "fs/promises";
+import { dirname as dirname6, join as join26, resolve as resolve3 } from "path";
 
 // src/utils/publication-approval.ts
 import { createHash as createHash3 } from "crypto";
@@ -5240,7 +5390,7 @@ async function refreshProjectIndexForTarget(vault, projectSlugs, today) {
   for (const slug of projectSlugs) {
     const rendered = await renderProjectIndex(vault, slug, { today });
     if (!rendered.ok) return rendered;
-    const indexPath = join25(vault, rendered.data.index_path);
+    const indexPath = join26(vault, rendered.data.index_path);
     try {
       await mkdir9(dirname6(indexPath), { recursive: true });
     } catch (error) {
@@ -5249,7 +5399,7 @@ async function refreshProjectIndexForTarget(vault, projectSlugs, today) {
     const written = await atomicWriteText(indexPath, rendered.data.text);
     if (!written.ok) return written;
     try {
-      const visible = await readFile12(indexPath, "utf8");
+      const visible = await readFile13(indexPath, "utf8");
       if (visible !== rendered.data.text) {
         return err("WRITE_FAILED", { path: indexPath, message: "project index verification failed" });
       }
@@ -5325,7 +5475,7 @@ function preparePagePublicationFromContent(input) {
 async function preparePagePublication(input) {
   let content;
   try {
-    content = await readFile12(input.draftPath, "utf8");
+    content = await readFile13(input.draftPath, "utf8");
   } catch (error) {
     return err("FILE_NOT_FOUND", { path: input.draftPath, message: String(error) });
   }
@@ -5397,10 +5547,10 @@ async function runLockedPrimaryStages(input, vault, deps) {
       ExitCode.VAULT_PATH_INVALID
     );
   }
-  const schemaPath = join25(vault, "SCHEMA.md");
+  const schemaPath = join26(vault, "SCHEMA.md");
   let schemaText;
   try {
-    schemaText = await readFile12(schemaPath, "utf8");
+    schemaText = await readFile13(schemaPath, "utf8");
   } catch (error) {
     return lockedFailure("schema", state, err("WRITE_FAILED", { message: String(error) }));
   }
@@ -5430,8 +5580,8 @@ async function runLockedPrimaryStages(input, vault, deps) {
   let visibleSchema;
   try {
     [visible, visibleSchema] = await Promise.all([
-      readFile12(input.targetPath, "utf8"),
-      readFile12(schemaPath, "utf8")
+      readFile13(input.targetPath, "utf8"),
+      readFile13(schemaPath, "utf8")
     ]);
   } catch (error) {
     return lockedFailure("verify", state, err("WRITE_FAILED", { message: String(error) }));
@@ -5535,17 +5685,17 @@ function renderPublicationLog(input, added) {
 }
 async function readPageChanged(targetPath, content) {
   try {
-    return ok(await readFile12(targetPath, "utf8") !== content);
+    return ok(await readFile13(targetPath, "utf8") !== content);
   } catch (error) {
     if (error.code === "ENOENT") return ok(true);
     return err("WRITE_FAILED", { path: targetPath, message: String(error) });
   }
 }
 async function previewPreparedPagePublication(input, vault) {
-  const schemaPath = join25(vault, "SCHEMA.md");
+  const schemaPath = join26(vault, "SCHEMA.md");
   let schemaText;
   try {
-    schemaText = await readFile12(schemaPath, "utf8");
+    schemaText = await readFile13(schemaPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: schemaPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -5557,10 +5707,10 @@ async function previewPreparedPagePublication(input, vault) {
   if (!reconciled.ok) return { exitCode: errorExitCode(reconciled.error), result: reconciled };
   const pageChanged = await readPageChanged(input.targetPath, input.page.content);
   if (!pageChanged.ok) return { exitCode: errorExitCode(pageChanged.error), result: pageChanged };
-  const indexPath = join25(vault, "index.md");
+  const indexPath = join26(vault, "index.md");
   let indexText;
   try {
-    indexText = await readFile12(indexPath, "utf8");
+    indexText = await readFile13(indexPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: indexPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -5576,7 +5726,7 @@ async function previewPreparedPagePublication(input, vault) {
   for (const projectSlug of projectSlugsForPublication(input.page.target, input.page.content)) {
     const renderedProject = await renderProjectIndex(vault, projectSlug, { today: input.date });
     if (!renderedProject.ok) return { exitCode: errorExitCode(renderedProject.error), result: renderedProject };
-    const projectIndexPath = join25(vault, renderedProject.data.index_path);
+    const projectIndexPath = join26(vault, renderedProject.data.index_path);
     const projectIndexChanged = await readPageChanged(projectIndexPath, renderedProject.data.text);
     if (!projectIndexChanged.ok) {
       return { exitCode: errorExitCode(projectIndexChanged.error), result: projectIndexChanged };
@@ -5586,10 +5736,10 @@ async function previewPreparedPagePublication(input, vault) {
       projectIndexPaths.push(renderedProject.data.index_path);
     }
   }
-  const logPath = join25(vault, "log.md");
+  const logPath = join26(vault, "log.md");
   let logText;
   try {
-    logText = await readFile12(logPath, "utf8");
+    logText = await readFile13(logPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: logPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -5883,7 +6033,7 @@ function buildTypedContent(title, ingested, type, tags, rawRelPath, provenance)
 }
 async function resolveRawCapture(input) {
   try {
-    const existing = await readFile13(input.path, "utf8");
+    const existing = await readFile14(input.path, "utf8");
     const frontmatter = extractFrontmatter(existing);
     if (!frontmatter.ok) {
       return err("INGEST_VALIDATION_FAILED", {
@@ -6022,7 +6172,7 @@ async function runIngest(input, pagePublishDeps = defaultPagePublishDeps()) {
     sourceContent = fetchResult.data.body;
   } else {
     try {
-      sourceContent = await readFile13(input.source, "utf8");
+      sourceContent = await readFile14(input.source, "utf8");
     } catch {
       return {
         exitCode: ExitCode.FILE_NOT_FOUND,
@@ -6047,7 +6197,7 @@ async function runIngest(input, pagePublishDeps = defaultPagePublishDeps()) {
   const rawRelPath = `raw/articles/${slug}.md`;
   const typedDir = TYPE_DIR[input.type] ?? `${input.type}s`;
   const typedRelPath = `${typedDir}/${slug}.md`;
-  const rawAbsPath = join26(input.vault, rawRelPath);
+  const rawAbsPath = join27(input.vault, rawRelPath);
   const identity = assessSourceIdentity({
     rawPath: rawRelPath,
     sourceUrl: sourceUrl ?? void 0,
@@ -6091,11 +6241,11 @@ async function runIngest(input, pagePublishDeps = defaultPagePublishDeps()) {
   );
   if (!input.dryRun) {
     try {
-      await mkdir10(join26(input.vault, typedDir), { recursive: true });
+      await mkdir10(join27(input.vault, typedDir), { recursive: true });
     } catch (error) {
       return {
         exitCode: ExitCode.WRITE_FAILED,
-        result: err("WRITE_FAILED", { path: join26(input.vault, typedDir), message: String(error) })
+        result: err("WRITE_FAILED", { path: join27(input.vault, typedDir), message: String(error) })
       };
     }
   }
@@ -6149,11 +6299,11 @@ async function runIngest(input, pagePublishDeps = defaultPagePublishDeps()) {
     preflight: pagePublishDeps.preflight,
     mutate: async (receipt) => {
       try {
-        await mkdir10(join26(input.vault, "raw", "articles"), { recursive: true });
+        await mkdir10(join27(input.vault, "raw", "articles"), { recursive: true });
       } catch (error) {
         return {
           exitCode: ExitCode.WRITE_FAILED,
-          result: err("WRITE_FAILED", { path: join26(input.vault, "raw", "articles"), message: String(error) })
+          result: err("WRITE_FAILED", { path: join27(input.vault, "raw", "articles"), message: String(error) })
         };
       }
       const rawWrite = await writeResolvedRaw({
@@ -6389,8 +6539,8 @@ ${body}`;
 }
 
 // src/commands/tag-reconcile.ts
-import { readFile as readFile14 } from "fs/promises";
-import { join as join27, posix } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join28, posix } from "path";
 var TYPED_TARGET_RE = /^(entities|concepts|comparisons|queries|meta)\/[a-z0-9][a-z0-9./_-]*\.md$/;
 function errorExitCode2(error) {
   switch (error) {
@@ -6433,7 +6583,7 @@ function asTagArray(frontmatter, path) {
 async function readTagsFromFile(path) {
   let text;
   try {
-    text = await readFile14(path, "utf8");
+    text = await readFile15(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path }) };
@@ -6454,7 +6604,7 @@ async function resolveRequestedTags(input, page) {
       result: err("INVALID_FRONTMATTER", { message: "explicit tags must be an array of strings" })
     };
   }
-  const source = input.from ?? (explicit.length === 0 ? join27(input.vault, page) : void 0);
+  const source = input.from ?? (explicit.length === 0 ? join28(input.vault, page) : void 0);
   if (!source) return { exitCode: ExitCode.OK, result: ok({ tags: [...new Set(explicit)].sort() }) };
   const sourced = await readTagsFromFile(source);
   if (!sourced.result.ok) return { exitCode: sourced.exitCode, result: sourced.result };
@@ -6465,7 +6615,7 @@ async function resolveRequestedTags(input, page) {
 }
 async function readSchema(schemaPath) {
   try {
-    return { exitCode: ExitCode.OK, result: ok(await readFile14(schemaPath, "utf8")) };
+    return { exitCode: ExitCode.OK, result: ok(await readFile15(schemaPath, "utf8")) };
   } catch (error) {
     if (error.code === "ENOENT") {
       return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: schemaPath }) };
@@ -6493,7 +6643,7 @@ function previewResult(page, tags, reconciled, dryRun, filesChanged) {
   };
 }
 async function reconcileTagsWhileLocked(input, page, tags, comment) {
-  const schemaPath = join27(input.vault, "SCHEMA.md");
+  const schemaPath = join28(input.vault, "SCHEMA.md");
   const current = await readSchema(schemaPath);
   if (!current.result.ok) return { exitCode: current.exitCode, result: current.result };
   const next = reconcileTaxonomyDocument(current.result.data, { tags, comment });
@@ -6504,7 +6654,7 @@ async function reconcileTagsWhileLocked(input, page, tags, comment) {
   }
   let verifiedText;
   try {
-    verifiedText = await readFile14(schemaPath, "utf8");
+    verifiedText = await readFile15(schemaPath, "utf8");
   } catch (error) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -6530,7 +6680,7 @@ async function runTagReconcile(input) {
   const comment = taxonomyCommentForPage(page.data, date, input.reason);
   if (!comment.ok) return { exitCode: ExitCode.SCHEME_REJECTED, result: comment };
   if (!input.write) {
-    const schema = await readSchema(join27(input.vault, "SCHEMA.md"));
+    const schema = await readSchema(join28(input.vault, "SCHEMA.md"));
     if (!schema.result.ok) return { exitCode: schema.exitCode, result: schema.result };
     const preview = reconcileTaxonomyDocument(schema.result.data, { tags, comment: comment.data });
     return previewResult(page.data, tags, preview, true, []);
@@ -6583,8 +6733,8 @@ async function runTagReconcile(input) {
 
 // src/commands/project-page-publish.ts
 import { realpathSync as realpathSync4 } from "fs";
-import { mkdir as mkdir11, readFile as readFile15 } from "fs/promises";
-import { dirname as dirname9, join as join29, resolve as resolve5 } from "path";
+import { mkdir as mkdir11, readFile as readFile16 } from "fs/promises";
+import { dirname as dirname9, join as join30, resolve as resolve5 } from "path";
 
 // src/utils/architecture-page.ts
 import { lstatSync, realpathSync as realpathSync2 } from "fs";
@@ -6745,7 +6895,7 @@ import {
   writeFileSync as writeFileSync5
 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname8, join as join28 } from "path";
+import { dirname as dirname8, join as join29 } from "path";
 var PUBLICATION_JOURNAL_SCHEMA = "skillwiki-publication-operation-v1";
 var PHASE_ORDER2 = [
   "locked",
@@ -6774,16 +6924,16 @@ function vaultIdentity(vaultPath) {
   return sha256Hex(real).slice(0, 16);
 }
 function publicationJournalRoot(home = process.env.HOME || homedir()) {
-  return join28(home, ".skillwiki", "publication-operations");
+  return join29(home, ".skillwiki", "publication-operations");
 }
 function resolveJournalPaths(vaultPath, operationId2, home = process.env.HOME || homedir()) {
   const identity = vaultIdentity(vaultPath);
   const rootDir = publicationJournalRoot(home);
-  const vaultDir = join28(rootDir, identity);
+  const vaultDir = join29(rootDir, identity);
   return {
     rootDir,
     vaultDir,
-    journalPath: join28(vaultDir, `${operationId2}.json`)
+    journalPath: join29(vaultDir, `${operationId2}.json`)
   };
 }
 function ensurePrivateDir(dir) {
@@ -7068,7 +7218,7 @@ async function observeStage2(deps, stage) {
 }
 async function readPriorTargetSha(targetPath) {
   try {
-    const text = await readFile15(targetPath, "utf8");
+    const text = await readFile16(targetPath, "utf8");
     return ok(sha256Hex(text));
   } catch (error) {
     if (error.code === "ENOENT") return ok("absent");
@@ -7093,7 +7243,7 @@ function validateLogNote(logNote) {
 async function prepareProjectPagePublication(input) {
   let content;
   try {
-    content = await readFile15(input.draftPath, "utf8");
+    content = await readFile16(input.draftPath, "utf8");
   } catch (error) {
     return err("FILE_NOT_FOUND", { path: input.draftPath, message: String(error) });
   }
@@ -7202,10 +7352,10 @@ function phaseFailure2(stage, prepared, published, verified, cause, context = {}
   };
 }
 async function previewProjectPagePublication(prepared, vault) {
-  const schemaPath = join29(vault, "SCHEMA.md");
+  const schemaPath = join30(vault, "SCHEMA.md");
   let schemaText;
   try {
-    schemaText = await readFile15(schemaPath, "utf8");
+    schemaText = await readFile16(schemaPath, "utf8");
   } catch (error) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -7228,18 +7378,18 @@ async function previewProjectPagePublication(prepared, vault) {
   }
   let projectIndexChanged = true;
   if (projectIndex.ok) {
-    const indexPath = join29(vault, projectIndex.data.index_path);
+    const indexPath = join30(vault, projectIndex.data.index_path);
     try {
-      const existing = await readFile15(indexPath, "utf8");
+      const existing = await readFile16(indexPath, "utf8");
       projectIndexChanged = existing !== projectIndex.data.text || pageChanged;
     } catch {
       projectIndexChanged = true;
     }
   }
-  const logPath = join29(vault, "log.md");
+  const logPath = join30(vault, "log.md");
   let logAppended = true;
   try {
-    const logText = await readFile15(logPath, "utf8");
+    const logText = await readFile16(logPath, "utf8");
     logAppended = !logText.includes(`<!-- skillwiki-project-page-publish:${prepared.operationId} -->`);
   } catch {
     return {
@@ -7363,11 +7513,11 @@ async function runLockedStages(prepared, vault, deps, journalHome) {
   if (journalHook) {
     return { ok: false, exitCode: ExitCode.WRITE_FAILED, stage: "journal", state, cause: journalHook };
   }
-  const schemaPath = join29(vault, "SCHEMA.md");
+  const schemaPath = join30(vault, "SCHEMA.md");
   {
     let schemaText;
     try {
-      schemaText = await readFile15(schemaPath, "utf8");
+      schemaText = await readFile16(schemaPath, "utf8");
     } catch (error) {
       return {
         ok: false,
@@ -7455,8 +7605,8 @@ async function runLockedStages(prepared, vault, deps, journalHome) {
     let visibleSchema;
     try {
       [visible, visibleSchema] = await Promise.all([
-        readFile15(prepared.targetPath, "utf8"),
-        readFile15(schemaPath, "utf8")
+        readFile16(prepared.targetPath, "utf8"),
+        readFile16(schemaPath, "utf8")
       ]);
     } catch (error) {
       return {
@@ -7510,7 +7660,7 @@ async function runLockedStages(prepared, vault, deps, journalHome) {
         cause: rendered
       };
     }
-    const knowledgePath = join29(vault, rendered.data.index_path);
+    const knowledgePath = join30(vault, rendered.data.index_path);
     try {
       await mkdir11(dirname9(knowledgePath), { recursive: true });
     } catch (error) {
@@ -7535,7 +7685,7 @@ async function runLockedStages(prepared, vault, deps, journalHome) {
     state.projectIndexChanged = knowledgeWrite.data.changed;
     if (state.projectIndexChanged) state.changed.add(rendered.data.index_path);
     try {
-      const visibleIndex = await readFile15(knowledgePath, "utf8");
+      const visibleIndex = await readFile16(knowledgePath, "utf8");
       if (visibleIndex !== rendered.data.text) {
         return {
           ok: false,
@@ -7909,7 +8059,7 @@ import { existsSync as existsSync9, mkdirSync as mkdirSync4, appendFileSync } fr
 import { createHash as createHash5 } from "crypto";
 import { execSync as execSync3, spawn } from "child_process";
 import { platform as platform2 } from "os";
-import { join as join30, resolve as resolvePath } from "path";
+import { join as join31, resolve as resolvePath } from "path";
 var MAINTENANCE_SCHEMA_VERSION = 1;
 var MAINTENANCE_COMMAND = "snapshot-maintenance journal clear-stale";
 function canonicalize(p) {
@@ -7972,7 +8122,7 @@ async function runSnapshotMaintenanceDryRun(input) {
     audit(makeAuditEvent(input, fleetLoad.hostId, now, "refusal", "MAINTENANCE_WRONG_WORKTREE"));
     return { exitCode: ExitCode.PROTECTED_SNAPSHOTTER_WRITE_BLOCKED, result: refusalErr("MAINTENANCE_WRONG_WORKTREE", `requested path '${requested}' is not the configured snapshot worktree '${canonicalize(configuredWorktree)}'`) };
   }
-  if (!existsSync9(requested) || !existsSync9(join30(requested, ".git"))) {
+  if (!existsSync9(requested) || !existsSync9(join31(requested, ".git"))) {
     audit(makeAuditEvent(input, fleetLoad.hostId, now, "refusal", "MAINTENANCE_MISSING_GIT_REPO"));
     return { exitCode: ExitCode.PROTECTED_SNAPSHOTTER_WRITE_BLOCKED, result: refusalErr("MAINTENANCE_MISSING_GIT_REPO", `snapshot worktree is not a git repository: ${requested}`) };
   }
@@ -8052,14 +8202,14 @@ async function resolveLiveVault(input) {
   return resolved.ok ? canonicalize(resolved.data.path) : void 0;
 }
 function snapshotMaintenanceAuditLogPath(home) {
-  const stateDir = platform2() === "darwin" ? join30(home, "Library", "Application Support", "vault-sync") : join30(home, ".local", "state", "vault-sync");
-  return join30(stateDir, "snapshot-maintenance-audit.jsonl");
+  const stateDir = platform2() === "darwin" ? join31(home, "Library", "Application Support", "vault-sync") : join31(home, ".local", "state", "vault-sync");
+  return join31(stateDir, "snapshot-maintenance-audit.jsonl");
 }
 function defaultAuditSink(home) {
   return (event) => {
     try {
       const logPath = snapshotMaintenanceAuditLogPath(home);
-      mkdirSync4(join30(logPath, ".."), { recursive: true });
+      mkdirSync4(join31(logPath, ".."), { recursive: true });
       appendFileSync(logPath, JSON.stringify(event) + "\n", { encoding: "utf8" });
     } catch {
     }
@@ -8220,7 +8370,7 @@ function releaseSnapshotFlock(handle) {
 
 // src/commands/backup.ts
 import { statSync as statSync3, readdirSync as readdirSync2, readFileSync as readFileSync15, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join31, relative as relative3, dirname as dirname10 } from "path";
+import { join as join32, relative as relative3, dirname as dirname10 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
 // src/utils/s3-client.ts
@@ -8244,7 +8394,7 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([".git", ".obsidian", "_archive", "node_
 function* walkMarkdown(dir, base) {
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     if (SKIP_DIRS.has(entry.name)) continue;
-    const full = join31(dir, entry.name);
+    const full = join32(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkMarkdown(full, base);
     } else if (entry.name.endsWith(".md")) {
@@ -8267,7 +8417,7 @@ async function runBackupSync(input) {
   let failed = 0;
   const files = [...walkMarkdown(input.vault, input.vault)];
   for (const relPath of files) {
-    const absPath = join31(input.vault, relPath);
+    const absPath = join32(input.vault, relPath);
     const localStat = statSync3(absPath);
     let needsUpload = true;
     try {
@@ -8343,7 +8493,7 @@ async function runBackupRestore(input) {
     const objects = list.Contents ?? [];
     for (const obj of objects) {
       if (!obj.Key) continue;
-      const localPath = join31(target, obj.Key);
+      const localPath = join32(target, obj.Key);
       try {
         const localStat = statSync3(localPath);
         if (obj.LastModified && localStat.mtime > obj.LastModified) {
@@ -8390,8 +8540,8 @@ async function runBackupRestore(input) {
 
 // src/commands/status.ts
 import { existsSync as existsSync10, statSync as statSync4 } from "fs";
-import { readFile as readFile16 } from "fs/promises";
-import { join as join32 } from "path";
+import { readFile as readFile17 } from "fs/promises";
+import { join as join33 } from "path";
 var FUSE_NO_MIRROR_NOTE = "FUSE vault with no read mirror - status scan may be slow";
 async function runStatus(input) {
   if (!existsSync10(input.vault)) {
@@ -8430,7 +8580,7 @@ async function runStatus(input) {
   const compound = scan.data.compound.length;
   let schemaVersion = "v1";
   try {
-    const schemaContent = await readFile16(join32(scanRoot, "SCHEMA.md"), "utf8");
+    const schemaContent = await readFile17(join33(scanRoot, "SCHEMA.md"), "utf8");
     const versionMatch = schemaContent.match(/version:\s*["']?([^"'\s\n]+)/i);
     if (versionMatch) schemaVersion = versionMatch[1];
   } catch {
@@ -8498,7 +8648,7 @@ async function runStatus(input) {
 
 // src/commands/seed.ts
 import { mkdir as mkdir12, writeFile as writeFile8, stat as stat4 } from "fs/promises";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 var TODAY = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 var EXAMPLE_PAGES = {
   "entities/example-project.md": `---
@@ -8567,29 +8717,29 @@ Real sources are immutable after ingestion \u2014 never edit them.
 `;
 async function runSeed(input) {
   try {
-    await stat4(join33(input.vault, "SCHEMA.md"));
+    await stat4(join34(input.vault, "SCHEMA.md"));
   } catch {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { root: input.vault, reason: "SCHEMA.md missing \u2014 run `skillwiki init` first" }) };
   }
   const created = [];
   const skipped = [];
   for (const [relPath, content] of Object.entries(EXAMPLE_PAGES)) {
-    const absPath = join33(input.vault, relPath);
+    const absPath = join34(input.vault, relPath);
     try {
       await stat4(absPath);
       skipped.push(relPath);
     } catch {
-      await mkdir12(join33(absPath, ".."), { recursive: true });
+      await mkdir12(join34(absPath, ".."), { recursive: true });
       await writeFile8(absPath, content, "utf8");
       created.push(relPath);
     }
   }
-  const rawPath = join33(input.vault, "raw", "articles", "example-source.md");
+  const rawPath = join34(input.vault, "raw", "articles", "example-source.md");
   try {
     await stat4(rawPath);
     skipped.push("raw/articles/example-source.md");
   } catch {
-    await mkdir12(join33(rawPath, ".."), { recursive: true });
+    await mkdir12(join34(rawPath, ".."), { recursive: true });
     await writeFile8(rawPath, EXAMPLE_RAW, "utf8");
     created.push("raw/articles/example-source.md");
   }
@@ -8612,9 +8762,9 @@ async function runSeed(input) {
 }
 
 // src/commands/canvas.ts
-import { readFile as readFile17, writeFile as writeFile9 } from "fs/promises";
+import { readFile as readFile18, writeFile as writeFile9 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 var NODE_WIDTH = 240;
 var NODE_HEIGHT = 60;
 var COLUMN_SPACING = 400;
@@ -8692,7 +8842,7 @@ function buildCanvasEdges(adjacency) {
   return edges;
 }
 async function runCanvasGenerate(input) {
-  const graphPath = input.graphPath ?? join34(input.vault, ".skillwiki", "graph.json");
+  const graphPath = input.graphPath ?? join35(input.vault, ".skillwiki", "graph.json");
   if (!existsSync11(graphPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -8704,7 +8854,7 @@ async function runCanvasGenerate(input) {
   }
   let raw;
   try {
-    raw = await readFile17(graphPath, "utf8");
+    raw = await readFile18(graphPath, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -8730,7 +8880,7 @@ async function runCanvasGenerate(input) {
   const nodes = buildCanvasNodes(paths);
   const edges = buildCanvasEdges(graph.adjacency);
   const canvas = { nodes, edges };
-  const outPath = join34(input.vault, "vault-graph.canvas");
+  const outPath = join35(input.vault, "vault-graph.canvas");
   try {
     await writeFile9(outPath, JSON.stringify(canvas, null, 2));
   } catch (e) {
@@ -8765,11 +8915,11 @@ async function runSourceDisposition(input) {
 
 // src/utils/source-disposal.ts
 import { createHash as createHash6 } from "crypto";
-import { readFile as readFile19, unlink as unlink5 } from "fs/promises";
+import { readFile as readFile20, unlink as unlink5 } from "fs/promises";
 
 // src/utils/raw-asset-reference-index.ts
-import { readdir as readdir7, readFile as readFile18 } from "fs/promises";
-import { join as join35, relative as relative4, sep as sep3 } from "path";
+import { readdir as readdir7, readFile as readFile19 } from "fs/promises";
+import { join as join36, relative as relative4, sep as sep3 } from "path";
 var PREVIEW_EXTENSIONS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "avif", "pdf", "mp3", "wav", "m4a", "mp4", "webm"]);
 async function walkFiles(root, dir = root) {
   let entries;
@@ -8780,7 +8930,7 @@ async function walkFiles(root, dir = root) {
   }
   const out = [];
   for (const entry of entries) {
-    const path = join35(dir, entry.name);
+    const path = join36(dir, entry.name);
     if (entry.isDirectory()) out.push(...await walkFiles(root, path));
     else if (entry.isFile()) out.push(relative4(root, path).split(sep3).join("/"));
   }
@@ -8796,7 +8946,7 @@ function addInbound(map, target, source) {
   map.set(target, refs);
 }
 async function buildRawAssetReferenceIndex(vault) {
-  const assetRoot = join35(vault, "raw", "assets");
+  const assetRoot = join36(vault, "raw", "assets");
   const relativeAssets = await walkFiles(assetRoot);
   const assets = relativeAssets.map((path) => `raw/assets/${path}`).sort((a, b) => a.localeCompare(b));
   const assetSet = new Set(assets);
@@ -8812,7 +8962,7 @@ async function buildRawAssetReferenceIndex(vault) {
   for (const page of scan.data.allMarkdown) {
     let text;
     try {
-      text = await readFile18(page.absPath, "utf8");
+      text = await readFile19(page.absPath, "utf8");
     } catch {
       continue;
     }
@@ -8872,7 +9022,7 @@ async function planSourceDisposal(input) {
   if (sensitive.length > 0) return err("SENSITIVE_CONTENT_DETECTED", { findings: sensitive });
   const target = await resolveExistingRegularFileInsideVault(input.vault, input.rawPath);
   if (!target.ok) return err("RAW_DISPOSAL_TARGET_INVALID", { path: input.rawPath, cause: target });
-  const bytes = await readFile19(target.data);
+  const bytes = await readFile20(target.data);
   const size = bytes.byteLength;
   let typedReferences = [];
   let otherReferences = [];
@@ -8996,7 +9146,7 @@ async function runSourceDisposal(input) {
 import { existsSync as existsSync12, readFileSync as readFileSync16 } from "fs";
 import { execSync as nodeExecSync } from "child_process";
 import { hostname as nodeHostname, platform as nodePlatform } from "os";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 var SSH_TIMEOUT_MS = 15e3;
 var TIMER_UNIT = "agent-memory-trends.timer";
 var SERVICE_UNIT = "agent-memory-trends.service";
@@ -9226,7 +9376,7 @@ async function runFleetHealth(input) {
   const home = input.home ?? env.HOME ?? "";
   const osHostname = input.osHostname ?? env.HOSTNAME ?? nodeHostname();
   const vault = input.vault ?? env.WIKI_PATH;
-  const file = input.file ?? (vault ? join36(vault, FLEET_REL_PATH) : void 0);
+  const file = input.file ?? (vault ? join37(vault, FLEET_REL_PATH) : void 0);
   if (!file) {
     return {
       exitCode: ExitCode.NO_VAULT_CONFIGURED,
@@ -9311,14 +9461,14 @@ async function runFleetHealth(input) {
 
 // src/utils/auto-commit.ts
 import { existsSync as existsSync13 } from "fs";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 async function postCommit(vault, exitCode) {
   if (exitCode !== 0) return;
   const home = process.env.HOME ?? "";
   const dotenv = await parseDotenvFile(configPath(home));
   const autoCommit = process.env.AUTO_COMMIT ?? dotenv["AUTO_COMMIT"];
   if (autoCommit === "false") return;
-  if (!existsSync13(join37(vault, ".git"))) return;
+  if (!existsSync13(join38(vault, ".git"))) return;
   const lastOps = readLastOp(vault);
   if (lastOps.length === 0) return;
   const porcelain = git(vault, ["status", "--porcelain", "--", ...VAULT_COMMIT_PATHSPEC]);
@@ -9479,7 +9629,7 @@ async function emitManagedVaultWrite(vault, command, mutate, opts) {
   if (dirty) {
     return emit(dirty, void 0, { postCommit: false });
   }
-  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-DWK3PJCO.js");
+  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-H7KVK2KI.js");
   const run = await runManagedWriteTransaction2({
     vault,
     command,
@@ -9509,7 +9659,7 @@ program.command("validate <file>").description("validate vault page frontmatter
   emit(await runValidate({ file, apply: !!opts.apply, vault }), vault);
 });
 program.command("graph").description("graph subcommands").command("build <vault>").option("--out <path>", "graph output path (default: <vault>/.skillwiki/graph.json)").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
-  const out = opts.out ?? join38(vault, ".skillwiki", "graph.json");
+  const out = opts.out ?? join39(vault, ".skillwiki", "graph.json");
   return emitGuardedVaultWrite(vault, "graph build", () => runGraphBuild({ vault, out }));
 });
 var canvasCmd = program.command("canvas").description("manage Obsidian canvas files");
@@ -10124,6 +10274,12 @@ program.command("project-index <slug> [vault]").description("generate a knowledg
   );
   else emit(await runProjectIndex({ vault: v.vault, slug, apply: false, check: opts.check }), v.vault);
 });
+var claimsCmd = program.command("claims").description("audit raw-transcript claim integrity (read-only)");
+claimsCmd.command("audit [vault]").description("report duplicate, malformed, dangling, project-mismatch, and work-item-unbacked claims (read-only)").option("--project <slug>", "scope findings to an exact project slug").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+  const v = await resolveVaultArg(vault, opts.wiki);
+  if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
+  else emit(await runClaimsAudit({ vault: v.vault, project: opts.project }), v.vault, { postCommit: false });
+});
 var compoundCmd = program.command("compound").description("manage project compound entries");
 compoundCmd.command("promote [vault]").description("promote retros with Generalize?: yes to compound entries").requiredOption("--project <slug>", "project slug (e.g., llm-wiki)").option("--dry-run", "preview promotions without writing files", false).option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
   const v = await resolveVaultArg(vault, opts.wiki);