skillwiki 0.10.112 → 0.10.113

package/dist/{chunk-Q6EZF37H.js → chunk-FQERKMD7.js}

@@ -18,10 +18,10 @@ import {
   resolveExistingRegularFileInsideVault,
   stripFencedBlocks,
   writeLogEvent
-} from "./chunk-CKQPUHM2.js";
+} from "./chunk-K3YZESND.js";
 import {
   buildRootIndexUniverse
-} from "./chunk-KJG2CSYD.js";
+} from "./chunk-3TKNAOJH.js";
 import {
   extractFrontmatter,
   filterGitIgnoredRelativePaths,
@@ -34,23 +34,23 @@ import {
   scanVault,
   splitFrontmatter,
   vaultIoConcurrency
-} from "./chunk-TKX6PSWZ.js";
+} from "./chunk-JL2SCLXT.js";
 import {
   atomicWriteText
-} from "./chunk-EE7W3GLA.js";
+} from "./chunk-6VUK2FTX.js";
 import {
   parseDotenvFile,
   parseDotenvText,
   profileKey,
   resolveSkillwikiHome
-} from "./chunk-SKOLE6US.js";
+} from "./chunk-IJKJGQKL.js";
 import {
   ExitCode,
   FleetManifestSchema,
   err,
   getErrorMessage,
   ok
-} from "./chunk-7POLZOFY.js";
+} from "./chunk-VNSZCK5V.js";
 
 // src/utils/managed-write-preflight.ts
 import { existsSync as existsSync11 } from "fs";
