skillwiki 0.7.0 → 0.8.1-beta.1

package/dist/cli.js

@@ -9,7 +9,7 @@ import {
 
 // src/cli.ts
 import { readFileSync as readFileSync12 } from "fs";
-import { join as join41 } from "path";
+import { join as join43 } from "path";
 import { Command as Command2 } from "commander";
 
 // ../shared/src/exit-codes.ts
@@ -62,7 +62,8 @@ var ExitCode = {
   BACKUP_RESTORE_CONFLICTS: 45,
   USAGE: 46,
   BODY_TRUNCATION_GUARD: 47,
-  SYNC_LOCK_HELD: 48
+  SYNC_LOCK_HELD: 48,
+  LOG_APPEND_LOCK_HELD: 49
 };
 
 // ../shared/src/json-output.ts
@@ -2362,10 +2363,111 @@ Chronological action log. Newest entries last. Skill writes append entries; lint
   return { exitCode: ExitCode.OK, result: ok({ entries, threshold: input.threshold, rotated: true, rotated_to: rotatedName, humanHint: `rotated ${entries} entries to ${rotatedName}` }) };
 }
 
+// src/commands/log-append.ts
+import { readFile as readFile13, rename as rename4, writeFile as writeFile8, stat as stat6 } from "fs/promises";
+import { join as join17 } from "path";
+
+// src/utils/log-lock.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join16 } from "path";
+function logLockPath(vault) {
+  return join16(vault, ".skillwiki", "log-append.lock");
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function acquireLogLock(vault, opts = {}) {
+  const retryMs = opts.retryMs ?? 2e3;
+  const pollMs = opts.pollMs ?? 50;
+  const staleMs = opts.staleMs ?? 1e4;
+  const path = logLockPath(vault);
+  const dir = join16(vault, ".skillwiki");
+  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
+  const deadline = Date.now() + retryMs;
+  const content = JSON.stringify({ pid: process.pid, acquired: (/* @__PURE__ */ new Date()).toISOString() }) + "\n";
+  for (; ; ) {
+    try {
+      writeFileSync2(path, content, { flag: "wx" });
+      return { ok: true };
+    } catch (e) {
+      const err3 = e;
+      if (err3.code !== "EEXIST") throw err3;
+    }
+    try {
+      const age = Date.now() - statSync2(path).mtimeMs;
+      if (age > staleMs) {
+        unlinkSync2(path);
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    if (Date.now() >= deadline) return { ok: false };
+    await sleep(pollMs);
+  }
+}
+function releaseLogLock(vault) {
+  try {
+    unlinkSync2(logLockPath(vault));
+  } catch {
+  }
+}
+
+// src/commands/log-append.ts
+var ENTRY_RE2 = /^## \[(\d{4})-\d{2}-\d{2}\]/gm;
+async function runLogAppend(input) {
+  try {
+    await stat6(join17(input.vault, "SCHEMA.md"));
+  } catch {
+    return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { vault: input.vault }) };
+  }
+  const content = (input.content ?? "").trim();
+  if (content.length === 0) {
+    return { exitCode: ExitCode.USAGE, result: err("USAGE", { message: "--content must be a non-empty log entry" }) };
+  }
+  const acquired = await acquireLogLock(input.vault);
+  if (!acquired.ok) {
+    return { exitCode: ExitCode.LOG_APPEND_LOCK_HELD, result: err("LOG_APPEND_LOCK_HELD", { vault: input.vault }) };
+  }
+  const logPath = join17(input.vault, "log.md");
+  try {
+    let logText;
+    try {
+      logText = await readFile13(logPath, "utf8");
+    } catch {
+      return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: logPath }) };
+    }
+    const entriesBefore = [...logText.matchAll(ENTRY_RE2)].length;
+    const body = logText.replace(/\s+$/, "");
+    const next = `${body}
+
+${content}
+`;
+    try {
+      const tmp = logPath + ".tmp";
+      await writeFile8(tmp, next, "utf8");
+      await rename4(tmp, logPath);
+    } catch (e) {
+      return { exitCode: ExitCode.WRITE_FAILED, result: err("WRITE_FAILED", { message: String(e) }) };
+    }
+    appendLastOp(input.vault, {
+      operation: "log-append",
+      summary: `appended log entry (${entriesBefore}->${entriesBefore + 1})`,
+      files: ["log.md"],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const entriesAfter = entriesBefore + 1;
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({ entries_before: entriesBefore, entries_after: entriesAfter, appended: true, humanHint: `appended log entry (${entriesBefore}->${entriesAfter})` })
+    };
+  } finally {
+    releaseLogLock(input.vault);
+  }
+}
+
 // src/commands/lint.ts
-import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile15 } from "fs/promises";
-import { join as join19 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile16, rename as rename6 } from "fs/promises";
+import { join as join21 } from "path";
 
 // src/commands/topic-map-check.ts
 var DEFAULT_THRESHOLD = 200;