@@ -598,7 +598,17 @@ var WARNING_ORDER = [
   "orphaned_project_pages",
   "missing_overview",
   "missing_diagram",
-  "cycle_traps"
+  "cycle_traps",
+  "ste_sentence_length",
+  "ste_hedge_words",
+  "ste_diagram_uncertainty",
+  "ste_comparison_visual"
+];
+var ADVISORY_WARNING_ORDER = [
+  "ste_sentence_length",
+  "ste_hedge_words",
+  "ste_diagram_uncertainty",
+  "ste_comparison_visual"
 ];
 var INFO_ORDER = [
   "bridges",
@@ -692,6 +702,15 @@ function severityForBucket(kind) {
   if (WARNING_ORDER.includes(kind)) return "warning";
   return "info";
 }
+function isAdvisoryLintWarning(kind) {
+  return ADVISORY_WARNING_ORDER.includes(kind);
+}
+function lintExitCode(summary, warningBuckets) {
+  if (summary.errors > 0) return ExitCode.LINT_HAS_ERRORS;
+  const blockingWarnings = warningBuckets.filter((bucket) => !isAdvisoryLintWarning(bucket.kind)).reduce((n, bucket) => n + bucket.items.length, 0);
+  if (blockingWarnings > 0 || summary.info > 0) return ExitCode.LINT_HAS_WARNINGS;
+  return ExitCode.OK;
+}
 function lintReadVault(input) {
   if (input.fix) {
     return { readPath: input.vault, readMirror: false };
@@ -766,9 +785,7 @@ function outputForOnlyBucket(input, match, fixed, unresolved, readVault = lintRe
     warnings: filtered.warning.reduce((n, b) => n + b.items.length, 0),
     info: filtered.info.reduce((n, b) => n + b.items.length, 0)
   };
-  let exitCode = ExitCode.OK;
-  if (summary.errors > 0) exitCode = ExitCode.LINT_HAS_ERRORS;
-  else if (summary.warnings > 0 || summary.info > 0) exitCode = ExitCode.LINT_HAS_WARNINGS;
+  const exitCode = lintExitCode(summary, filtered.warning);
   const vault = lintVaultOutput(input, readVault);
   const hintLines = [
     ...readMirrorHintLines(vault),
@@ -3276,7 +3293,7 @@ function buildCliSurface() {
   program.command("observe").requiredOption("--text <text>").option("--kind <kind>").option("--project <slug>").option("--severity <level>").option("--capture-budget <n>").option("--wiki <name>");
   program.command("session-brief").option("--project <slug>").option("--write").option("--agent-memory-run-state <path>").option("--wiki <name>");
   program.command("memory");
-  program.command("ingest").requiredOption("--vault <path>").requiredOption("--type <type>").requiredOption("--title <title>").option("--tags <csv>").option("--provenance <provenance>").option("--dry-run");
+  program.command("ingest").requiredOption("--vault <path>").requiredOption("--type <type>").requiredOption("--title <title>").option("--tags <csv>").option("--provenance <provenance>").option("--html").option("--dry-run");
   program.command("fleet");
   program.command("page");
   program.command("project-page");
@@ -3317,6 +3334,7 @@ function buildCliSurface() {
   tagCmd.command("reconcile").requiredOption("--page <path>").option("--from <path>").option("--tags <csv>").option("--reason <text>").option("--write").option("--wiki <name>");
   const pageCmd = program.commands.find((c) => c.name() === "page");
   pageCmd.command("publish").requiredOption("--target <path>").option("--log-note <text>").option("--write").option("--approve <token>").option("--wiki <name>");
+  pageCmd.command("render-html").requiredOption("--out <file>").option("--wiki <name>");
   const projectPageCmd = program.commands.find((c) => c.name() === "project-page");
   projectPageCmd.command("publish").requiredOption("--project <slug>").requiredOption("--target <path>").option("--log-note <text>").option("--write").option("--approve <token>").option("--wiki <name>");
   const claimsCmd = program.commands.find((c) => c.name() === "claims");
@@ -3511,6 +3529,346 @@ function assessSourceIdentity(input) {
   return { status: "ok", pathSignals, sourceSignals, bodySignals, reasons };
 }
 
+// src/lint/ste.ts
+var URL_RE = /https?:\/\/[^\s)<>]+/gi;
+var CITATION_RE = /\^\[raw\/[^\]]+\]/g;
+var FENCE_OPEN = /^(\s*)(`{3,}|~{3,})(.*)$/;
+var HEADING_RE2 = /^(#{1,6})\s+(\S.*)$/;
+var ORDERED_ITEM_RE = /^(\s*)\d+\.\s+(.*)$/;
+var UNORDERED_ITEM_RE = /^(\s*)[-*+]\s+(.*)$/;
+var TABLE_ROW_RE = /^\s*\|.*\|\s*$/;
+var BLOCKQUOTE_RE = /^\s*>/;
+var LEAST_CERTAIN_RE = /^\s*\*\*Least certain:\*\*\s*$/;
+var UNCERTAINTY_HEADING_RE = /^##\s+Uncertainty\s*$/i;
+var STEPS_HEADING_RE = /^(Steps|Procedure)\b/i;
+var LEAST_CERTAIN_FOLLOWING_RE = /^\s*\*\*Least certain:\*\*\s*\n(?:[ \t]*[-*+][ \t]+\S.*\n?)+/;
+var HEDGE_PHRASES = ["appears to", "could be"];
+var HEDGE_WORDS = [
+  "might",
+  "may",
+  "perhaps",
+  "possibly",
+  "probably",
+  "likely",
+  "seems",
+  "arguably",
+  "somewhat"
+];
+var STE_PROSE_WORD_LIMIT = 25;
+var STE_INSTRUCTION_WORD_LIMIT = 20;
+function isOutputStandardV2(fm) {
+  return fm.output_standard === "v2";
+}
+function stripUrlsAndCitations(text) {
+  return text.replace(URL_RE, " ").replace(CITATION_RE, " ");
+}
+function countWords(text) {
+  const cleaned = stripUrlsAndCitations(text).trim();
+  if (!cleaned) return 0;
+  return cleaned.split(/\s+/).filter(Boolean).length;
+}
+function splitSentences(text) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (!normalized) return [];
+  return normalized.split(/(?<=[.!?])\s+/).map((part) => part.trim()).filter(Boolean);
+}
+function hedgePattern() {
+  const phrases = HEDGE_PHRASES.map((p) => p.replace(/\s+/g, "\\s+"));
+  const words = HEDGE_WORDS.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(`\\b(?:${[...phrases, ...words].join("|")})\\b`, "gi");
+}
+function findHedgeMatches(text) {
+  const matches = text.match(hedgePattern());
+  if (!matches) return [];
+  return [...new Set(matches.map((m) => m.toLowerCase().replace(/\s+/g, " ")))];
+}
+function toggleFence(line, fence) {
+  const match = line.match(FENCE_OPEN);
+  if (!match) return false;
+  const marker = match[2];
+  if (!fence.open) {
+    fence.open = true;
+    fence.marker = marker;
+    return true;
+  }
+  if (marker[0] === fence.marker[0] && marker.length >= fence.marker.length && match[3].trim() === "") {
+    fence.open = false;
+    fence.marker = "";
+    return true;
+  }
+  return false;
+}
+function isTableSeparator(line) {
+  return /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(line);
+}
+function hasMarkdownTable(body) {
+  const fence = { open: false, marker: "" };
+  const lines = body.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (toggleFence(line, fence) || fence.open) continue;
+    if (TABLE_ROW_RE.test(line) && i + 1 < lines.length && isTableSeparator(lines[i + 1])) {
+      return true;
+    }
+  }
+  return false;
+}
+function fenceLanguage(line) {
+  const match = line.match(FENCE_OPEN);
+  if (!match) return "";
+  return match[3].trim().split(/\s+/)[0]?.toLowerCase() ?? "";
+}
+function hasMermaidBlock(body) {
+  const fence = { open: false, marker: "" };
+  for (const line of body.split(/\r?\n/)) {
+    if (!fence.open && fenceLanguage(line) === "mermaid") return true;
+    toggleFence(line, fence);
+  }
+  return false;
+}
+function mermaidBlocksMissingLeastCertain(body) {
+  const lines = body.split(/\r?\n/);
+  const fence = { open: false, marker: "" };
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const startingMermaid = !fence.open && fenceLanguage(line) === "mermaid";
+    if (toggleFence(line, fence)) {
+      if (startingMermaid) {
+        i++;
+        while (i < lines.length && fence.open) {
+          toggleFence(lines[i], fence);
+          i++;
+        }
+        const after = lines.slice(i).join("\n");
+        if (!LEAST_CERTAIN_FOLLOWING_RE.test(after)) return true;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return false;
+}
+function comparisonLacksVisual(body) {
+  return !hasMarkdownTable(body) && !hasMermaidBlock(body);
+}
+function headingLevel(line) {
+  const match = line.match(HEADING_RE2);
+  if (!match) return null;
+  return { level: match[1].length, title: match[2].trim() };
+}
+function collectListItem(lines, start, markerRe) {
+  const first = lines[start].replace(markerRe, "$2");
+  const chunks = [first];
+  let i = start + 1;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.trim()) break;
+    if (HEADING_RE2.test(line) || FENCE_OPEN.test(line) || ORDERED_ITEM_RE.test(line) || UNORDERED_ITEM_RE.test(line) || TABLE_ROW_RE.test(line) || BLOCKQUOTE_RE.test(line)) {
+      break;
+    }
+    if (/^\s+\S/.test(line)) {
+      chunks.push(line.trim());
+      i++;
+      continue;
+    }
+    break;
+  }
+  return { text: chunks.join(" "), next: i };
+}
+function findLongUnits(body) {
+  const lines = body.split(/\r?\n/);
+  const fence = { open: false, marker: "" };
+  let underStepsUntilLevel = null;
+  const findings = [];
+  let paragraph = [];
+  const flushParagraph = () => {
+    if (paragraph.length === 0) return;
+    const text = paragraph.join(" ");
+    paragraph = [];
+    for (const sentence of splitSentences(text)) {
+      const words = countWords(sentence);
+      if (words > STE_PROSE_WORD_LIMIT) {
+        findings.push({ text: sentence, words, limit: STE_PROSE_WORD_LIMIT });
+      }
+    }
+  };
+  const checkInstruction = (text) => {
+    const words = countWords(text);
+    if (words > STE_INSTRUCTION_WORD_LIMIT) {
+      findings.push({ text, words, limit: STE_INSTRUCTION_WORD_LIMIT });
+    }
+  };
+  const checkProseChunk = (text) => {
+    for (const sentence of splitSentences(text)) {
+      const words = countWords(sentence);
+      if (words > STE_PROSE_WORD_LIMIT) {
+        findings.push({ text: sentence, words, limit: STE_PROSE_WORD_LIMIT });
+      }
+    }
+  };
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (toggleFence(line, fence)) {
+      flushParagraph();
+      i++;
+      continue;
+    }
+    if (fence.open) {
+      i++;
+      continue;
+    }
+    const heading = headingLevel(line);
+    if (heading) {
+      flushParagraph();
+      if (STEPS_HEADING_RE.test(heading.title)) {
+        underStepsUntilLevel = heading.level;
+      } else if (underStepsUntilLevel !== null && heading.level <= underStepsUntilLevel) {
+        underStepsUntilLevel = null;
+      }
+      i++;
+      continue;
+    }
+    if (BLOCKQUOTE_RE.test(line) || TABLE_ROW_RE.test(line) || isTableSeparator(line)) {
+      flushParagraph();
+      i++;
+      continue;
+    }
+    const ordered = line.match(ORDERED_ITEM_RE);
+    if (ordered) {
+      flushParagraph();
+      const item = collectListItem(lines, i, ORDERED_ITEM_RE);
+      checkInstruction(item.text);
+      i = item.next;
+      continue;
+    }
+    const unordered = line.match(UNORDERED_ITEM_RE);
+    if (unordered) {
+      flushParagraph();
+      const item = collectListItem(lines, i, UNORDERED_ITEM_RE);
+      if (underStepsUntilLevel !== null) checkInstruction(item.text);
+      else checkProseChunk(item.text);
+      i = item.next;
+      continue;
+    }
+    if (!line.trim()) {
+      flushParagraph();
+      i++;
+      continue;
+    }
+    paragraph.push(line.trim());
+    i++;
+  }
+  flushParagraph();
+  return findings;
+}
+function hasSteSentenceLengthViolation(body) {
+  return findLongUnits(body).length > 0;
+}
+function isEscapedBacktick(text, index) {
+  let slashes = 0;
+  for (let i = index - 1; i >= 0 && text[i] === "\\"; i--) slashes++;
+  return slashes % 2 === 1;
+}
+function backtickRunLength(text, index) {
+  let n = 0;
+  while (index + n < text.length && text[index + n] === "`") n++;
+  return n;
+}
+function stripInlineCodeSpans(text) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === "`" && !isEscapedBacktick(text, i)) {
+      const n = backtickRunLength(text, i);
+      let j = i + n;
+      let closed = false;
+      while (j < text.length) {
+        if (text[j] === "`") {
+          const m = backtickRunLength(text, j);
+          if (m === n) {
+            out += " ";
+            i = j + m;
+            closed = true;
+            break;
+          }
+          j += m;
+          continue;
+        }
+        j++;
+      }
+      if (!closed) {
+        out += text.slice(i, i + n);
+        i += n;
+      }
+      continue;
+    }
+    out += text[i];
+    i++;
+  }
+  return out;
+}
+function isLeastCertainListItemLine(line) {
+  return UNORDERED_ITEM_RE.test(line) || ORDERED_ITEM_RE.test(line) || /^\s+\S/.test(line);
+}
+function findHedgesOutsideAllowedRegions(body) {
+  const lines = body.split(/\r?\n/);
+  const fence = { open: false, marker: "" };
+  let uncertaintyUntilLevel = null;
+  let skippingLeastCertainList = false;
+  let leastCertainSawBlank = false;
+  const found = [];
+  const endLeastCertainList = () => {
+    skippingLeastCertainList = false;
+    leastCertainSawBlank = false;
+  };
+  for (const line of lines) {
+    if (toggleFence(line, fence)) {
+      endLeastCertainList();
+      continue;
+    }
+    if (fence.open) continue;
+    const heading = headingLevel(line);
+    if (heading) {
+      endLeastCertainList();
+      if (UNCERTAINTY_HEADING_RE.test(line)) {
+        uncertaintyUntilLevel = heading.level;
+      } else if (uncertaintyUntilLevel !== null && heading.level <= uncertaintyUntilLevel) {
+        uncertaintyUntilLevel = null;
+      }
+      continue;
+    }
+    if (uncertaintyUntilLevel !== null || BLOCKQUOTE_RE.test(line)) {
+      endLeastCertainList();
+      continue;
+    }
+    if (LEAST_CERTAIN_RE.test(line)) {
+      skippingLeastCertainList = true;
+      leastCertainSawBlank = false;
+      continue;
+    }
+    if (skippingLeastCertainList) {
+      if (!line.trim()) {
+        leastCertainSawBlank = true;
+        continue;
+      }
+      if (isLeastCertainListItemLine(line) || !leastCertainSawBlank) {
+        leastCertainSawBlank = false;
+        continue;
+      }
+      endLeastCertainList();
+    }
+    found.push(...findHedgeMatches(stripInlineCodeSpans(line)));
+  }
+  return [...new Set(found)];
+}
+function hasSteHedgeViolation(body) {
+  return findHedgesOutsideAllowedRegions(body).length > 0;
+}
+
 // src/lint/rules.ts
 async function collectCliRefsPages(vault) {
   if (!existsSync4(join13(vault, "SCHEMA.md"))) {
@@ -4934,6 +5292,83 @@ var cycleTrapsRule = {
     return { buckets };
   }
 };
+var steSentenceLengthRule = {
+  id: "ste_sentence_length",
+  severity: "warning",
+  async run(ctx) {
+    const items = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const fm = extractFrontmatter(text);
+        if (!fm.ok || !isOutputStandardV2(fm.data)) return;
+        const split = splitFrontmatter(text);
+        if (!split.ok) return;
+        if (hasSteSentenceLengthViolation(split.data.body)) items.push(page.relPath);
+      } catch {
+      }
+    });
+    return { buckets: items.length > 0 ? { ste_sentence_length: items } : {} };
+  }
+};
+var steHedgeWordsRule = {
+  id: "ste_hedge_words",
+  severity: "warning",
+  async run(ctx) {
+    const items = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const fm = extractFrontmatter(text);
+        if (!fm.ok || !isOutputStandardV2(fm.data)) return;
+        const split = splitFrontmatter(text);
+        if (!split.ok) return;
+        if (hasSteHedgeViolation(split.data.body)) items.push(page.relPath);
+      } catch {
+      }
+    });
+    return { buckets: items.length > 0 ? { ste_hedge_words: items } : {} };
+  }
+};
+var steDiagramUncertaintyRule = {
+  id: "ste_diagram_uncertainty",
+  severity: "warning",
+  async run(ctx) {
+    const items = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const fm = extractFrontmatter(text);
+        if (!fm.ok || !isOutputStandardV2(fm.data)) return;
+        const split = splitFrontmatter(text);
+        if (!split.ok) return;
+        if (mermaidBlocksMissingLeastCertain(split.data.body)) items.push(page.relPath);
+      } catch {
+      }
+    });
+    return { buckets: items.length > 0 ? { ste_diagram_uncertainty: items } : {} };
+  }
+};
+var steComparisonVisualRule = {
+  id: "ste_comparison_visual",
+  severity: "warning",
+  async run(ctx) {
+    const items = [];
+    await mapWithConcurrency(ctx.scan.typedKnowledge, vaultIoConcurrency(), async (page) => {
+      try {
+        const text = await readPageCached(page, ctx.pageTextCache);
+        const fm = extractFrontmatter(text);
+        if (!fm.ok || !isOutputStandardV2(fm.data)) return;
+        if (fm.data.type !== "comparison") return;
+        const split = splitFrontmatter(text);
+        if (!split.ok) return;
+        if (comparisonLacksVisual(split.data.body)) items.push(page.relPath);
+      } catch {
+      }
+    });
+    return { buckets: items.length > 0 ? { ste_comparison_visual: items } : {} };
+  }
+};
 var LINT_RULES = [
   brokenWikilinksRule,
   tagNotInTaxonomyRule,
@@ -4968,7 +5403,11 @@ var LINT_RULES = [
   orphanedProjectPagesRule,
   cliRefsRule,
   staleSectionsRule,
-  cycleTrapsRule
+  cycleTrapsRule,
+  steSentenceLengthRule,
+  steHedgeWordsRule,
+  steDiagramUncertaintyRule,
+  steComparisonVisualRule
 ];
 
 // src/utils/git-archive.ts
@@ -5118,9 +5557,7 @@ var LintRunner = class {
       warnings: warningOut.reduce((n, b) => n + b.items.length, 0),
       info: infoOut.reduce((n, b) => n + b.items.length, 0)
     };
-    let exitCode = ExitCode.OK;
-    if (summary.errors > 0) exitCode = ExitCode.LINT_HAS_ERRORS;
-    else if (summary.warnings > 0 || summary.info > 0) exitCode = ExitCode.LINT_HAS_WARNINGS;
+    const exitCode = lintExitCode(summary, warningOut);
     const vault = lintVaultOutput(input, readVault);
     const hintLines = [];
     hintLines.push(...readMirrorHintLines(vault));
@@ -6156,10 +6593,12 @@ async function runSyncPull(input) {
   const pathFixCount = pathFix.result.ok ? pathFix.result.data.fixed.length : 0;
   let lintErrors = 0;
   let lintWarnings = 0;
+  let blockingLintWarnings = 0;
   const lintResult = await runLint({ vault, days: 90, lines: 200, logThreshold: 500 });
   if (lintResult.result.ok) {
     lintErrors = lintResult.result.data.summary.errors;
     lintWarnings = lintResult.result.data.summary.warnings;
+    blockingLintWarnings = lintResult.result.data.by_severity.warning.filter((bucket) => !isAdvisoryLintWarning(bucket.kind)).reduce((n, bucket) => n + bucket.items.length, 0);
   }
   const hintParts = [];
   if (filesUpdated > 0) hintParts.push(`updated ${filesUpdated} file(s)`);
@@ -6167,7 +6606,7 @@ async function runSyncPull(input) {
   if (pathFixCount > 0) hintParts.push(`${pathFixCount} long path(s) fixed`);
   if (lintErrors > 0) hintParts.push(`${lintErrors} lint error(s)`);
   if (lintWarnings > 0) hintParts.push(`${lintWarnings} lint warning(s)`);
-  const exitCode = lintErrors > 0 ? ExitCode.LINT_HAS_ERRORS : lintWarnings > 0 ? ExitCode.LINT_HAS_WARNINGS : ExitCode.OK;
+  const exitCode = lintErrors > 0 ? ExitCode.LINT_HAS_ERRORS : blockingLintWarnings > 0 ? ExitCode.LINT_HAS_WARNINGS : ExitCode.OK;
   return {
     exitCode,
     result: ok({
@@ -7280,6 +7719,7 @@ export {
   louvain,
   communityCohesion,
   extractIssuePage,
+  isAdvisoryLintWarning,
   extractGitTree,
   runLinks,
   extractTaxonomy,

package/dist/{chunk-SKOLE6US.js → chunk-IJKJGQKL.js}

@@ -2,7 +2,7 @@
 import {
   isClipOutboxKey,
   isVaultSyncKey
-} from "./chunk-7POLZOFY.js";
+} from "./chunk-VNSZCK5V.js";
 
 // src/utils/home.ts
 import { homedir } from "os";

package/dist/{chunk-IR2DI4Y5.js → chunk-IJWZDQDH.js}

@@ -2,14 +2,14 @@
 import {
   ROOT_INDEX_SECTION_ORDER,
   buildRootIndexUniverse
-} from "./chunk-KJG2CSYD.js";
+} from "./chunk-3TKNAOJH.js";
 import {
   atomicWriteText
-} from "./chunk-EE7W3GLA.js";
+} from "./chunk-6VUK2FTX.js";
 import {
   err,
   ok
-} from "./chunk-7POLZOFY.js";
+} from "./chunk-VNSZCK5V.js";
 
 // src/utils/index-projection.ts
 import { readFile } from "fs/promises";

package/dist/{chunk-TKX6PSWZ.js → chunk-JL2SCLXT.js}

@@ -3,7 +3,7 @@ import {
   err,
   getErrorMessage,
   ok
-} from "./chunk-7POLZOFY.js";
+} from "./chunk-VNSZCK5V.js";
 
 // src/parsers/frontmatter.ts
 import yaml from "js-yaml";

package/dist/{chunk-CKQPUHM2.js → chunk-K3YZESND.js}

@@ -4,11 +4,11 @@ import {
   readPage,
   scanSensitiveContent,
   splitFrontmatter
-} from "./chunk-TKX6PSWZ.js";
+} from "./chunk-JL2SCLXT.js";
 import {
   err,
   ok
-} from "./chunk-7POLZOFY.js";
+} from "./chunk-VNSZCK5V.js";
 
 // src/utils/vault-path-safety.ts
 import { lstatSync, realpathSync } from "fs";