@@ -2387,13 +2489,13 @@ async function runTopicMapCheck(input) {
 }
 
 // src/commands/index-link-format.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join16 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join18 } from "path";
 var MD_LINK_RE = /\[[^\[\]]+\]\([^)]+\.md\)/;
 async function runIndexLinkFormat(input) {
   let text = "";
   try {
-    text = await readFile13(join16(input.vault, "index.md"), "utf8");
+    text = await readFile14(join18(input.vault, "index.md"), "utf8");
   } catch {
   }
   const markdown_links = [];
@@ -2406,8 +2508,8 @@ ${markdown_links.map((l) => `  line ${l.line}: ${l.text}`).join("\n")}`;
 }
 
 // src/commands/dedup.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3 } from "fs";
+import { join as join19 } from "path";
 async function runDedup(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
@@ -2435,7 +2537,7 @@ async function runDedup(input) {
       }
     }
     for (const page of scan.data.typedKnowledge) {
-      const text = readFileSync3(join17(input.vault, page.relPath), "utf-8");
+      const text = readFileSync3(join19(input.vault, page.relPath), "utf-8");
       let updated = text;
       let changed = false;
       for (const [oldPath, newPath] of replacements) {
@@ -2453,14 +2555,14 @@ async function runDedup(input) {
         }
       }
       if (changed) {
-        writeFileSync2(join17(input.vault, page.relPath), updated);
+        writeFileSync3(join19(input.vault, page.relPath), updated);
         rewired.push(page.relPath);
       }
     }
     for (const [oldPath] of replacements) {
-      const fullPath = join17(input.vault, oldPath);
+      const fullPath = join19(input.vault, oldPath);
       try {
-        unlinkSync2(fullPath);
+        unlinkSync3(fullPath);
         removed.push(oldPath);
       } catch {
       }
@@ -2493,9 +2595,9 @@ async function runDedup(input) {
 }
 
 // src/utils/safe-write.ts
-import { open, readFile as readFile14, rename as rename4, unlink as unlink2, writeFile as writeFile8 } from "fs/promises";
+import { open, readFile as readFile15, rename as rename5, unlink as unlink2, writeFile as writeFile9 } from "fs/promises";
 import { randomBytes } from "crypto";
-import { dirname as dirname7, basename, join as join18 } from "path";
+import { dirname as dirname7, basename, join as join20 } from "path";
 var DEFAULT_MIN_BODY_RATIO = 0.5;
 var DEFAULT_MIN_OLD_BODY_BYTES = 200;
 function bodyBytes(text) {
@@ -2505,7 +2607,7 @@ function bodyBytes(text) {
 }
 async function readIfExists(absPath) {
   try {
-    return await readFile14(absPath, "utf8");
+    return await readFile15(absPath, "utf8");
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw e;
@@ -2544,7 +2646,7 @@ async function safeWritePage(absPath, newContent, opts = {}) {
   }
   const dir = dirname7(absPath);
   const tmpName = `.${basename(absPath)}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
-  const tmpPath = join18(dir, tmpName);
+  const tmpPath = join20(dir, tmpName);
   try {
     const handle = await open(tmpPath, "w");
     try {
@@ -2556,7 +2658,7 @@ async function safeWritePage(absPath, newContent, opts = {}) {
     } finally {
       await handle.close();
     }
-    await rename4(tmpPath, absPath);
+    await rename5(tmpPath, absPath);
     return ok({ isNew, oldBodyBytes, newBodyBytes, bodyRatio, guardSkippedSmall });
   } catch (e) {
     try {
@@ -2607,6 +2709,60 @@ async function runRawBodyDedup(vault) {
   };
 }
 
+// src/commands/path-too-long.ts
+var MAX_PATH_LENGTH = 240;
+async function runPathTooLong(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 violations = [];
+  for (const page of allPages) {
+    if (page.relPath.length > MAX_PATH_LENGTH) {
+      violations.push({ relPath: page.relPath, length: page.relPath.length });
+    }
+  }
+  if (violations.length > 0) {
+    return {
+      exitCode: ExitCode.LINT_HAS_ERRORS,
+      result: ok({
+        violations,
+        humanHint: violations.map((v) => `${v.relPath}: ${v.length} chars (max ${MAX_PATH_LENGTH})`).join("\n")
+      })
+    };
+  }
+  return { exitCode: ExitCode.OK, result: ok({ violations, humanHint: "all paths within length limit" }) };
+}
+function truncateFilename(relPath, maxLength = MAX_PATH_LENGTH) {
+  if (relPath.length <= maxLength) return relPath;
+  const lastSlash = relPath.lastIndexOf("/");
+  const dir = lastSlash >= 0 ? relPath.slice(0, lastSlash) : "";
+  const filename = lastSlash >= 0 ? relPath.slice(lastSlash + 1) : relPath;
+  const hash = computeShortHash(relPath);
+  const ext = filename.endsWith(".md") ? ".md" : "";
+  const base = filename.endsWith(".md") ? filename.slice(0, -3) : filename;
+  const suffix = `-${hash}${ext}`;
+  const dirPrefix = dir ? dir + "/" : "";
+  const maxPrefixLen = maxLength - dirPrefix.length - suffix.length;
+  if (maxPrefixLen <= 0) {
+    const fallback = dirPrefix + hash + ext;
+    if (fallback.length > maxLength) {
+      const dirBudget = maxLength - suffix.length;
+      return dirPrefix.slice(0, Math.max(0, dirBudget)) + suffix;
+    }
+    return fallback;
+  }
+  const prefix = base.slice(0, maxPrefixLen).replace(/[-_\s]+$/, "");
+  return dirPrefix + prefix + suffix;
+}
+function computeShortHash(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0").slice(0, 8);
+}
+
 // src/utils/cli-surface.ts
 import { Command } from "commander";
 function buildCliSurface() {
@@ -2639,7 +2795,7 @@ function buildCliSurface() {
   program2.command("config");
   program2.command("doctor");
   program2.command("status").option("--wiki <name>");
-  program2.command("archive").option("--wiki <name>");
+  program2.command("archive").option("--wiki <name>").option("--cascade").option("--apply");
   program2.command("drift").option("--apply").option("--new <date>").option("--wiki <name>");
   program2.command("dedup").option("--apply").option("--wiki <name>");
   program2.command("migrate-citations").option("--dry-run").option("--wiki <name>");
@@ -2672,6 +2828,9 @@ function buildCliSurface() {
   syncCmd2.command("status").option("--wiki <name>");
   syncCmd2.command("push").option("--wiki <name>");
   syncCmd2.command("pull").option("--wiki <name>");
+  syncCmd2.command("lock").option("--summary <text>").option("--ttl-minutes <n>").option("--force").option("--wiki <name>");
+  syncCmd2.command("unlock").option("--force").option("--wiki <name>");
+  syncCmd2.command("peers").option("--wiki <name>");
   const backupCmd2 = program2.commands.find((c) => c.name() === "backup");
   backupCmd2.command("sync").option("--dry-run").option("--bucket <name>").option("--endpoint <url>").option("--region <region>").option("--prune").option("--wiki <name>");
   backupCmd2.command("restore").option("--bucket <name>").option("--endpoint <url>").option("--region <region>").option("--target <dir>").option("--wiki <name>");
@@ -2779,7 +2938,7 @@ function extractSourceEntries(rawFm) {
   }
   return entries;
 }
-var ERROR_ORDER = ["broken_wikilinks", "invalid_frontmatter", "raw_dedup", "broken_sources", "tag_not_in_taxonomy"];
+var ERROR_ORDER = ["broken_wikilinks", "invalid_frontmatter", "raw_dedup", "broken_sources", "tag_not_in_taxonomy", "path_too_long"];
 var WARNING_ORDER = ["raw_body_duplicate", "raw_subdirectory_duplicate", "file_source_url", "index_incomplete", "index_link_format", "stale_page", "page_too_large", "log_rotate_needed", "orphans", "compound_refs", "legacy_citation_style", "orphaned_citations", "duplicate_frontmatter", "work_item_health", "orphaned_project_pages", "missing_overview", "missing_diagram"];
 var INFO_ORDER = ["bridges", "page_structure", "topic_map_recommended", "frontmatter_wikilink", "wikilink_citation", "missing_tldr", "stale_sections", "cli_refs"];
 async function runLint(input) {
@@ -2839,6 +2998,8 @@ 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 });
+  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();
@@ -2900,7 +3061,7 @@ async function runLint(input) {
         let rawPath = entry.replace(/^"/, "").replace(/"$/, "").replace(/^'/, "").replace(/'$/, "");
         rawPath = rawPath.replace(/^\^\[/, "").replace(/\]$/, "");
         if (!rawPath.startsWith("raw/") && !rawPath.startsWith("_archive/raw/")) continue;
-        if (!existsSync3(join19(input.vault, rawPath)) && !existsSync3(join19(input.vault, rawPath + ".md")) && !rawPath.startsWith("_archive/") && !existsSync3(join19(input.vault, "_archive", rawPath)) && !existsSync3(join19(input.vault, "_archive", rawPath + ".md"))) {
+        if (!existsSync4(join21(input.vault, rawPath)) && !existsSync4(join21(input.vault, rawPath + ".md")) && !rawPath.startsWith("_archive/") && !existsSync4(join21(input.vault, "_archive", rawPath)) && !existsSync4(join21(input.vault, "_archive", rawPath + ".md"))) {
           brokenSourceFlags.push(`${page.relPath}: ${rawPath}`);
         }
       }
@@ -2991,11 +3152,11 @@ async function runLint(input) {
         const slugMatch = String(entry).match(/\[\[([^\]]+)\]\]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
-        const knowledgePath = join19(input.vault, "projects", slug, "knowledge.md");
-        if (!existsSync3(knowledgePath)) continue;
+        const knowledgePath = join21(input.vault, "projects", slug, "knowledge.md");
+        if (!existsSync4(knowledgePath)) continue;
         const pageRef = page.relPath.replace(/\.md$/, "");
         try {
-          const knowledgeContent = await readFile15(knowledgePath, "utf8");
+          const knowledgeContent = await readFile16(knowledgePath, "utf8");
           if (!knowledgeContent.includes(`[[${pageRef}]]`)) {
             orphanedProjectPages.push(`${page.relPath}: not in projects/${slug}/knowledge.md`);
           }
@@ -3006,7 +3167,7 @@ async function runLint(input) {
     if (orphanedProjectPages.length > 0) buckets.orphaned_project_pages = orphanedProjectPages;
     const cliRefFlags = [];
     const cliSurface = buildCliSurface();
-    const allScanPages = [...scan.data.typedKnowledge, ...scan.data.raw, ...scan.data.workItems, ...scan.data.compound];
+    const allScanPages = [...scan.data.typedKnowledge];
     for (const page of allScanPages) {
       const text = await readPage(page);
       const violations = validateCliRefs(text, page.relPath, cliSurface);
@@ -3042,7 +3203,7 @@ async function runLint(input) {
       for (const relPath of legacyPages) {
         try {
           const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile15(absPath, "utf8");
+          const raw = await readFile16(absPath, "utf8");
           const split = splitFrontmatter(raw);
           if (!split.ok) {
             unresolved.push(relPath);
@@ -3141,7 +3302,7 @@ ${newBody}`;
       for (const relPath of noOverview) {
         try {
           const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile15(absPath, "utf8");
+          const raw = await readFile16(absPath, "utf8");
           const split = splitFrontmatter(raw);
           if (!split.ok) {
             unresolved.push(relPath);
@@ -3182,7 +3343,7 @@ ${trimmedBody}`;
       for (const relPath of missingTldrFlags) {
         try {
           const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile15(absPath, "utf8");
+          const raw = await readFile16(absPath, "utf8");
           const split = splitFrontmatter(raw);
           if (!split.ok) {
             unresolved.push(relPath);
@@ -3232,7 +3393,7 @@ ${lines.join("\n")}`;
       for (const relPath of wikilinkCitationFlags) {
         try {
           const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile15(absPath, "utf8");
+          const raw = await readFile16(absPath, "utf8");
           const split = splitFrontmatter(raw);
           if (!split.ok) {
             unresolved.push(relPath);
@@ -3319,7 +3480,7 @@ ${newBody}`;
       for (const relPath of fileSourceUrlFlags) {
         try {
           const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile15(absPath, "utf8");
+          const raw = await readFile16(absPath, "utf8");
           const parts = raw.split("---", 3);
           if (parts.length < 3) {
             unresolved.push(relPath);
@@ -3353,6 +3514,45 @@ ${newBody}`;
         else delete buckets.file_source_url;
       }
     }
+    const pathViolations = buckets.path_too_long;
+    if (input.fix && pathViolations && pathViolations.length > 0) {
+      const pathFixed = [];
+      for (const v of pathViolations) {
+        try {
+          const absPath = `${input.vault}/${v.relPath}`;
+          const newRelPath = truncateFilename(v.relPath);
+          const newAbsPath = `${input.vault}/${newRelPath}`;
+          await rename6(absPath, newAbsPath);
+          const oldPathEscaped = v.relPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          for (const page of allPages) {
+            if (page.relPath === v.relPath) continue;
+            const content = await readFile16(page.absPath, "utf8");
+            if (!content.includes(v.relPath)) continue;
+            let updated = content;
+            const citationRe = new RegExp(`\\^\\[${oldPathEscaped}\\]`, "g");
+            updated = updated.replace(citationRe, `^[${newRelPath}]`);
+            const wikilinkRe = new RegExp(`\\[\\[${oldPathEscaped}(\\|[^\\]]*)?\\]\\]`, "g");
+            updated = updated.replace(wikilinkRe, (_m, alias) => `[[${newRelPath}${alias ?? ""}]]`);
+            if (updated !== content) {
+              const w = await safeWritePage(page.absPath, updated);
+              if (!w.ok) {
+                unresolved.push(`${page.relPath} (rewire)`);
+              }
+            }
+          }
+          pathFixed.push(v.relPath);
+        } catch {
+          unresolved.push(v.relPath);
+        }
+      }
+      fixed.push(...pathFixed);
+      if (pathFixed.length > 0) {
+        const fixedSet = new Set(pathFixed);
+        const remaining = pathViolations.filter((v) => !fixedSet.has(v.relPath));
+        if (remaining.length > 0) buckets.path_too_long = remaining;
+        else delete buckets.path_too_long;
+      }
+    }
   }
   const errorOut = ERROR_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
   const warningOut = WARNING_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
@@ -3428,14 +3628,14 @@ ${match.length === 0 ? "0 violations" : match.map((b) => `  ${b.kind}: ${b.items
 }
 
 // src/commands/config.ts
-import { readFile as readFile16 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join20 } from "path";
+import { readFile as readFile17 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join22 } from "path";
 function validateKey(key) {
   return CONFIG_KEYS.includes(key) || isValidWikiProfileKey(key);
 }
 function configPath(home) {
-  return join20(home, ".skillwiki", ".env");
+  return join22(home, ".skillwiki", ".env");
 }
 async function runConfigGet(input) {
   if (!validateKey(input.key)) {
@@ -3453,7 +3653,7 @@ async function runConfigSet(input) {
   try {
     let originalContent;
     try {
-      originalContent = await readFile16(filePath, "utf8");
+      originalContent = await readFile17(filePath, "utf8");
     } catch {
     }
     const existing = originalContent !== void 0 ? parseDotenvText(originalContent) : {};
@@ -3485,18 +3685,18 @@ async function runConfigList(input) {
 }
 async function runConfigPath(input) {
   const filePath = configPath(input.home);
-  return { exitCode: ExitCode.OK, result: ok({ path: filePath, exists: existsSync4(filePath), humanHint: filePath }) };
+  return { exitCode: ExitCode.OK, result: ok({ path: filePath, exists: existsSync5(filePath), humanHint: filePath }) };
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync7, lstatSync, readlinkSync, readdirSync, statSync as statSync2, readFileSync as readFileSync7 } from "fs";
-import { join as join24, resolve as resolve4 } from "path";
+import { existsSync as existsSync8, lstatSync, readlinkSync, readdirSync, statSync as statSync3, readFileSync as readFileSync7 } from "fs";
+import { join as join26, resolve as resolve4 } from "path";
 import { execSync as execSync2 } from "child_process";
 import { platform as platform2 } from "os";
 
 // src/utils/auto-update.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
-import { join as join21, dirname as dirname8 } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { join as join23, dirname as dirname8 } from "path";
 import { spawn } from "child_process";
 
 // src/utils/update-consts.ts
@@ -3507,7 +3707,7 @@ var CLI_DISABLE_FLAG = "--no-update-notifier";
 
 // src/utils/auto-update.ts
 function cachePath(home) {
-  return join21(home, ".skillwiki", CACHE_FILENAME);
+  return join23(home, ".skillwiki", CACHE_FILENAME);
 }
 function readCacheRaw(home) {
   try {
@@ -3526,8 +3726,8 @@ function readCache(home) {
 }
 function writeCache(home, cache) {
   const p = cachePath(home);
-  mkdirSync2(dirname8(p), { recursive: true });
-  writeFileSync3(p, JSON.stringify(cache, null, 2));
+  mkdirSync3(dirname8(p), { recursive: true });
+  writeFileSync4(p, JSON.stringify(cache, null, 2));
 }
 function latestFromCache(home, currentVersion) {
   const { cache } = readCache(home);
@@ -3545,7 +3745,7 @@ function triggerAutoUpdate(home, currentVersion) {
   const { isStale: isStale2 } = readCache(home);
   if (!isStale2) return;
   const bgScript = new URL("../auto-update-bg.js", import.meta.url).pathname;
-  if (!existsSync5(bgScript)) return;
+  if (!existsSync6(bgScript)) return;
   const child = spawn(process.execPath, [bgScript, home, currentVersion], {
     detached: true,
     stdio: "ignore"
@@ -3557,12 +3757,12 @@ function triggerAutoUpdate(home, currentVersion) {
 
 // src/utils/plugin-registry.ts
 import { readFileSync as readFileSync5 } from "fs";
-import { join as join22 } from "path";
-var REGISTRY_PATH = join22(".claude", "plugins", "installed_plugins.json");
+import { join as join24 } from "path";
+var REGISTRY_PATH = join24(".claude", "plugins", "installed_plugins.json");
 var PLUGIN_KEY = "skillwiki@llm-wiki";
 function readInstalledPlugins(home) {
   try {
-    const raw = readFileSync5(join22(home, REGISTRY_PATH), "utf8");
+    const raw = readFileSync5(join24(home, REGISTRY_PATH), "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3579,8 +3779,8 @@ function findPlugin(home, key = PLUGIN_KEY) {
 // src/utils/s3-mount-health.ts
 import { execSync } from "child_process";
 import { platform } from "os";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, readFileSync as readFile17 } from "fs";
-import { join as join23 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, unlinkSync as unlinkSync4, readFileSync as readFile18 } from "fs";
+import { join as join25 } from "path";
 var OS = platform();
 function findRcloneMountPid() {
   try {
@@ -3738,35 +3938,35 @@ function detectFuseMount(vaultPath) {
   return null;
 }
 function writeTest(dir) {
-  const testFile = join23(dir, `.doctor-write-test-${process.pid}.tmp`);
+  const testFile = join25(dir, `.doctor-write-test-${process.pid}.tmp`);
   const payload = `skillwiki doctor write test \u2014 ${Date.now()} \u2014 ${Math.random().toString(36).slice(2)}`;
   const start = Date.now();
   try {
-    writeFileSync4(testFile, payload, "utf8");
+    writeFileSync5(testFile, payload, "utf8");
   } catch (e) {
     return { success: false, writeMs: Date.now() - start, readMs: 0, size: 0, error: `write failed: ${e.message}` };
   }
   const writeMs = Date.now() - start;
   const readStart = Date.now();
   try {
-    const back = readFile17(testFile, "utf8");
+    const back = readFile18(testFile, "utf8");
     const readMs = Date.now() - readStart;
     if (back !== payload) {
       try {
-        unlinkSync3(testFile);
+        unlinkSync4(testFile);
       } catch {
       }
       return { success: false, writeMs, readMs, size: Buffer.byteLength(payload, "utf8"), error: "content mismatch \u2014 wrote and read-back differ" };
     }
   } catch (e) {
     try {
-      unlinkSync3(testFile);
+      unlinkSync4(testFile);
     } catch {
     }
     return { success: false, writeMs, readMs: Date.now() - readStart, size: 0, error: `read failed: ${e.message}` };
   }
   try {
-    unlinkSync3(testFile);
+    unlinkSync4(testFile);
   } catch {
   }
   return { success: true, writeMs, readMs: Date.now() - readStart, size: Buffer.byteLength(payload, "utf8") };
@@ -3807,13 +4007,13 @@ function detectCliChannels(argv, home) {
   }
   const plugin = findPlugin(home);
   if (plugin) {
-    const pluginBin = join24(plugin.installPath, "bin", "skillwiki");
-    if (existsSync7(pluginBin)) {
+    const pluginBin = join26(plugin.installPath, "bin", "skillwiki");
+    if (existsSync8(pluginBin)) {
       channels.push({ name: "plugin", path: pluginBin, isDevLink: false });
     }
   }
-  const installBin = join24(home, ".claude", "skills", "bin", "skillwiki");
-  if (existsSync7(installBin)) {
+  const installBin = join26(home, ".claude", "skills", "bin", "skillwiki");
+  if (existsSync8(installBin)) {
     channels.push({ name: "install", path: installBin, isDevLink: false });
   }
   return channels;
@@ -3865,7 +4065,7 @@ function checkCliChannels(argv, home) {
 }
 async function checkConfigFile(home) {
   const cfgPath = configPath(home);
-  if (!existsSync7(cfgPath)) {
+  if (!existsSync8(cfgPath)) {
     return check("warn", "config_file", "Config file exists", `${cfgPath} not found`);
   }
   try {
@@ -3880,7 +4080,7 @@ function checkWikiPathExists(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "wiki_path_exists", "Vault directory exists", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (existsSync7(resolvedPath) && statSync2(resolvedPath).isDirectory()) {
+  if (existsSync8(resolvedPath) && statSync3(resolvedPath).isDirectory()) {
     return check("pass", "wiki_path_exists", "Vault directory exists", resolvedPath);
   }
   return check("error", "wiki_path_exists", "Vault directory exists", `${resolvedPath} does not exist or is not a directory`);
@@ -3889,13 +4089,13 @@ function checkVaultStructure(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync7(resolvedPath)) {
+  if (!existsSync8(resolvedPath)) {
     return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 vault directory does not exist");
   }
   const missing = [];
-  if (!existsSync7(join24(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
+  if (!existsSync8(join26(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
   for (const dir of ["raw", "entities", "concepts", "meta"]) {
-    if (!existsSync7(join24(resolvedPath, dir))) missing.push(dir + "/");
+    if (!existsSync8(join26(resolvedPath, dir))) missing.push(dir + "/");
   }
   if (missing.length === 0) {
     return check("pass", "vault_structure", "Vault structure valid", "All required files and directories present");
@@ -3903,8 +4103,8 @@ function checkVaultStructure(resolvedPath) {
   return check("warn", "vault_structure", "Vault structure valid", `Missing: ${missing.join(", ")} \u2014 run \`skillwiki init\` to add CodeWiki structure`);
 }
 function checkSkillsInstalled(home, cwd) {
-  const srcDir = cwd ? join24(cwd, "packages", "skills") : void 0;
-  if (srcDir && existsSync7(srcDir)) {
+  const srcDir = cwd ? join26(cwd, "packages", "skills") : void 0;
+  if (srcDir && existsSync8(srcDir)) {
     const found = findSkillMd(srcDir);
     if (found.length > 0) {
       return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (source)`);
@@ -3917,8 +4117,8 @@ function checkSkillsInstalled(home, cwd) {
       return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (plugin v${plugin.version})`);
     }
   }
-  const skillsDir = join24(home, ".claude", "skills");
-  if (existsSync7(skillsDir)) {
+  const skillsDir = join26(home, ".claude", "skills");
+  if (existsSync8(skillsDir)) {
     const found = findSkillMd(skillsDir);
     if (found.length > 0) {
       return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (CLI install)`);
@@ -3928,10 +4128,10 @@ function checkSkillsInstalled(home, cwd) {
 }
 function checkDuplicateSkills(home) {
   const plugin = findPlugin(home);
-  const skillsDir = join24(home, ".claude", "skills");
+  const skillsDir = join26(home, ".claude", "skills");
   const agentSkillDirs = [
-    { label: "~/.codex/skills/", path: join24(home, ".codex", "skills") },
-    { label: "~/.agents/skills/", path: join24(home, ".agents", "skills") }
+    { label: "~/.codex/skills/", path: join26(home, ".codex", "skills") },
+    { label: "~/.agents/skills/", path: join26(home, ".agents", "skills") }
   ];
   if (!plugin) {
     return check("pass", "skills_duplicate", "Skills not duplicated", "Single install channel");
@@ -4008,8 +4208,8 @@ async function checkProfiles(home) {
 }
 async function checkProjectLocalOverride(cwd) {
   const dir = cwd ?? process.cwd();
-  const envPath = join24(dir, ".skillwiki", ".env");
-  if (existsSync7(envPath)) {
+  const envPath = join26(dir, ".skillwiki", ".env");
+  if (existsSync8(envPath)) {
     return check("pass", "project_local", "Project-local config", `Found: ${envPath}`);
   }
   return check("pass", "project_local", "Project-local config", "None");
@@ -4018,7 +4218,7 @@ function checkVaultGitRemote(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "vault_git_remote", "Vault git remote", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync7(join24(resolvedPath, ".git"))) {
+  if (!existsSync8(join26(resolvedPath, ".git"))) {
     return check("warn", "vault_git_remote", "Vault git remote", "Vault is not a git repository \u2014 sync features unavailable");
   }
   try {
@@ -4041,9 +4241,9 @@ function checkObsidianTemplates(resolvedPath) {
     return check("error", "obsidian_templates", "Obsidian templates", "Cannot check \u2014 WIKI_PATH not resolved");
   }
   const missing = [];
-  if (!existsSync7(join24(resolvedPath, "_Templates"))) missing.push("_Templates/");
-  if (!existsSync7(join24(resolvedPath, ".obsidian", "templates.json"))) missing.push(".obsidian/templates.json");
-  if (!existsSync7(join24(resolvedPath, ".obsidian", "app.json"))) missing.push(".obsidian/app.json");
+  if (!existsSync8(join26(resolvedPath, "_Templates"))) missing.push("_Templates/");
+  if (!existsSync8(join26(resolvedPath, ".obsidian", "templates.json"))) missing.push(".obsidian/templates.json");
+  if (!existsSync8(join26(resolvedPath, ".obsidian", "app.json"))) missing.push(".obsidian/app.json");
   if (missing.length === 0) {
     return check("pass", "obsidian_templates", "Obsidian templates", "Template folder and config present");
   }
@@ -4053,8 +4253,8 @@ function checkDotStoreClean(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "dsstore_clean", "No .DS_Store in raw/", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  const rawDir = join24(resolvedPath, "raw");
-  if (!existsSync7(rawDir)) {
+  const rawDir = join26(resolvedPath, "raw");
+  if (!existsSync8(rawDir)) {
     return check("pass", "dsstore_clean", "No .DS_Store in raw/", "raw/ directory not found \u2014 check skipped");
   }
   const found = [];
@@ -4069,7 +4269,7 @@ function checkDotStoreClean(resolvedPath) {
       if (entry.name === ".DS_Store") {
         found.push(rel ? `${rel}/.DS_Store` : ".DS_Store");
       } else if (entry.isDirectory()) {
-        walk2(join24(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
+        walk2(join26(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
       }
     }
   })(rawDir, "");
@@ -4082,7 +4282,7 @@ function checkSyncLastPush(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "sync_last_push", "Vault sync recency", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync7(join24(resolvedPath, ".git"))) {
+  if (!existsSync8(join26(resolvedPath, ".git"))) {
     return check("pass", "sync_last_push", "Vault sync recency", "No git repo \u2014 sync check skipped");
   }
   let timestamp;
@@ -4123,8 +4323,8 @@ function checkS3MountPerf(resolvedPath) {
     return check("pass", "s3_mount_perf", "S3 mount performance", "local disk");
   }
   const mountPoint = fuse.mountPoint;
-  const conceptsDir = join24(resolvedPath, "concepts");
-  if (!existsSync7(conceptsDir)) {
+  const conceptsDir = join26(resolvedPath, "concepts");
+  if (!existsSync8(conceptsDir)) {
     return check("pass", "s3_mount_perf", "S3 mount performance", `S3 FUSE mount (${mountPoint}), no concepts/ to benchmark`);
   }
   const start = Date.now();
@@ -4242,8 +4442,8 @@ function checkWriteTest(resolvedPath) {
   if (!fuse) {
     return check("pass", "s3_write_test", "S3 write test", "local disk \u2014 check skipped");
   }
-  const conceptsDir = join24(resolvedPath, "concepts");
-  if (!existsSync7(conceptsDir)) {
+  const conceptsDir = join26(resolvedPath, "concepts");
+  if (!existsSync8(conceptsDir)) {
     return check("pass", "s3_write_test", "S3 write test", "no concepts/ dir to test \u2014 check skipped");
   }
   const result = writeTest(conceptsDir);
@@ -4329,7 +4529,7 @@ function checkVfsCacheHealth(resolvedPath) {
 }
 function readVaultSyncConfig(home) {
   try {
-    const content = readFileSync7(join24(home, ".skillwiki", ".env"), "utf8");
+    const content = readFileSync7(join26(home, ".skillwiki", ".env"), "utf8");
     let installed = false;
     let role;
     for (const line of content.split(/\r?\n/)) {
@@ -4363,12 +4563,12 @@ function vaultSyncChecks(input) {
     ];
   }
   const isMac = os === "darwin";
-  const logDir = input.logDir ?? (isMac ? join24(home, "Library", "Logs") : join24(home, ".local", "state", "vault-sync", "log"));
-  const shareDir = input.shareDir ?? (isMac ? join24(home, "Library", "Application Support", "vault-sync", "bin") : join24(home, ".local", "share", "vault-sync", "bin"));
-  const filterPath = input.filterPath ?? join24(home, ".config", "rclone", "wiki-push-filters.txt");
+  const logDir = input.logDir ?? (isMac ? join26(home, "Library", "Logs") : join26(home, ".local", "state", "vault-sync", "log"));
+  const shareDir = input.shareDir ?? (isMac ? join26(home, "Library", "Application Support", "vault-sync", "bin") : join26(home, ".local", "share", "vault-sync", "bin"));
+  const filterPath = input.filterPath ?? join26(home, ".config", "rclone", "wiki-push-filters.txt");
   const snapshotPath = input.snapshotScriptPath ?? "/root/.hermes/scripts/wiki-snapshot-v3.sh";
-  const pushScriptPath = join24(shareDir, "wiki-push.sh");
-  const c1 = existsSync7(pushScriptPath) ? check("pass", "vault_sync_installed", "Vault sync installed", `Found: ${pushScriptPath}`) : check("error", "vault_sync_installed", "Vault sync installed", `Script not found at ${pushScriptPath} \u2014 run vault-sync-install`);
+  const pushScriptPath = join26(shareDir, "wiki-push.sh");
+  const c1 = existsSync8(pushScriptPath) ? check("pass", "vault_sync_installed", "Vault sync installed", `Found: ${pushScriptPath}`) : check("error", "vault_sync_installed", "Vault sync installed", `Script not found at ${pushScriptPath} \u2014 run vault-sync-install`);
   let c2;
   try {
     if (isMac) {
@@ -4419,7 +4619,7 @@ function vaultSyncChecks(input) {
       "Scheduler check failed \u2014 run vault-sync-install"
     );
   }
-  const logFile = join24(logDir, "wiki-push.log");
+  const logFile = join26(logDir, "wiki-push.log");
   let c3;
   try {
     const logContent = readFileSync7(logFile, "utf8");
@@ -4478,7 +4678,7 @@ function vaultSyncChecks(input) {
       }
     }
   } catch {
-    c3 = existsSync7(logDir) ? check(
+    c3 = existsSync8(logDir) ? check(
       "warn",
       "vault_sync_last_push_age",
       "Vault sync last push recency",
@@ -4490,7 +4690,7 @@ function vaultSyncChecks(input) {
       `Log directory not found at ${logDir}`
     );
   }
-  const fetchLogFile = join24(logDir, "wiki-fetch.log");
+  const fetchLogFile = join26(logDir, "wiki-fetch.log");
   let cFetch;
   try {
     const logContent = readFileSync7(fetchLogFile, "utf8");
@@ -4537,7 +4737,7 @@ function vaultSyncChecks(input) {
   }
   let c4;
   try {
-    if (!existsSync7(filterPath)) {
+    if (!existsSync8(filterPath)) {
       c4 = check(
         "error",
         "vault_sync_filter_present",
@@ -4586,7 +4786,7 @@ function vaultSyncChecks(input) {
     );
   } else {
     try {
-      if (!existsSync7(snapshotPath)) {
+      if (!existsSync8(snapshotPath)) {
         c5 = check(
           "error",
           "vault_sync_snapshot_guard",
@@ -4632,9 +4832,9 @@ function findSkillMd(dir) {
   }
   for (const entry of entries) {
     if (entry.isFile() && entry.name === "SKILL.md") {
-      results.push(join24(dir, entry.name));
+      results.push(join26(dir, entry.name));
     } else if (entry.isDirectory()) {
-      results.push(...findSkillMd(join24(dir, entry.name)));
+      results.push(...findSkillMd(join26(dir, entry.name)));
     }
   }
   return results;
@@ -4648,7 +4848,7 @@ function findSkillNames(dir) {
     return results;
   }
   for (const entry of entries) {
-    if (entry.isDirectory() && existsSync7(join24(dir, entry.name, "SKILL.md"))) {
+    if (entry.isDirectory() && existsSync8(join26(dir, entry.name, "SKILL.md"))) {
       results.push(entry.name);
     }
   }
@@ -4712,8 +4912,8 @@ async function runDoctor(input) {
 }
 
 // src/commands/archive.ts
-import { rename as rename5, mkdir as mkdir8, readFile as readFile18, writeFile as writeFile9 } from "fs/promises";
-import { join as join25, dirname as dirname9 } from "path";
+import { rename as rename7, mkdir as mkdir8, readFile as readFile19, writeFile as writeFile10 } from "fs/promises";
+import { join as join27, dirname as dirname9 } from "path";
 function countWikilinks(body, slug) {
   const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const re = new RegExp(`\\[\\[${escaped}(?:[|#][^\\]]*)?\\]\\]`, "g");
@@ -4741,7 +4941,7 @@ async function runArchive(input) {
   if (!relPath) return { exitCode: ExitCode.ARCHIVE_TARGET_NOT_FOUND, result: err("ARCHIVE_TARGET_NOT_FOUND", { page: input.page }) };
   if (relPath.startsWith("_archive/")) return { exitCode: ExitCode.ARCHIVE_ALREADY_ARCHIVED, result: err("ARCHIVE_ALREADY_ARCHIVED", { page: relPath }) };
   const slug = relPath.replace(/\.md$/, "").split("/").pop();
-  const archivePath = join25("_archive", relPath).replace(/\\/g, "/");
+  const archivePath = join27("_archive", relPath).replace(/\\/g, "/");
   let cascade;
   if (input.cascade) {
     const wikilinkRefs = [];
@@ -4765,7 +4965,7 @@ async function runArchive(input) {
     const indexRefs = [];
     if (!isRaw) {
       try {
-        const idx = await readFile18(join25(input.vault, "index.md"), "utf8");
+        const idx = await readFile19(join27(input.vault, "index.md"), "utf8");
         idx.split("\n").forEach((line, i) => {
           if (line.includes(`[[${slug}]]`)) indexRefs.push({ line: i + 1, text: line });
         });
@@ -4791,8 +4991,8 @@ async function runArchive(input) {
   }
   if (input.cascade && input.apply && cascade) {
     for (const ref of cascade.source_array_refs) {
-      const absPath = join25(input.vault, ref.page);
-      const text = await readFile18(absPath, "utf8");
+      const absPath = join27(input.vault, ref.page);
+      const text = await readFile19(absPath, "utf8");
       const split = splitFrontmatter(text);
       if (!split.ok) continue;
       const before = split.data.rawFrontmatter;
@@ -4803,29 +5003,29 @@ async function runArchive(input) {
       );
       if (fmRewritten === before) continue;
       if (!arraysEqual(ref.sources_after, ref.sources_before)) {
-        await writeFile9(absPath, `---
+        await writeFile10(absPath, `---
 ${fmRewritten}
 ---${split.data.body}`, "utf8");
       }
     }
   }
-  await mkdir8(dirname9(join25(input.vault, archivePath)), { recursive: true });
+  await mkdir8(dirname9(join27(input.vault, archivePath)), { recursive: true });
   let indexUpdated = false;
   if (!isRaw) {
-    const indexPath = join25(input.vault, "index.md");
+    const indexPath = join27(input.vault, "index.md");
     try {
-      const idx = await readFile18(indexPath, "utf8");
+      const idx = await readFile19(indexPath, "utf8");
       const originalLines = idx.split("\n");
       const filtered = originalLines.filter((l) => !l.includes(`[[${slug}]]`));
       if (filtered.length !== originalLines.length) {
-        await writeFile9(indexPath, filtered.join("\n"), "utf8");
+        await writeFile10(indexPath, filtered.join("\n"), "utf8");
         indexUpdated = true;
       }
     } catch (e) {
       if (e instanceof Error && "code" in e && e.code !== "ENOENT") throw e;
     }
   }
-  await rename5(join25(input.vault, relPath), join25(input.vault, archivePath));
+  await rename7(join27(input.vault, relPath), join27(input.vault, archivePath));
   appendLastOp(input.vault, {
     operation: input.cascade ? "archive-cascade" : "archive",
     summary: `moved ${relPath} to ${archivePath}${input.cascade ? ` (cascade: ${cascade?.source_array_refs.length ?? 0} source arrays updated)` : ""}`,
@@ -5212,14 +5412,14 @@ ${newBody}`;
 // src/commands/update.ts
 import { execSync as execSync3 } from "child_process";
 import { readFileSync as readFileSync8 } from "fs";
-import { join as join26 } from "path";
+import { join as join28 } from "path";
 function resolveGlobalSkillsRoot() {
   try {
     const globalRoot = execSync3("npm root -g", {
       encoding: "utf8",
       timeout: 5e3
     }).trim();
-    return join26(globalRoot, "skillwiki", "skills");
+    return join28(globalRoot, "skillwiki", "skills");
   } catch {
     return null;
   }
@@ -5245,7 +5445,7 @@ async function runUpdate(input) {
   );
   const currentVersion = pkg2.version;
   const tag = input.distTag ?? "latest";
-  const target = join26(input.home, ".claude", "skills");
+  const target = join28(input.home, ".claude", "skills");
   let latest;
   try {
     latest = execSync3(`npm view skillwiki@${tag} version`, {
@@ -5315,16 +5515,16 @@ async function runUpdate(input) {
 
 // src/commands/self-update.ts
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { join as join29 } from "path";
 var DEFAULT_SOURCE_ROOT_SUFFIX = "/Desktop/code/llm-wiki";
 async function runSelfUpdate(input) {
   const currentVersion = JSON.parse(
     readFileSync9(new URL("../../package.json", import.meta.url), "utf8")
   ).version;
   const sourceRoot = input.sourceRoot ?? `${input.home}${DEFAULT_SOURCE_ROOT_SUFFIX}`;
-  const localPkgPath = join27(sourceRoot, "packages", "cli", "package.json");
-  const hasLocalSource = existsSync8(localPkgPath);
+  const localPkgPath = join29(sourceRoot, "packages", "cli", "package.json");
+  const hasLocalSource = existsSync9(localPkgPath);
   if (input.check) {
     let availableVersion = null;
     let source;
@@ -5455,10 +5655,10 @@ async function runSelfUpdate(input) {
 }
 
 // src/commands/transcripts.ts
-import { readdir as readdir5, stat as stat6, readFile as readFile19 } from "fs/promises";
-import { join as join28 } from "path";
+import { readdir as readdir5, stat as stat7, readFile as readFile20 } from "fs/promises";
+import { join as join30 } from "path";
 async function runTranscripts(input) {
-  const dir = join28(input.vault, "raw", "transcripts");
+  const dir = join30(input.vault, "raw", "transcripts");
   let entries;
   try {
     entries = await readdir5(dir, { withFileTypes: true });
@@ -5468,13 +5668,13 @@ async function runTranscripts(input) {
   const transcripts = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = join28(dir, entry.name);
-    const content = await readFile19(filePath, "utf8");
+    const filePath = join30(dir, entry.name);
+    const content = await readFile20(filePath, "utf8");
     const fm = extractFrontmatter(content);
     if (!fm.ok) continue;
     const ingested = typeof fm.data.ingested === "string" ? fm.data.ingested : "";
     if (input.since && ingested && ingested < input.since) continue;
-    const s = await stat6(filePath);
+    const s = await stat7(filePath);
     transcripts.push({
       file: `raw/transcripts/${entry.name}`,
       ingested,
@@ -5486,12 +5686,12 @@ async function runTranscripts(input) {
 }
 
 // src/commands/project-index.ts
-import { readdir as readdir6, readFile as readFile20, writeFile as writeFile10, mkdir as mkdir9 } from "fs/promises";
-import { join as join29, dirname as dirname10 } from "path";
+import { readdir as readdir6, readFile as readFile21, writeFile as writeFile11, mkdir as mkdir9 } from "fs/promises";
+import { join as join31, dirname as dirname10 } from "path";
 var LAYER2_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
 async function runProjectIndex(input) {
   const slug = input.slug;
-  const projectDir = join29(input.vault, "projects", slug);
+  const projectDir = join31(input.vault, "projects", slug);
   try {
     await readdir6(projectDir);
   } catch {
@@ -5502,15 +5702,15 @@ async function runProjectIndex(input) {
   }
   const wikilinkPattern = `[[${slug}]]`;
   const entries = [];
-  const compoundDir = join29(input.vault, "projects", slug, "compound");
+  const compoundDir = join31(input.vault, "projects", slug, "compound");
   try {
     const compoundFiles = await readdir6(compoundDir, { withFileTypes: true });
     for (const entry of compoundFiles) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const filePath = join29(compoundDir, entry.name);
+      const filePath = join31(compoundDir, entry.name);
       let text;
       try {
-        text = await readFile20(filePath, "utf8");
+        text = await readFile21(filePath, "utf8");
       } catch {
         continue;
       }
@@ -5527,16 +5727,16 @@ async function runProjectIndex(input) {
   for (const dir of LAYER2_DIRS) {
     let files;
     try {
-      files = await readdir6(join29(input.vault, dir), { withFileTypes: true });
+      files = await readdir6(join31(input.vault, dir), { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of files) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const filePath = join29(input.vault, dir, entry.name);
+      const filePath = join31(input.vault, dir, entry.name);
       let text;
       try {
-        text = await readFile20(filePath, "utf8");
+        text = await readFile21(filePath, "utf8");
       } catch {
         continue;
       }
@@ -5557,11 +5757,11 @@ async function runProjectIndex(input) {
     const tb = typeOrder[b.type] ?? 99;
     return ta !== tb ? ta - tb : a.title.localeCompare(b.title);
   });
-  const indexPath = join29(projectDir, "knowledge.md");
+  const indexPath = join31(projectDir, "knowledge.md");
   let existing = false;
   let stale = false;
   try {
-    const existingText = await readFile20(indexPath, "utf8");
+    const existingText = await readFile21(indexPath, "utf8");
     existing = true;
     const existingEntries = existingText.split("\n").filter((l) => l.startsWith("- [["));
     const existingPages = new Set(existingEntries.map((l) => {
@@ -5602,7 +5802,7 @@ Autogenerated by \`skillwiki project-index\` on ${today}.
   if (input.apply) {
     try {
       await mkdir9(dirname10(indexPath), { recursive: true });
-      await writeFile10(indexPath, body, "utf8");
+      await writeFile11(indexPath, body, "utf8");
     } catch (e) {
       return {
         exitCode: ExitCode.WRITE_FAILED,
@@ -5630,10 +5830,10 @@ ${entries.map((e) => `  ${e.type}: [[${e.page.replace(/\.md$/, "")}]] \u2014 ${e
 }
 
 // src/commands/compound.ts
-import { writeFile as writeFile11, mkdir as mkdir10, readdir as readdir7, unlink as unlink3 } from "fs/promises";
-import { join as join30 } from "path";
-import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile21 } from "fs/promises";
+import { writeFile as writeFile12, mkdir as mkdir10, readdir as readdir7, unlink as unlink3 } from "fs/promises";
+import { join as join32 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile22 } 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,
@@ -5731,17 +5931,17 @@ function extractRetroFields(date, cycleName, block) {
   };
 }
 async function runCompound(input) {
-  const logPath = join30(input.vault, "log.md");
+  const logPath = join32(input.vault, "log.md");
   let logText;
   try {
-    logText = await readFile21(logPath, "utf8");
+    logText = await readFile22(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 = join30(input.vault, "projects", input.project, "compound");
+  const compoundDir = join32(input.vault, "projects", input.project, "compound");
   for (const entry of entries) {
     const generalizeValue = entry.generalize.trim();
     if (!/^yes/i.test(generalizeValue)) {
@@ -5749,8 +5949,8 @@ async function runCompound(input) {
       continue;
     }
     const slug = slugify(entry.cycleName);
-    const compoundPath = join30(compoundDir, `${slug}.md`);
-    if (existsSync9(compoundPath)) {
+    const compoundPath = join32(compoundDir, `${slug}.md`);
+    if (existsSync10(compoundPath)) {
       skipped.push(entry.date);
       continue;
     }
@@ -5788,10 +5988,10 @@ async function runCompound(input) {
     ].join("\n");
     const content = frontmatter + "\n" + body;
     if (!input.dryRun) {
-      if (!existsSync9(compoundDir)) {
+      if (!existsSync10(compoundDir)) {
         await mkdir10(compoundDir, { recursive: true });
       }
-      await writeFile11(compoundPath, content, "utf8");
+      await writeFile12(compoundPath, content, "utf8");
     }
     promoted.push(`${slug}.md`);
   }
@@ -5810,16 +6010,16 @@ async function runCompound(input) {
   };
 }
 async function runCompoundDelete(input) {
-  const projectDir = join30(input.vault, "projects", input.project);
-  if (!existsSync9(projectDir)) {
+  const projectDir = join32(input.vault, "projects", input.project);
+  if (!existsSync10(projectDir)) {
     return {
       exitCode: ExitCode.PROJECT_NOT_FOUND,
       result: err("PROJECT_NOT_FOUND", { slug: input.project, path: projectDir })
     };
   }
   const entryName = input.entry.replace(/\.md$/, "");
-  const compoundPath = join30(projectDir, "compound", `${entryName}.md`);
-  if (!existsSync9(compoundPath)) {
+  const compoundPath = join32(projectDir, "compound", `${entryName}.md`);
+  if (!existsSync10(compoundPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
       result: err("FILE_NOT_FOUND", { path: compoundPath })
@@ -5852,8 +6052,8 @@ knowledge.md regenerated`
   };
 }
 async function runCompoundList(input) {
-  const compoundDir = join30(input.vault, "projects", input.project, "compound");
-  if (!existsSync9(compoundDir)) {
+  const compoundDir = join32(input.vault, "projects", input.project, "compound");
+  if (!existsSync10(compoundDir)) {
     return {
       exitCode: ExitCode.OK,
       result: ok({
@@ -5883,10 +6083,10 @@ could not read compound directory`
   const entries = [];
   for (const dirent of dirents) {
     if (!dirent.isFile() || !dirent.name.endsWith(".md")) continue;
-    const filePath = join30(compoundDir, dirent.name);
+    const filePath = join32(compoundDir, dirent.name);
     let text;
     try {
-      text = await readFile21(filePath, "utf8");
+      text = await readFile22(filePath, "utf8");
     } catch {
       continue;
     }
@@ -5915,9 +6115,9 @@ no compound entries found`;
 }
 
 // src/commands/observe.ts
-import { mkdir as mkdir11, writeFile as writeFile12 } from "fs/promises";
-import { existsSync as existsSync10, statSync as statSync3 } from "fs";
-import { join as join31 } from "path";
+import { mkdir as mkdir11, writeFile as writeFile13 } from "fs/promises";
+import { existsSync as existsSync11, statSync as statSync4 } from "fs";
+import { join as join33 } from "path";
 import { createHash as createHash4 } from "crypto";
 var ALLOWED_KINDS = /* @__PURE__ */ new Set(["note", "bug", "task", "idea", "session-log"]);
 function slugify2(text) {
@@ -5940,13 +6140,13 @@ async function runObserve(input) {
       result: err("SCHEME_REJECTED", { message: "Text must not be empty" })
     };
   }
-  if (!existsSync10(input.vault) || !statSync3(input.vault).isDirectory()) {
+  if (!existsSync11(input.vault) || !statSync4(input.vault).isDirectory()) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("VAULT_PATH_INVALID", { path: input.vault })
     };
   }
-  const transcriptsDir = join31(input.vault, "raw", "transcripts");
+  const transcriptsDir = join33(input.vault, "raw", "transcripts");
   try {
     await mkdir11(transcriptsDir, { recursive: true });
   } catch {
@@ -5958,7 +6158,7 @@ async function runObserve(input) {
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const slug = slugify2(input.text);
   const fileName = `${today}-observation-${slug}.md`;
-  const filePath = join31(transcriptsDir, fileName);
+  const filePath = join33(transcriptsDir, fileName);
   const body = `
 ${input.text.trim()}
 `;
@@ -5976,7 +6176,7 @@ ${input.text.trim()}
   frontmatterLines.push("---");
   const content = frontmatterLines.join("\n") + body;
   try {
-    await writeFile12(filePath, content, "utf8");
+    await writeFile13(filePath, content, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -5998,8 +6198,8 @@ ${input.text.trim()}
 }
 
 // src/commands/ingest.ts
-import { readFile as readFile22, writeFile as writeFile13, mkdir as mkdir12 } from "fs/promises";
-import { join as join32 } from "path";
+import { readFile as readFile23, writeFile as writeFile14, mkdir as mkdir12 } from "fs/promises";
+import { join as join34 } from "path";
 import { createHash as createHash5 } from "crypto";
 var ALLOWED_TYPES = /* @__PURE__ */ new Set(["entity", "concept", "comparison", "query"]);
 var TYPE_DIR = {
@@ -6158,7 +6358,7 @@ async function runIngest(input) {
     sourceContent = fetchResult.data.body;
   } else {
     try {
-      sourceContent = await readFile22(input.source, "utf8");
+      sourceContent = await readFile23(input.source, "utf8");
     } catch {
       return {
         exitCode: ExitCode.FILE_NOT_FOUND,
@@ -6173,8 +6373,8 @@ async function runIngest(input) {
   const rawRelPath = `raw/articles/${slug}.md`;
   const typedDir = TYPE_DIR[input.type] ?? `${input.type}s`;
   const typedRelPath = `${typedDir}/${slug}.md`;
-  const rawAbsPath = join32(input.vault, rawRelPath);
-  const typedAbsPath = join32(input.vault, typedRelPath);
+  const rawAbsPath = join34(input.vault, rawRelPath);
+  const typedAbsPath = join34(input.vault, typedRelPath);
   const rawContent = buildRawContent(sourceUrl, today, sha256, sourceContent);
   const typedContent = buildTypedContent(
     input.title,
@@ -6237,8 +6437,8 @@ async function runIngest(input) {
     };
   }
   try {
-    await mkdir12(join32(input.vault, "raw", "articles"), { recursive: true });
-    await writeFile13(rawAbsPath, rawContent, "utf8");
+    await mkdir12(join34(input.vault, "raw", "articles"), { recursive: true });
+    await writeFile14(rawAbsPath, rawContent, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -6246,8 +6446,8 @@ async function runIngest(input) {
     };
   }
   try {
-    await mkdir12(join32(input.vault, typedDir), { recursive: true });
-    await writeFile13(typedAbsPath, typedContent, "utf8");
+    await mkdir12(join34(input.vault, typedDir), { recursive: true });
+    await writeFile14(typedAbsPath, typedContent, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -6425,12 +6625,12 @@ ${body}`;
 }
 
 // src/commands/sync.ts
-import { existsSync as existsSync12 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join36 } from "path";
 
 // src/utils/sync-lock.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync10, renameSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "fs";
-import { join as join33 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync10, renameSync, unlinkSync as unlinkSync5, writeFileSync as writeFileSync6 } from "fs";
+import { join as join35 } from "path";
 import { createHash as createHash6 } from "crypto";
 function getSessionId() {
   if (process.env.CLAUDE_SESSION_ID) return process.env.CLAUDE_SESSION_ID;
@@ -6438,11 +6638,11 @@ function getSessionId() {
   return process.pid.toString();
 }
 function lockPath(vault) {
-  return join33(vault, ".skillwiki", "sync.lock");
+  return join35(vault, ".skillwiki", "sync.lock");
 }
 function readLock(vault) {
   const path = lockPath(vault);
-  if (!existsSync11(path)) return null;
+  if (!existsSync12(path)) return null;
   try {
     const raw = readFileSync10(path, "utf8");
     return JSON.parse(raw);
@@ -6457,9 +6657,9 @@ function isStale(lock, now) {
 }
 function acquireLock(vault, opts = {}) {
   const path = lockPath(vault);
-  const dir = join33(vault, ".skillwiki");
-  if (!existsSync11(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  const dir = join35(vault, ".skillwiki");
+  if (!existsSync12(dir)) {
+    mkdirSync4(dir, { recursive: true });
   }
   const sessionId = opts.sessionId ?? getSessionId();
   const summary = opts.summary ?? "skillwiki sync";
@@ -6478,7 +6678,7 @@ function acquireLock(vault, opts = {}) {
   };
   try {
     const content = JSON.stringify(lock, null, 2) + "\n";
-    writeFileSync5(path, content, { flag: "wx" });
+    writeFileSync6(path, content, { flag: "wx" });
     return { ok: true, lock };
   } catch (e) {
     const err3 = e;
@@ -6498,19 +6698,19 @@ function acquireLock(vault, opts = {}) {
 function writeLockedFile(path, lock) {
   const tmp = path + ".tmp";
   const content = JSON.stringify(lock, null, 2) + "\n";
-  writeFileSync5(tmp, content);
+  writeFileSync6(tmp, content);
   renameSync(tmp, path);
 }
 function releaseLock(vault, opts = {}) {
   const path = lockPath(vault);
-  if (!existsSync11(path)) {
+  if (!existsSync12(path)) {
     return { released: false };
   }
   const sessionId = opts.sessionId ?? getSessionId();
   const existing = readLock(vault);
   if (opts.force) {
     try {
-      unlinkSync4(path);
+      unlinkSync5(path);
       const prior = existing && existing.session_id !== sessionId ? existing : void 0;
       return { released: true, prior };
     } catch {
@@ -6521,7 +6721,7 @@ function releaseLock(vault, opts = {}) {
     return { released: false };
   }
   try {
-    unlinkSync4(path);
+    unlinkSync5(path);
     return { released: true };
   } catch {
     return { released: false };
@@ -6532,7 +6732,7 @@ function releaseLock(vault, opts = {}) {
 function runSyncStatus(input) {
   const vault = input.vault;
   const includeStashes = input.includeStashes ?? false;
-  if (!existsSync12(join34(vault, ".git"))) {
+  if (!existsSync13(join36(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: ok({
@@ -6609,7 +6809,7 @@ function runSyncStatus(input) {
 }
 async function runSyncPush(input) {
   const vault = input.vault;
-  if (!existsSync12(join34(vault, ".git"))) {
+  if (!existsSync13(join36(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -6713,7 +6913,7 @@ function enumerateStashes(vault) {
 }
 async function runSyncPull(input) {
   const vault = input.vault;
-  if (!existsSync12(join34(vault, ".git"))) {
+  if (!existsSync13(join36(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -6881,7 +7081,7 @@ function runSyncPeers(input) {
 }
 function runSyncLock(input) {
   const vault = input.vault;
-  if (!existsSync12(vault)) {
+  if (!existsSync13(vault)) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("VAULT_PATH_INVALID", { path: vault })
@@ -6916,7 +7116,7 @@ function runSyncLock(input) {
 }
 function runSyncUnlock(input) {
   const vault = input.vault;
-  if (!existsSync12(vault)) {
+  if (!existsSync13(vault)) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("VAULT_PATH_INVALID", { path: vault })
@@ -6949,8 +7149,8 @@ function runSyncUnlock(input) {
 }
 
 // src/commands/backup.ts
-import { statSync as statSync4, readdirSync as readdirSync2, readFileSync as readFileSync11, mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "fs";
-import { join as join35, relative as relative3, dirname as dirname11 } from "path";
+import { statSync as statSync5, readdirSync as readdirSync2, readFileSync as readFileSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync7 } from "fs";
+import { join as join37, relative as relative3, dirname as dirname11 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
 // src/utils/s3-client.ts
@@ -6974,7 +7174,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 = join35(dir, entry.name);
+    const full = join37(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkMarkdown(full, base);
     } else if (entry.name.endsWith(".md")) {
@@ -6997,8 +7197,8 @@ async function runBackupSync(input) {
   let failed = 0;
   const files = [...walkMarkdown(input.vault, input.vault)];
   for (const relPath of files) {
-    const absPath = join35(input.vault, relPath);
-    const localStat = statSync4(absPath);
+    const absPath = join37(input.vault, relPath);
+    const localStat = statSync5(absPath);
     let needsUpload = true;
     try {
       const head = await client.send(new HeadObjectCommand({ Bucket: input.bucket, Key: relPath }));
@@ -7073,9 +7273,9 @@ async function runBackupRestore(input) {
     const objects = list.Contents ?? [];
     for (const obj of objects) {
       if (!obj.Key) continue;
-      const localPath = join35(target, obj.Key);
+      const localPath = join37(target, obj.Key);
       try {
-        const localStat = statSync4(localPath);
+        const localStat = statSync5(localPath);
         if (obj.LastModified && localStat.mtime > obj.LastModified) {
           conflicts++;
           continue;
@@ -7086,8 +7286,8 @@ async function runBackupRestore(input) {
         const resp = await client.send(new GetObjectCommand({ Bucket: input.bucket, Key: obj.Key }));
         const body = await resp.Body?.transformToByteArray();
         if (body) {
-          mkdirSync4(dirname11(localPath), { recursive: true });
-          writeFileSync6(localPath, Buffer.from(body));
+          mkdirSync5(dirname11(localPath), { recursive: true });
+          writeFileSync7(localPath, Buffer.from(body));
           downloaded++;
         }
       } catch {
@@ -7119,11 +7319,11 @@ async function runBackupRestore(input) {
 }
 
 // src/commands/status.ts
-import { existsSync as existsSync13, statSync as statSync5 } from "fs";
-import { readFile as readFile23 } from "fs/promises";
-import { join as join36 } from "path";
+import { existsSync as existsSync14, statSync as statSync6 } from "fs";
+import { readFile as readFile24 } from "fs/promises";
+import { join as join38 } from "path";
 async function runStatus(input) {
-  if (!existsSync13(input.vault)) {
+  if (!existsSync14(input.vault)) {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { vault: input.vault }) };
   }
   const scan = await scanVault(input.vault);
@@ -7148,7 +7348,7 @@ async function runStatus(input) {
   const compound = scan.data.compound.length;
   let schemaVersion = "v1";
   try {
-    const schemaContent = await readFile23(join36(input.vault, "SCHEMA.md"), "utf8");
+    const schemaContent = await readFile24(join38(input.vault, "SCHEMA.md"), "utf8");
     const versionMatch = schemaContent.match(/version:\s*["']?([^"'\s\n]+)/i);
     if (versionMatch) schemaVersion = versionMatch[1];
   } catch {
@@ -7164,7 +7364,7 @@ async function runStatus(input) {
   let maxTime = 0;
   for (const page of allPages) {
     try {
-      const st = statSync5(page.absPath);
+      const st = statSync6(page.absPath);
       if (st.mtimeMs > maxTime) {
         maxTime = st.mtimeMs;
         lastModified = st.mtime.toISOString();
@@ -7208,8 +7408,8 @@ async function runStatus(input) {
 }
 
 // src/commands/seed.ts
-import { mkdir as mkdir13, writeFile as writeFile14, stat as stat7 } from "fs/promises";
-import { join as join37 } from "path";
+import { mkdir as mkdir13, writeFile as writeFile15, stat as stat8 } from "fs/promises";
+import { join as join39 } from "path";
 var TODAY = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 var EXAMPLE_PAGES = {
   "entities/example-project.md": `---
@@ -7278,30 +7478,30 @@ Real sources are immutable after ingestion \u2014 never edit them.
 `;
 async function runSeed(input) {
   try {
-    await stat7(join37(input.vault, "SCHEMA.md"));
+    await stat8(join39(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 = join37(input.vault, relPath);
+    const absPath = join39(input.vault, relPath);
     try {
-      await stat7(absPath);
+      await stat8(absPath);
       skipped.push(relPath);
     } catch {
-      await mkdir13(join37(absPath, ".."), { recursive: true });
-      await writeFile14(absPath, content, "utf8");
+      await mkdir13(join39(absPath, ".."), { recursive: true });
+      await writeFile15(absPath, content, "utf8");
       created.push(relPath);
     }
   }
-  const rawPath = join37(input.vault, "raw", "articles", "example-source.md");
+  const rawPath = join39(input.vault, "raw", "articles", "example-source.md");
   try {
-    await stat7(rawPath);
+    await stat8(rawPath);
     skipped.push("raw/articles/example-source.md");
   } catch {
-    await mkdir13(join37(rawPath, ".."), { recursive: true });
-    await writeFile14(rawPath, EXAMPLE_RAW, "utf8");
+    await mkdir13(join39(rawPath, ".."), { recursive: true });
+    await writeFile15(rawPath, EXAMPLE_RAW, "utf8");
     created.push("raw/articles/example-source.md");
   }
   if (created.length > 0) {
@@ -7323,9 +7523,9 @@ async function runSeed(input) {
 }
 
 // src/commands/canvas.ts
-import { readFile as readFile24, writeFile as writeFile15 } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
-import { join as join38 } from "path";
+import { readFile as readFile25, writeFile as writeFile16 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import { join as join40 } from "path";
 var NODE_WIDTH = 240;
 var NODE_HEIGHT = 60;
 var COLUMN_SPACING = 400;
@@ -7403,8 +7603,8 @@ function buildCanvasEdges(adjacency) {
   return edges;
 }
 async function runCanvasGenerate(input) {
-  const graphPath = input.graphPath ?? join38(input.vault, ".skillwiki", "graph.json");
-  if (!existsSync14(graphPath)) {
+  const graphPath = input.graphPath ?? join40(input.vault, ".skillwiki", "graph.json");
+  if (!existsSync15(graphPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
       result: err("FILE_NOT_FOUND", {
@@ -7415,7 +7615,7 @@ async function runCanvasGenerate(input) {
   }
   let raw;
   try {
-    raw = await readFile24(graphPath, "utf8");
+    raw = await readFile25(graphPath, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -7441,9 +7641,9 @@ async function runCanvasGenerate(input) {
   const nodes = buildCanvasNodes(paths);
   const edges = buildCanvasEdges(graph.adjacency);
   const canvas = { nodes, edges };
-  const outPath = join38(input.vault, "vault-graph.canvas");
+  const outPath = join40(input.vault, "vault-graph.canvas");
   try {
-    await writeFile15(outPath, JSON.stringify(canvas, null, 2));
+    await writeFile16(outPath, JSON.stringify(canvas, null, 2));
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -7463,8 +7663,8 @@ written: ${outPath}`
 }
 
 // src/commands/query.ts
-import { readFile as readFile25, stat as stat8 } from "fs/promises";
-import { join as join39 } from "path";
+import { readFile as readFile26, stat as stat9 } from "fs/promises";
+import { join as join41 } from "path";
 var W_KEYWORD = 2;
 var W_SOURCE_OVERLAP = 4;
 var W_WIKILINK = 3;
@@ -7585,10 +7785,10 @@ function computeKeywordScore(terms, title, tags, body) {
   return score;
 }
 async function loadOrBuildGraph(vault) {
-  const graphPath = join39(vault, ".skillwiki", "graph.json");
+  const graphPath = join41(vault, ".skillwiki", "graph.json");
   let needsBuild = false;
   try {
-    const fileStat = await stat8(graphPath);
+    const fileStat = await stat9(graphPath);
     const ageHours = (Date.now() - fileStat.mtimeMs) / (1e3 * 60 * 60);
     if (ageHours > 24) needsBuild = true;
   } catch {
@@ -7599,7 +7799,7 @@ async function loadOrBuildGraph(vault) {
     if (buildResult.exitCode !== 0) return null;
   }
   try {
-    const raw = await readFile25(graphPath, "utf8");
+    const raw = await readFile26(graphPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -7607,14 +7807,14 @@ async function loadOrBuildGraph(vault) {
 }
 
 // src/utils/auto-commit.ts
-import { existsSync as existsSync15 } from "fs";
-import { join as join40 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join42 } from "path";
 async function postCommit(vault, exitCode) {
   if (exitCode !== 0) return;
   const home = process.env.HOME ?? "";
   const dotenv = await parseDotenvFile(configPath(home));
   if (dotenv["AUTO_COMMIT"] === "false") return;
-  if (!existsSync15(join40(vault, ".git"))) return;
+  if (!existsSync16(join42(vault, ".git"))) return;
   const lastOps = readLastOp(vault);
   if (lastOps.length === 0) return;
   const porcelain = git(vault, ["status", "--porcelain"]);
@@ -7665,7 +7865,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 ?? join41(vault, ".skillwiki", "graph.json");
+  const out = opts.out ?? join43(vault, ".skillwiki", "graph.json");
   emit(await runGraphBuild({ vault, out }), vault);
 });
 var canvasCmd = program.command("canvas").description("manage Obsidian canvas files");
@@ -7791,7 +7991,12 @@ program.command("log-rotate [vault]").description("rotate or trim the vault log
   if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
   else emit(await runLogRotate({ vault: v.vault, threshold: opts.threshold, apply: !!opts.apply }), v.vault);
 });
-program.command("lint [vault]").description("run all vault health checks").option("--days <n>", "stale threshold", (s) => parseInt(s, 10), 90).option("--lines <n>", "pagesize threshold", (s) => parseInt(s, 10), 200).option("--log-threshold <n>", "log rotation threshold", (s) => parseInt(s, 10), 500).option("--fix", "auto-fix legacy_citation_style violations").option("--only <bucket>", "run only the specified lint bucket").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+program.command("log-append [vault]").description("append a single entry to the vault log under a short advisory lock").requiredOption("--content <text>", "log entry text to append").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 runLogAppend({ vault: v.vault, content: opts.content }), v.vault);
+});
+program.command("lint [vault]").description("run all vault health checks").option("--days <n>", "stale threshold", (s) => parseInt(s, 10), 90).option("--lines <n>", "pagesize threshold", (s) => parseInt(s, 10), 200).option("--log-threshold <n>", "log rotation threshold", (s) => parseInt(s, 10), 500).option("--fix", "auto-fix supported lint violations").option("--only <bucket>", "run only the specified lint bucket").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 runLint({