package/dist/{chunk-DOHWNPAZ.js → chunk-OGEAFXON.js}

@@ -2,7 +2,7 @@
 import {
   parseDotenvFile,
   resolveSkillwikiHome
-} from "./chunk-SKOLE6US.js";
+} from "./chunk-IJKJGQKL.js";
 
 // src/utils/mcp-auth-env.ts
 import { join } from "path";

package/dist/{chunk-ABRYBO4T.js → chunk-OWWWO2XS.js}

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 import {
   defaultLookup
-} from "./chunk-LOVLZNLX.js";
+} from "./chunk-5D5HFQ76.js";
 import {
   parseDotenvFile,
   resolveSkillwikiHome
-} from "./chunk-SKOLE6US.js";
+} from "./chunk-IJKJGQKL.js";
 import {
   CLIP_OUTBOX_DEFAULTS,
   ipv4InCidr,
   isClipOutboxKey,
   parseClipOutboxKeyValue
-} from "./chunk-7POLZOFY.js";
+} from "./chunk-VNSZCK5V.js";
 
 // src/clip-outbox/runtime.ts
 import { existsSync as existsSync2 } from "fs";

package/dist/{chunk-FCA3RRNF.js → chunk-SEY4N4CT.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   atomicWriteText
-} from "./chunk-EE7W3GLA.js";
+} from "./chunk-6VUK2FTX.js";
 
 // src/clip-outbox/journal.ts
 import { mkdir, readFile, open } from "fs/promises";