@mrciphersmith/keryx 0.3.81 → 0.3.83

package/dist/core.js

@@ -10853,7 +10853,7 @@ var init_skill_length_ceilings = __esm(() => {
     "review/review-jev-scenarios": 187,
     "review/review-layout": 238,
     "review/review-logic": 377,
-    "review/review-orchestrator": 1723,
+    "review/review-orchestrator": 1712,
     "review/review-performance": 374,
     "review/review-pr-feedback": 895,
     "review/review-regression": 216,
@@ -22803,7 +22803,7 @@ var MARKER_VERSION = 1, BEGIN, END, REFERENCE_HEADING;
 var init_managed_block = __esm(() => {
   BEGIN = /^<!--\s*keryx:reference:begin\s+v=(\d+)(?:\s+hash=([0-9a-f]{64}))?\s*-->$/;
   END = /^<!--\s*keryx:reference:end\s*-->$/;
-  REFERENCE_HEADING = /^##\s+Reference\b/i;
+  REFERENCE_HEADING = /^##\s+Reference(?:\s*\([^)]*\))?\s*$/i;
 });
 
 // src/wiki/page-invariants.ts
@@ -23010,6 +23010,49 @@ ${entry}
   return all.join(`
 `);
 }
+function repairVersionAndOrder(markdown) {
+  let next = markdown;
+  const all = next.split(`
+`);
+  const range = changelogRange(all);
+  if (range !== null) {
+    const mask = fencedLines2(all);
+    const starts = [];
+    for (let index = range.heading + 1;index < range.end; index += 1) {
+      if (!mask[index] && ENTRY_START.test(all[index]))
+        starts.push(index);
+    }
+    const chunks = starts.map((start, position) => {
+      const end = position + 1 < starts.length ? starts[position + 1] : range.end;
+      const body = all.slice(start, end);
+      while (body.length > 1 && body[body.length - 1].trim() === "")
+        body.pop();
+      return { body, version: ENTRY_VERSION.exec(body[0])?.[1] ?? null };
+    });
+    const ordered = chunks.every((chunk) => chunk.version !== null) ? [...chunks].sort((left, right) => compareVersions(right.version, left.version)) : chunks;
+    if (ordered.some((chunk, index) => chunk !== chunks[index])) {
+      const spaced = starts.length > 1 && all[starts[1] - 1].trim() === "";
+      const rebuilt = [];
+      ordered.forEach((chunk, index) => {
+        if (index > 0 && spaced)
+          rebuilt.push("");
+        rebuilt.push(...chunk.body);
+      });
+      let tail = range.end;
+      while (tail > starts[0] && all[tail - 1].trim() === "")
+        tail -= 1;
+      all.splice(starts[0], tail - starts[0], ...rebuilt);
+      next = all.join(`
+`);
+    }
+  }
+  const version = pageVersion(next);
+  const newest = newestChangelogVersion(parseChangelog(next));
+  if (version !== null && newest !== null && compareVersions(version, newest) < 0) {
+    next = setPageVersion(next, newest);
+  }
+  return next;
+}
 function sectionsOf(markdown) {
   const all = lines2(markdown);
   const mask = fencedLines2(all);
@@ -23095,6 +23138,8 @@ function withAddedLines(fresh, existingBody) {
       return false;
     if (/^[-*]\s+\[Module [^\]]+\]\([^)]+\.md\)$/.test(text))
       return false;
+    if (/^[-*]\s+`[^`]+`\s+\(no wiki page\)$/.test(text))
+      return false;
     if (/^graph-derived\b/i.test(text))
       return false;
     return !freshText.includes(text);
@@ -23155,10 +23200,11 @@ ${replacement.lines.join(`
 `);
     }
   }
+  const repaired = repairVersionAndOrder(next);
   if (next === source)
-    return existing;
-  const version = nextPageVersion(source);
-  return inEolOf(existing, prependChangelogEntry(setPageVersion(next, version), `- ${version} - ${entryNote}`));
+    return repaired === source ? existing : inEolOf(existing, repaired);
+  const version = nextPageVersion(repaired);
+  return inEolOf(existing, prependChangelogEntry(setPageVersion(repaired, version), `- ${version} - ${entryNote}`));
 }
 var CHANGELOG_HEADING, SECTION_HEADING, H2, ENTRY_START, ENTRY_VERSION, LEGACY_META_KEYS;
 var init_page_invariants = __esm(() => {
@@ -23182,6 +23228,55 @@ var init_page_invariants = __esm(() => {
   ]);
 });
 
+// src/wiki/readme-links.ts
+import path76 from "path";
+function rewriteReadmeLinks(text, readmeDir, pageLink) {
+  return text.replace(MARKDOWN_LINK, (whole, bang, label, target) => {
+    if (target === "" || HAS_SCHEME.test(target)) {
+      return whole;
+    }
+    const filePart = target.split(/[#?]/)[0] ?? "";
+    if (filePart === "") {
+      return label;
+    }
+    const resolved = path76.posix.normalize(filePart.startsWith("/") ? filePart.replace(/^\/+/, "") : path76.posix.join(readmeDir, filePart));
+    const codePath = resolved.replace(/\/+$/, "");
+    if (codePath === "" || codePath === "." || codePath === ".." || codePath.startsWith("../")) {
+      return label;
+    }
+    const named = label.length > 0 ? `${label} (\`${codePath}\`)` : `\`${codePath}\``;
+    if (bang === "!") {
+      return named;
+    }
+    const moduleName = moduleOfTarget(filePart, codePath);
+    const page = moduleName === null ? null : pageLink(moduleName);
+    return page === null ? named : `[${label.length > 0 ? label : moduleName}](${page})`;
+  });
+}
+function moduleOfTarget(filePart, codePath) {
+  const base = path76.posix.basename(codePath);
+  if (filePart.endsWith("/") || !/\.[A-Za-z0-9]+$/.test(base)) {
+    return codePath;
+  }
+  if (DOC_ENTRY.test(base)) {
+    const dir = path76.posix.dirname(codePath);
+    return dir === "." ? null : dir;
+  }
+  return null;
+}
+function truncateMarkdown(text, max) {
+  if (text.length <= max) {
+    return text;
+  }
+  return text.slice(0, max).replace(/\s*!?\[[^\]]*$|\s*!?\[[^\]]*\]\([^)]*$/, "").trimEnd();
+}
+var MARKDOWN_LINK, HAS_SCHEME, DOC_ENTRY;
+var init_readme_links = __esm(() => {
+  MARKDOWN_LINK = /(!?)\[([^[\]]*)\]\(\s*<?([^)\s>]*)>?(?:\s+(?:"[^"]*"|'[^']*'))?\s*\)/g;
+  HAS_SCHEME = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+  DOC_ENTRY = /^(?:readme|index)\.(?:md|mdx)$/i;
+});
+
 // src/wiki/think-tags.ts
 function maskCodeRegions(text) {
   const maskMatch = (m) => "\x00".repeat(m.length);
@@ -23570,15 +23665,15 @@ __export(exports_service4, {
 import { spawn as spawn3 } from "child_process";
 import { createHash as createHash15 } from "crypto";
 import { mkdir as mkdir20, readFile as readFile39, readdir as readdir13, writeFile as writeFile14 } from "fs/promises";
-import path76 from "path";
+import path77 from "path";
 function wikiRootPath3(cwd) {
-  return path76.join(cwd, ".metaproject", "wiki");
+  return path77.join(cwd, ".metaproject", "wiki");
 }
 function dataRootPath(cwd) {
-  return path76.join(cwd, ".metaproject", "data", "gdwiki");
+  return path77.join(cwd, ".metaproject", "data", "gdwiki");
 }
 function linkCheckReportPath(cwd) {
-  return path76.join(dataRootPath(cwd), "link-check", "latest.md");
+  return path77.join(dataRootPath(cwd), "link-check", "latest.md");
 }
 async function wikiStatus(cwd) {
   const root = wikiRootPath3(cwd);
@@ -23586,7 +23681,7 @@ async function wikiStatus(cwd) {
   const pages = enabled ? await collectPages(cwd) : [];
   return {
     enabled,
-    wikiRoot: path76.relative(cwd, root),
+    wikiRoot: path77.relative(cwd, root),
     totalPages: pages.length,
     countsByType: WIKI_PAGE_TYPES.map(({ type }) => ({
       type,
@@ -23617,9 +23712,9 @@ async function wikiCreatePage(input) {
   if (!/^[a-z0-9][a-z0-9-]*$/.test(input.slug)) {
     throw new Error(`Invalid slug: ${input.slug}. Use lowercase letters, digits, and hyphens.`);
   }
-  const dir = path76.join(wikiRootPath3(input.cwd), typeConfig.folder);
-  const filePath = path76.join(dir, `${input.slug}.md`);
-  const relativePath = path76.relative(input.cwd, filePath);
+  const dir = path77.join(wikiRootPath3(input.cwd), typeConfig.folder);
+  const filePath = path77.join(dir, `${input.slug}.md`);
+  const relativePath = path77.relative(input.cwd, filePath);
   if (await pathExists(filePath) && !input.force) {
     throw new Error(`Page already exists: ${relativePath}. Use --force to overwrite.`);
   }
@@ -23631,7 +23726,7 @@ async function wikiCreatePage(input) {
 }
 async function wikiGenerateIndex(cwd, history) {
   const root = wikiRootPath3(cwd);
-  const indexPath = path76.join(root, "index.md");
+  const indexPath = path77.join(root, "index.md");
   const pages = await collectPages(cwd);
   const generatedAt = new Date().toISOString();
   const managedBlock = `${WIKI_INDEX_BEGIN}
@@ -23648,7 +23743,7 @@ ${managedBlock}
 `;
   await writeWikiPage(history ?? await openWikiWriteContext(cwd, "wiki index"), indexPath, next);
   return {
-    path: path76.relative(cwd, indexPath),
+    path: path77.relative(cwd, indexPath),
     pageCount: pages.length,
     generatedAt
   };
@@ -23656,13 +23751,13 @@ ${managedBlock}
 async function wikiCheckLinks(cwd) {
   const root = wikiRootPath3(cwd);
   const allFiles = await pathExists(root) ? await walkMarkdown(root) : [];
-  const files = allFiles.filter((absolutePath) => !path76.relative(root, absolutePath).startsWith(`templates${path76.sep}`));
+  const files = allFiles.filter((absolutePath) => !path77.relative(root, absolutePath).startsWith(`templates${path77.sep}`));
   const broken = [];
   let checkedLinks = 0;
   let skippedExternal = 0;
   for (const absolutePath of files) {
     const content = await readFile39(absolutePath, "utf8");
-    const pageRelative = path76.relative(cwd, absolutePath);
+    const pageRelative = path77.relative(cwd, absolutePath);
     for (const target of extractLinkTargets(content)) {
       if (EXTERNAL_LINK.test(target)) {
         skippedExternal += 1;
@@ -23673,7 +23768,7 @@ async function wikiCheckLinks(cwd) {
         continue;
       }
       checkedLinks += 1;
-      const resolved = path76.resolve(path76.dirname(absolutePath), filePart);
+      const resolved = path77.resolve(path77.dirname(absolutePath), filePart);
       if (!await pathExists(resolved)) {
         broken.push({
           page: pageRelative,
@@ -23685,7 +23780,7 @@ async function wikiCheckLinks(cwd) {
   }
   const generatedAt = new Date().toISOString();
   const reportPath = linkCheckReportPath(cwd);
-  await mkdir20(path76.dirname(reportPath), { recursive: true });
+  await mkdir20(path77.dirname(reportPath), { recursive: true });
   await writeFile14(reportPath, renderLinkCheckReport({
     generatedAt,
     checkedPages: files.length,
@@ -23694,7 +23789,7 @@ async function wikiCheckLinks(cwd) {
     broken
   }), "utf8");
   return {
-    reportPath: path76.relative(cwd, reportPath),
+    reportPath: path77.relative(cwd, reportPath),
     checkedPages: files.length,
     checkedLinks,
     skippedExternal,
@@ -23745,7 +23840,7 @@ async function wikiValidate(cwd) {
   }
   if (await isIndexStale(cwd, pages)) {
     issues.push({
-      page: path76.join(path76.relative(cwd, wikiRootPath3(cwd)), "index.md"),
+      page: path77.join(path77.relative(cwd, wikiRootPath3(cwd)), "index.md"),
       kind: "index",
       message: "index out of date, run `keryx wiki index`"
     });
@@ -23791,7 +23886,7 @@ function collectCommandLabel(input) {
   return ["wiki collect", ...flags].join(" ");
 }
 async function wikiPruneOrphans(cwd, history) {
-  const componentsDir = path76.join(wikiRootPath3(cwd), "components");
+  const componentsDir = path77.join(wikiRootPath3(cwd), "components");
   if (!await pathExists(componentsDir)) {
     return { pruned: [], orphanedAccepted: [] };
   }
@@ -23811,15 +23906,15 @@ async function wikiPruneOrphans(cwd, history) {
     if (validSlugs.has(slug)) {
       continue;
     }
-    const filePath = path76.join(componentsDir, entry);
+    const filePath = path77.join(componentsDir, entry);
     const current = await readFile39(filePath, "utf8");
     const isUnmodifiedDraft = /\nStatus:\s*draft\s*\n/.test(current) && current.includes("Generated by `keryx wiki collect`");
     if (isUnmodifiedDraft) {
       run ??= history ?? await openWikiWriteContext(cwd, "wiki prune");
       await deleteWikiPage(run, filePath);
-      pruned.push(path76.relative(cwd, filePath));
+      pruned.push(path77.relative(cwd, filePath));
     } else {
-      orphanedAccepted.push(path76.relative(cwd, filePath));
+      orphanedAccepted.push(path77.relative(cwd, filePath));
     }
   }
   return { pruned, orphanedAccepted };
@@ -23829,7 +23924,7 @@ async function validModuleNames(cwd) {
   return counts === undefined ? undefined : new Set(counts.keys());
 }
 async function moduleFileCounts(cwd) {
-  const nodesPath = path76.join(cwd, ".metaproject", "data", "gdgraph", "storage", "nodes.jsonl");
+  const nodesPath = path77.join(cwd, ".metaproject", "data", "gdgraph", "storage", "nodes.jsonl");
   if (!await pathExists(nodesPath)) {
     return;
   }
@@ -23900,9 +23995,9 @@ async function wikiEvidence(input) {
   });
 }
 function resolveEvidenceScope(cwd, override) {
-  const absolute = path76.resolve(cwd);
+  const absolute = path77.resolve(cwd);
   return {
-    projectId: override?.projectId ?? (path76.basename(absolute) || "project"),
+    projectId: override?.projectId ?? (path77.basename(absolute) || "project"),
     checkoutId: override?.checkoutId ?? `checkout:${createHash15("sha256").update(absolute).digest("hex").slice(0, 16)}`,
     ...override?.workspaceId ? { workspaceId: override.workspaceId } : {},
     ...override?.taskId ? { taskId: override.taskId } : {}
@@ -23917,7 +24012,7 @@ function isMachineAuthoredPage(pageType, relativePath, content) {
   if (source === null) {
     return false;
   }
-  const normalised = relativePath.split(path76.sep).join("/").replace(/^wiki\//, "");
+  const normalised = relativePath.split(path77.sep).join("/").replace(/^wiki\//, "");
   return WIKI_PAGE_PRODUCERS.some((producer) => producer.source === source && producer.pageType === pageType && producer.path.test(normalised) && /^-[ \t]+Link:.*\bsha256\b/m.test(content));
 }
 function createGdWikiService() {
@@ -23933,8 +24028,8 @@ function createGdWikiService() {
   };
 }
 async function collectGraphWikiCandidates(cwd, generatedAt, limit, onlyModules) {
-  const nodesPath = path76.join(cwd, ".metaproject", "data", "gdgraph", "storage", "nodes.jsonl");
-  const edgesPath = path76.join(cwd, ".metaproject", "data", "gdgraph", "storage", "edges.jsonl");
+  const nodesPath = path77.join(cwd, ".metaproject", "data", "gdgraph", "storage", "nodes.jsonl");
+  const edgesPath = path77.join(cwd, ".metaproject", "data", "gdgraph", "storage", "edges.jsonl");
   if (!await pathExists(nodesPath) || !await pathExists(edgesPath)) {
     return [];
   }
@@ -24021,6 +24116,12 @@ async function collectGraphWikiCandidates(cwd, generatedAt, limit, onlyModules)
   };
   const moduleCandidates = [];
   const pageModules = new Set(topModules.map((entry) => entry.name));
+  const componentsDir = path77.join(wikiRootPath3(cwd), "components");
+  const existingSlugs = new Set((await pathExists(componentsDir) ? await readdir13(componentsDir) : []).filter((entry) => entry.endsWith(".md")).map((entry) => entry.slice(0, -3)));
+  const pageLink = (name) => {
+    const slug = slugifyPath(name);
+    return pageModules.has(name) || existingSlugs.has(slug) ? `${slug}.md` : null;
+  };
   for (const item of topModules) {
     const moduleName = item.name;
     const moduleFileList = moduleFiles.get(moduleName) ?? [];
@@ -24032,7 +24133,7 @@ async function collectGraphWikiCandidates(cwd, generatedAt, limit, onlyModules)
     const entryFiles = moduleFileList.filter((file) => /(^|\/)index\.[jt]sx?$/.test(file)).slice(0, 4);
     const deps = topCounts(moduleDeps.get(moduleName), 6);
     const dependents = topCounts(moduleDependents.get(moduleName), 6);
-    const readme = await readModuleReadme(cwd, moduleName);
+    const readme = await readModuleReadme(cwd, moduleName, pageLink);
     const exportsFrom = entryFiles.length > 0 ? entryFiles : keyFiles.slice(0, 2).map((entry) => entry.file);
     const exportApi = await extractModuleApi(cwd, exportsFrom);
     const reference = [];
@@ -24064,15 +24165,20 @@ async function collectGraphWikiCandidates(cwd, generatedAt, limit, onlyModules)
     if (exportApi.length > 0) {
       summaryParts.push("Exposes " + exportApi.length + " public symbol(s).");
     }
-    const relatedNames = [];
+    const linkedNames = [];
+    const unlinkedNames = [];
     const seenRelated = new Set([moduleName]);
     for (const [name] of [...deps, ...dependents]) {
-      if (!seenRelated.has(name) && pageModules.has(name)) {
-        seenRelated.add(name);
-        relatedNames.push(name);
+      if (seenRelated.has(name)) {
+        continue;
       }
+      seenRelated.add(name);
+      (pageLink(name) === null ? unlinkedNames : linkedNames).push(name);
     }
-    const related = relatedNames.slice(0, 8).map((name) => ({ name, slug: slugifyPath(name) }));
+    const related = [
+      ...linkedNames.slice(0, 8).map((name) => ({ name, page: pageLink(name) })),
+      ...unlinkedNames.slice(0, 8).map((name) => ({ name, page: null }))
+    ];
     moduleCandidates.push({
       type: "component",
       slug: slugifyPath(moduleName),
@@ -24117,8 +24223,8 @@ function topCounts(bucket, limit) {
   }
   return [...bucket.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit);
 }
-async function readModuleReadme(cwd, moduleName) {
-  const readmePath = path76.join(cwd, ...moduleName.split("/"), "README.md");
+async function readModuleReadme(cwd, moduleName, pageLink) {
+  const readmePath = path77.join(cwd, ...moduleName.split("/"), "README.md");
   if (!await pathExists(readmePath)) {
     return null;
   }
@@ -24128,7 +24234,7 @@ async function readModuleReadme(cwd, moduleName) {
     if (!paragraph) {
       return null;
     }
-    const normalized = paragraph.replace(/\s+/g, " ").slice(0, 400);
+    const normalized = truncateMarkdown(rewriteReadmeLinks(paragraph.replace(/\s+/g, " "), moduleName, pageLink), 400);
     return "- " + normalized + " (from module README)";
   } catch {
     return null;
@@ -24139,7 +24245,7 @@ async function extractModuleExports(cwd, files) {
   const declRe = /export\s+(?:async\s+)?(?:default\s+)?(?:const|let|var|function|class|type|interface|enum)\s+([A-Za-z_$][\w$]*)/g;
   const braceRe = /export\s*\{([^}]+)\}/g;
   for (const file of files.slice(0, 4)) {
-    const filePath = path76.join(cwd, ...file.split("/"));
+    const filePath = path77.join(cwd, ...file.split("/"));
     if (!await pathExists(filePath)) {
       continue;
     }
@@ -24170,7 +24276,7 @@ async function extractModuleExports(cwd, files) {
 }
 async function extractModuleApi(cwd, files) {
   const names = await extractModuleExports(cwd, files);
-  const symbolsPath = path76.join(cwd, ".metaproject", "data", "gdgraph", "storage", "symbols.jsonl");
+  const symbolsPath = path77.join(cwd, ".metaproject", "data", "gdgraph", "storage", "symbols.jsonl");
   if (names.length === 0 || !await pathExists(symbolsPath)) {
     return names.map((name) => "`" + name + "`");
   }
@@ -24196,7 +24302,7 @@ async function extractModuleApi(cwd, files) {
   });
 }
 async function collectHealthWikiCandidates(cwd, generatedAt) {
-  const healthPath = path76.join(cwd, ".metaproject", "data", "health", "artifacts", "latest.json");
+  const healthPath = path77.join(cwd, ".metaproject", "data", "health", "artifacts", "latest.json");
   if (!await pathExists(healthPath)) {
     return [];
   }
@@ -24238,7 +24344,7 @@ async function collectHealthWikiCandidates(cwd, generatedAt) {
   }];
 }
 async function collectTestingWikiCandidates(cwd, generatedAt) {
-  const contextPath = path76.join(cwd, ".metaproject", "data", "testing", "context.md");
+  const contextPath = path77.join(cwd, ".metaproject", "data", "testing", "context.md");
   if (!await pathExists(contextPath)) {
     return [];
   }
@@ -24269,8 +24375,8 @@ async function writeCollectedPage(cwd, candidate, force, history) {
   if (!folder) {
     throw new Error(`Unsupported collected wiki type: ${candidate.type}`);
   }
-  const filePath = path76.join(wikiRootPath3(cwd), folder, `${candidate.slug}.md`);
-  const relativePath = path76.relative(cwd, filePath);
+  const filePath = path77.join(wikiRootPath3(cwd), folder, `${candidate.slug}.md`);
+  const relativePath = path77.relative(cwd, filePath);
   const exists = await pathExists(filePath);
   if (exists && !force) {
     return { path: relativePath, type: candidate.type, source: candidate.source, action: "skipped" };
@@ -24321,7 +24427,7 @@ async function writeCollectedPage(cwd, candidate, force, history) {
 async function wikiPagesForFile(cwd, targetRepoPath) {
   const pages = await collectPages(cwd);
   const refs = await Promise.all(pages.map(async (page) => ({
-    repoPath: path76.relative(cwd, page.absolutePath).split(path76.sep).join("/"),
+    repoPath: path77.relative(cwd, page.absolutePath).split(path77.sep).join("/"),
     content: await readFile39(page.absolutePath, "utf8")
   })));
   return backlinksFor(buildBacklinkIndex(refs), targetRepoPath);
@@ -24360,7 +24466,7 @@ function renderIndexBody(pages, generatedAt) {
 `).trimEnd();
 }
 async function isIndexStale(cwd, pages) {
-  const indexPath = path76.join(wikiRootPath3(cwd), "index.md");
+  const indexPath = path77.join(wikiRootPath3(cwd), "index.md");
   if (!await pathExists(indexPath)) {
     return true;
   }
@@ -24378,7 +24484,7 @@ async function walkMarkdown(root) {
   const results = [];
   const entries = await readdir13(root, { withFileTypes: true });
   for (const entry of entries) {
-    const absolutePath = path76.join(root, entry.name);
+    const absolutePath = path77.join(root, entry.name);
     if (entry.isDirectory()) {
       results.push(...await walkMarkdown(absolutePath));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -24435,7 +24541,7 @@ ${JSON.stringify(state, null, 2)}
 `;
 }
 async function readIndexGeneratedAt(cwd) {
-  const indexPath = path76.join(wikiRootPath3(cwd), "index.md");
+  const indexPath = path77.join(wikiRootPath3(cwd), "index.md");
   if (!await pathExists(indexPath)) {
     return null;
   }
@@ -24518,10 +24624,11 @@ ${reference.join(`
 ## Related Wiki
 
 Graph-derived - regenerated by \`keryx wiki collect --force\`. Only pages that
-exist are linked; when enriching, add new links only to pages you have verified.
+exist are linked, other modules are named as code paths; when enriching, add
+new links only to pages you have verified.
 
 - [Wiki Index](../index.md)
-${related.map((entry) => "- [Module " + entry.name + "](" + entry.slug + ".md)").join(`
+${related.map((entry) => entry.page === null ? "- `" + entry.name + "` (no wiki page)" : "- [Module " + entry.name + "](" + entry.page + ")").join(`
 `)}
 
 ## Changelog
@@ -24672,7 +24779,7 @@ async function validateStructure(cwd, pages, issues) {
       if (pattern.includes("*")) {
         continue;
       }
-      if (!await pathExists(path76.join(cwd, pattern))) {
+      if (!await pathExists(path77.join(cwd, pattern))) {
         issues.push({
           page: page.relativePath,
           kind: "describes",
@@ -24742,7 +24849,7 @@ async function validatePageInvariants(cwd, pages, issues) {
   }
 }
 function toPosixPath(value) {
-  return value.split(path76.sep).join("/");
+  return value.split(path77.sep).join("/");
 }
 function compareSemver(a, b) {
   const pa = a.split(".").map(Number);
@@ -24764,6 +24871,7 @@ var init_service4 = __esm(() => {
   init_evidence();
   init_history();
   init_page_invariants();
+  init_readme_links();
   init_section_index();
   init_section_tombstone();
   init_staleness2();
@@ -24785,9 +24893,9 @@ var init_service4 = __esm(() => {
 // src/gdgraph/wiki-layer.ts
 import { createHash as createHash16 } from "crypto";
 import { mkdir as mkdir21, stat as stat12, writeFile as writeFile15 } from "fs/promises";
-import path77 from "path";
+import path78 from "path";
 function storageDir(projectRoot) {
-  return path77.join(projectRoot, ".metaproject", "data", "gdgraph", "storage");
+  return path78.join(projectRoot, ".metaproject", "data", "gdgraph", "storage");
 }
 function wikiPageId(relativePath) {
   return `wiki:${relativePath}`;
@@ -24853,11 +24961,11 @@ async function enrichBuildWithWikiLayer(input) {
   const mtimes = new Map;
   for (const record of input.fileRecords) {
     try {
-      const info = await stat12(path77.join(input.projectRoot, record.path));
+      const info = await stat12(path78.join(input.projectRoot, record.path));
       mtimes.set(record.path, info.mtimeMs);
     } catch {}
   }
-  await writeFile15(path77.join(dir, BUILD_MANIFEST_FILE), `${JSON.stringify({ version: 1, files: computeFingerprints(input.fileRecords, mtimes) }, null, 2)}
+  await writeFile15(path78.join(dir, BUILD_MANIFEST_FILE), `${JSON.stringify({ version: 1, files: computeFingerprints(input.fileRecords, mtimes) }, null, 2)}
 `, "utf8");
   const validModules = input.validModules !== undefined ? input.validModules : await (input.loadValidModules ?? defaultLoadValidModules)(input.projectRoot);
   const wikiPages = await collectPages(input.projectRoot);
@@ -24882,8 +24990,8 @@ async function enrichBuildWithWikiLayer(input) {
       version: page.version
     }))
   });
-  await writeJsonl(path77.join(dir, WIKI_PAGES_FILE), layer.pages);
-  await writeJsonl(path77.join(dir, DESCRIBES_FILE), layer.describes);
+  await writeJsonl(path78.join(dir, WIKI_PAGES_FILE), layer.pages);
+  await writeJsonl(path78.join(dir, DESCRIBES_FILE), layer.describes);
   return layer;
 }
 async function defaultLoadValidModules(projectRoot) {
@@ -24901,7 +25009,7 @@ var init_wiki_layer = __esm(() => {
 // src/gdskills/contracts.ts
 import { readFile as readFile51 } from "fs/promises";
 import { existsSync as existsSync15 } from "fs";
-import path105 from "path";
+import path106 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function loadSchema(name) {
   const contract = CONTRACTS.find((entry) => entry.name === name);
@@ -24912,10 +25020,10 @@ async function loadSchema(name) {
   return JSON.parse(raw);
 }
 function contractPath(contract) {
-  const here = path105.dirname(fileURLToPath2(import.meta.url));
+  const here = path106.dirname(fileURLToPath2(import.meta.url));
   if (contract.sourcePath) {
-    for (const root of [path105.join(here, "..", ".."), path105.join(here, ".."), here]) {
-      const candidate = path105.resolve(root, contract.sourcePath);
+    for (const root of [path106.join(here, "..", ".."), path106.join(here, ".."), here]) {
+      const candidate = path106.resolve(root, contract.sourcePath);
       if (existsSync15(candidate)) {
         return candidate;
       }
@@ -24925,7 +25033,7 @@ function contractPath(contract) {
   if (existsSync15(directPath)) {
     return directPath;
   }
-  const packagedSourcePath = path105.join(here, "..", "src", "gdskills", "contracts", contract.fileName);
+  const packagedSourcePath = path106.join(here, "..", "src", "gdskills", "contracts", contract.fileName);
   if (existsSync15(packagedSourcePath)) {
     return packagedSourcePath;
   }
@@ -29959,7 +30067,7 @@ __export(exports_service5, {
 // src/gdgraph/build.ts
 import { mkdir as mkdir22, readdir as readdir14, readFile as readFile40, writeFile as writeFile16 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
-import path78 from "path";
+import path79 from "path";
 
 // src/gdgraph/types.ts
 var UNKNOWN_IMPORT_KIND = "unknown-static";
@@ -30024,7 +30132,7 @@ async function buildGraph(projectRoot) {
   const assetNodes = new Map;
   const fileRecords = [];
   for (const file of files) {
-    const absolutePath = path78.join(projectRoot, file);
+    const absolutePath = path79.join(projectRoot, file);
     const content = await readFile40(absolutePath, "utf8");
     fileRecords.push({ path: file, content });
     const language = getLanguage(file);
@@ -30077,24 +30185,24 @@ async function collectSourceFiles(projectRoot) {
   const result = [];
   const skippedDirectories = [];
   async function walk(relativeDir) {
-    const absoluteDir = path78.join(projectRoot, relativeDir);
+    const absoluteDir = path79.join(projectRoot, relativeDir);
     const entries = await readdir14(absoluteDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) {
-          skippedDirectories.push(normalizePath2(path78.posix.join(relativeDir, entry.name)).replace(/^\.\//, ""));
+          skippedDirectories.push(normalizePath2(path79.posix.join(relativeDir, entry.name)).replace(/^\.\//, ""));
           continue;
         }
-        await walk(normalizePath2(path78.posix.join(relativeDir, entry.name)));
+        await walk(normalizePath2(path79.posix.join(relativeDir, entry.name)));
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
-      if (!SOURCE_EXTENSIONS.includes(path78.extname(entry.name))) {
+      if (!SOURCE_EXTENSIONS.includes(path79.extname(entry.name))) {
         continue;
       }
-      result.push(normalizePath2(path78.posix.join(relativeDir, entry.name)).replace(/^\.\//, ""));
+      result.push(normalizePath2(path79.posix.join(relativeDir, entry.name)).replace(/^\.\//, ""));
     }
   }
   await walk(".");
@@ -30176,8 +30284,8 @@ function resolveImport(projectRoot, fromFile, specifier, fileSet, resolver) {
 }
 function resolveAssetImport(projectRoot, fromFile, specifier, resolver) {
   for (const candidate of importCandidateBases(projectRoot, fromFile, specifier, resolver)) {
-    const extension = path78.posix.extname(candidate);
-    if (ASSET_EXTENSIONS.includes(extension) && existsSync7(path78.join(projectRoot, candidate))) {
+    const extension = path79.posix.extname(candidate);
+    if (ASSET_EXTENSIONS.includes(extension) && existsSync7(path79.join(projectRoot, candidate))) {
       return candidate;
     }
   }
@@ -30186,17 +30294,17 @@ function resolveAssetImport(projectRoot, fromFile, specifier, resolver) {
 function importCandidateBases(projectRoot, fromFile, specifier, resolver) {
   const normalizedSpecifier = stripImportSuffix(specifier);
   if (normalizedSpecifier.startsWith(".") && getLanguage(fromFile) !== "python") {
-    const fromDir = path78.posix.dirname(fromFile);
-    return [normalizePath2(path78.posix.normalize(path78.posix.join(fromDir, normalizedSpecifier)))];
+    const fromDir = path79.posix.dirname(fromFile);
+    return [normalizePath2(path79.posix.normalize(path79.posix.join(fromDir, normalizedSpecifier)))];
   }
-  return resolver.candidateBases(normalizedSpecifier, fromFile).map((candidate) => normalizePath2(path78.relative(projectRoot, path78.join(projectRoot, candidate))));
+  return resolver.candidateBases(normalizedSpecifier, fromFile).map((candidate) => normalizePath2(path79.relative(projectRoot, path79.join(projectRoot, candidate))));
 }
 function resolveSourceCandidate(base, fileSet) {
   const candidates = [
     base,
     ...SOURCE_RESOLUTION_EXTENSIONS.map((extension) => `${base}${extension}`),
-    ...SOURCE_RESOLUTION_EXTENSIONS.map((extension) => path78.posix.join(base, `index${extension}`)),
-    path78.posix.join(base, "__init__.py")
+    ...SOURCE_RESOLUTION_EXTENSIONS.map((extension) => path79.posix.join(base, `index${extension}`)),
+    path79.posix.join(base, "__init__.py")
   ];
   return candidates.find((candidate) => fileSet.has(candidate)) ?? null;
 }
@@ -30226,7 +30334,7 @@ async function loadJavaResolver(projectRoot) {
   return createJavaResolver(roots);
 }
 async function discoverJavaSourceRoots(projectRoot) {
-  const pomPath = path78.join(projectRoot, "pom.xml");
+  const pomPath = path79.join(projectRoot, "pom.xml");
   if (existsSync7(pomPath)) {
     try {
       const roots = parseMavenSourceRoots(await readFile40(pomPath, "utf8"));
@@ -30236,7 +30344,7 @@ async function discoverJavaSourceRoots(projectRoot) {
     } catch {}
   }
   for (const gradleName of ["build.gradle", "build.gradle.kts"]) {
-    const gradlePath = path78.join(projectRoot, gradleName);
+    const gradlePath = path79.join(projectRoot, gradleName);
     if (existsSync7(gradlePath)) {
       try {
         const roots = parseGradleSourceRoots(await readFile40(gradlePath, "utf8"));
@@ -30258,12 +30366,12 @@ function createJavaResolver(sourceRoots) {
         return [];
       }
       const relative = specifier.split(".").join("/");
-      return sourceRoots.map((root) => normalizePath2(path78.posix.join(root, relative)));
+      return sourceRoots.map((root) => normalizePath2(path79.posix.join(root, relative)));
     }
   };
 }
 function loadPythonResolver(projectRoot) {
-  const hasSrc = existsSync7(path78.join(projectRoot, "src"));
+  const hasSrc = existsSync7(path79.join(projectRoot, "src"));
   return createPythonResolver(hasSrc);
 }
 function createPythonResolver(hasSrc) {
@@ -30276,16 +30384,16 @@ function createPythonResolver(hasSrc) {
       if (specifier.startsWith(".")) {
         const dots = /^\.+/.exec(specifier)?.[0].length ?? 0;
         const rest = specifier.slice(dots);
-        let baseDir = path78.posix.dirname(fromFile);
+        let baseDir = path79.posix.dirname(fromFile);
         for (let level = 1;level < dots; level += 1) {
-          baseDir = path78.posix.dirname(baseDir);
+          baseDir = path79.posix.dirname(baseDir);
         }
         const suffix = rest ? rest.split(".").join("/") : "";
-        const base = suffix ? path78.posix.join(baseDir, suffix) : baseDir;
+        const base = suffix ? path79.posix.join(baseDir, suffix) : baseDir;
         return [normalizePath2(base)];
       }
       const relative = specifier.split(".").join("/");
-      return roots.map((root) => normalizePath2(root ? path78.posix.join(root, relative) : relative));
+      return roots.map((root) => normalizePath2(root ? path79.posix.join(root, relative) : relative));
     }
   };
 }
@@ -30294,8 +30402,8 @@ function parseMavenSourceRoots(pomXml) {
   for (const match of pomXml.matchAll(/<module>\s*([^<]+?)\s*<\/module>/g)) {
     const moduleDir = match[1]?.trim();
     if (moduleDir && !moduleDir.includes("${")) {
-      roots.add(normalizePath2(path78.posix.join(moduleDir, "src/main/java")));
-      roots.add(normalizePath2(path78.posix.join(moduleDir, "src/test/java")));
+      roots.add(normalizePath2(path79.posix.join(moduleDir, "src/main/java")));
+      roots.add(normalizePath2(path79.posix.join(moduleDir, "src/test/java")));
     }
   }
   for (const tag of ["sourceDirectory", "testSourceDirectory"]) {
@@ -30328,7 +30436,7 @@ function parseGradleSourceRoots(buildGradle) {
 var TSCONFIG_EXTENDS_MAX_DEPTH = 10;
 async function loadTsconfigResolver(projectRoot) {
   const empty = createTsconfigResolver(null, []);
-  const tsconfigPath = path78.join(projectRoot, "tsconfig.json");
+  const tsconfigPath = path79.join(projectRoot, "tsconfig.json");
   if (!existsSync7(tsconfigPath)) {
     return empty;
   }
@@ -30341,7 +30449,7 @@ async function loadTsconfigResolver(projectRoot) {
   return createTsconfigResolver(resolved.baseUrl, paths);
 }
 function toProjectRelativeDir(projectRoot, absoluteDir) {
-  const relative = normalizePath2(path78.relative(projectRoot, absoluteDir)).replace(/^\.\//, "");
+  const relative = normalizePath2(path79.relative(projectRoot, absoluteDir)).replace(/^\.\//, "");
   return relative === "." ? "" : relative;
 }
 async function readTsconfigJson(configPath) {
@@ -30356,11 +30464,11 @@ function resolveTsconfigExtendsPath(configDir, extendsSpecifier) {
   if (!extendsSpecifier.startsWith(".") && !extendsSpecifier.startsWith("/")) {
     return null;
   }
-  const resolved = path78.resolve(configDir, extendsSpecifier);
+  const resolved = path79.resolve(configDir, extendsSpecifier);
   return resolved.endsWith(".json") ? resolved : `${resolved}.json`;
 }
 async function resolveTsconfigOptions(configPath, visited, depth, projectRoot) {
-  const resolvedPath = path78.resolve(configPath);
+  const resolvedPath = path79.resolve(configPath);
   if (depth > TSCONFIG_EXTENDS_MAX_DEPTH || visited.has(resolvedPath)) {
     return null;
   }
@@ -30371,15 +30479,15 @@ async function resolveTsconfigOptions(configPath, visited, depth, projectRoot) {
   }
   let inherited = null;
   if (typeof parsed.extends === "string") {
-    const basePath = resolveTsconfigExtendsPath(path78.dirname(resolvedPath), parsed.extends);
+    const basePath = resolveTsconfigExtendsPath(path79.dirname(resolvedPath), parsed.extends);
     if (basePath) {
       inherited = await resolveTsconfigOptions(basePath, visited, depth + 1, projectRoot);
     }
   }
-  const configDir = path78.dirname(resolvedPath);
+  const configDir = path79.dirname(resolvedPath);
   const declaringDir = toProjectRelativeDir(projectRoot, configDir);
   const options = parsed.compilerOptions ?? {};
-  const ownBaseUrl = typeof options.baseUrl === "string" ? toProjectRelativeDir(projectRoot, path78.resolve(configDir, options.baseUrl)) : null;
+  const ownBaseUrl = typeof options.baseUrl === "string" ? toProjectRelativeDir(projectRoot, path79.resolve(configDir, options.baseUrl)) : null;
   const baseUrl = ownBaseUrl ?? inherited?.baseUrl ?? null;
   const ownPaths = isRecord4(options.paths) ? Object.entries(options.paths).filter((entry) => Array.isArray(entry[1])).map(([pattern, targets]) => ({
     pattern,
@@ -30408,7 +30516,7 @@ function createTsconfigResolver(baseUrl, mappings) {
         }
       }
       if (baseUrl !== null) {
-        candidates.push(normalizePath2(path78.posix.join(baseUrl, normalizedSpecifier)));
+        candidates.push(normalizePath2(path79.posix.join(baseUrl, normalizedSpecifier)));
       }
       return [...new Set(candidates.map((candidate) => candidate.replace(/^\.\//, "")))];
     }
@@ -30428,7 +30536,7 @@ function matchPathPattern(pattern, specifier) {
 }
 function applyPathTarget(base, target, wildcard) {
   const replaced = target.includes("*") ? target.replace("*", wildcard) : target;
-  return normalizePath2(path78.posix.normalize(path78.posix.join(base, replaced)));
+  return normalizePath2(path79.posix.normalize(path79.posix.join(base, replaced)));
 }
 function stripJsonComments(source) {
   let out = "";
@@ -30481,21 +30589,21 @@ function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function writeGraph(projectRoot, graph) {
-  const storageDir = path78.join(projectRoot, ".metaproject", "data", "gdgraph", "storage");
-  const artifactsDir = path78.join(projectRoot, ".metaproject", "data", "gdgraph", "artifacts");
+  const storageDir = path79.join(projectRoot, ".metaproject", "data", "gdgraph", "storage");
+  const artifactsDir = path79.join(projectRoot, ".metaproject", "data", "gdgraph", "artifacts");
   await mkdir22(storageDir, { recursive: true });
   await mkdir22(artifactsDir, { recursive: true });
-  await writeFile16(path78.join(storageDir, "nodes.jsonl"), graph.nodes.map((node) => JSON.stringify(node)).join(`
+  await writeFile16(path79.join(storageDir, "nodes.jsonl"), graph.nodes.map((node) => JSON.stringify(node)).join(`
 `) + `
 `, "utf8");
-  await writeFile16(path78.join(storageDir, "edges.jsonl"), graph.edges.map((edge) => JSON.stringify(edge)).join(`
+  await writeFile16(path79.join(storageDir, "edges.jsonl"), graph.edges.map((edge) => JSON.stringify(edge)).join(`
 `) + `
 `, "utf8");
-  await writeFile16(path78.join(artifactsDir, "module-map.json"), JSON.stringify(buildModuleMap(graph), null, 2) + `
+  await writeFile16(path79.join(artifactsDir, "module-map.json"), JSON.stringify(buildModuleMap(graph), null, 2) + `
 `, "utf8");
 }
 async function writeSummary(projectRoot, graph, collection) {
-  const artifactsDir = path78.join(projectRoot, ".metaproject", "data", "gdgraph", "artifacts");
+  const artifactsDir = path79.join(projectRoot, ".metaproject", "data", "gdgraph", "artifacts");
   await mkdir22(artifactsDir, { recursive: true });
   const unresolved = graph.edges.filter((edge) => edge.kind === "unresolved");
   const imports = graph.edges.filter((edge) => edge.kind === "imports");
@@ -30510,7 +30618,7 @@ async function writeSummary(projectRoot, graph, collection) {
 `);
   const skippedList = collection.skippedDirectories.length > 0 ? collection.skippedDirectories.slice(0, 30).map((dir) => `- \`${dir}\``).join(`
 `) : "- none";
-  const summaryPath = path78.join(artifactsDir, "summary.md");
+  const summaryPath = path79.join(artifactsDir, "summary.md");
   const content = `# gdgraph Summary
 
 ## Stats
@@ -30591,7 +30699,7 @@ function groupBy(items, getKey) {
 }
 function unresolvedType(specifier) {
   const stripped = stripImportSuffix(specifier);
-  const extension = path78.posix.extname(stripped);
+  const extension = path79.posix.extname(stripped);
   if (extension) {
     return extension;
   }
@@ -30601,13 +30709,13 @@ function unresolvedType(specifier) {
   return "package";
 }
 function normalizePath2(value) {
-  return value.split(path78.sep).join("/");
+  return value.split(path79.sep).join("/");
 }
 
 // src/gdgraph/target.ts
-import path79 from "path";
+import path80 from "path";
 function normalizeTarget(target) {
-  return target.replace(/^\.\//, "").split(path79.sep).join("/");
+  return target.replace(/^\.\//, "").split(path80.sep).join("/");
 }
 function resolveGraphTarget(graph, target) {
   const normalized = normalizeTarget(target);
@@ -30700,15 +30808,15 @@ init_config3();
 
 // src/gdgraph/query.ts
 import { readFile as readFile41 } from "fs/promises";
-import path80 from "path";
+import path81 from "path";
 async function loadGraph(projectRoot) {
-  const storageDir = path80.join(projectRoot, ".metaproject", "data", "gdgraph", "storage");
-  const nodes = await readJsonl(path80.join(storageDir, "nodes.jsonl"));
-  const edges = await readJsonl(path80.join(storageDir, "edges.jsonl"));
-  const symbols = await readJsonl(path80.join(storageDir, "symbols.jsonl"));
-  const calls = await readJsonl(path80.join(storageDir, "calls.jsonl"));
-  const wikiPages = await readJsonl(path80.join(storageDir, "wiki-pages.jsonl"));
-  const describes = await readJsonl(path80.join(storageDir, "describes.jsonl"));
+  const storageDir = path81.join(projectRoot, ".metaproject", "data", "gdgraph", "storage");
+  const nodes = await readJsonl(path81.join(storageDir, "nodes.jsonl"));
+  const edges = await readJsonl(path81.join(storageDir, "edges.jsonl"));
+  const symbols = await readJsonl(path81.join(storageDir, "symbols.jsonl"));
+  const calls = await readJsonl(path81.join(storageDir, "calls.jsonl"));
+  const wikiPages = await readJsonl(path81.join(storageDir, "wiki-pages.jsonl"));
+  const describes = await readJsonl(path81.join(storageDir, "describes.jsonl"));
   const graph = { nodes, edges };
   if (symbols.length > 0) {
     graph.symbols = symbols;
@@ -30768,7 +30876,7 @@ async function bunfigPreloadRoots(projectRoot) {
   const roots = new Set;
   let text;
   try {
-    text = await readFile41(path80.join(projectRoot, "bunfig.toml"), "utf8");
+    text = await readFile41(path81.join(projectRoot, "bunfig.toml"), "utf8");
   } catch {
     return roots;
   }
@@ -30782,8 +30890,8 @@ async function bunfigPreloadRoots(projectRoot) {
       if (raw.length === 0) {
         continue;
       }
-      const absolute = path80.resolve(projectRoot, raw);
-      const relative = path80.relative(projectRoot, absolute).split(path80.sep).join("/");
+      const absolute = path81.resolve(projectRoot, raw);
+      const relative = path81.relative(projectRoot, absolute).split(path81.sep).join("/");
       roots.add(relative);
     }
   }
@@ -30856,7 +30964,7 @@ function canonicalCycle(cycle) {
 
 // src/gdgraph/repomap.ts
 import { mkdir as mkdir23, writeFile as writeFile17 } from "fs/promises";
-import path81 from "path";
+import path82 from "path";
 
 // src/gdgraph/pagerank.ts
 function personalizedPageRank(nodes, edges, options) {
@@ -30967,7 +31075,7 @@ function overflowContent(required, missing, budget) {
 `);
 }
 function repomapArtifactPath(cwd) {
-  return path81.join(cwd, ".metaproject", "data", "gdgraph", "artifacts", "repomap.md");
+  return path82.join(cwd, ".metaproject", "data", "gdgraph", "artifacts", "repomap.md");
 }
 function buildRankEdges(graph, config) {
   const edges = [];
@@ -31112,7 +31220,7 @@ function computeRepomap(graph, config, options = {}) {
 async function writeRepomap(cwd, graph, config, options = {}) {
   const result = computeRepomap(graph, config, options);
   const artifactPath = repomapArtifactPath(cwd);
-  await mkdir23(path81.dirname(artifactPath), { recursive: true });
+  await mkdir23(path82.dirname(artifactPath), { recursive: true });
   await writeFile17(artifactPath, result.content, "utf8");
   return { ...result, path: artifactPath };
 }
@@ -31195,12 +31303,12 @@ init_section_tombstone();
 // src/forgetting/journal.ts
 init_fs();
 import { appendFile as appendFile5, mkdir as mkdir24, readFile as readFile42, stat as stat13 } from "fs/promises";
-import path82 from "path";
+import path83 from "path";
 function forgettingDataDir(cwd) {
-  return path82.join(cwd, ".metaproject", "data", "forgetting");
+  return path83.join(cwd, ".metaproject", "data", "forgetting");
 }
 function deletionJournalPath(cwd) {
-  return path82.join(forgettingDataDir(cwd), "journal.jsonl");
+  return path83.join(forgettingDataDir(cwd), "journal.jsonl");
 }
 async function readDeletionJournal(cwd) {
   const file = deletionJournalPath(cwd);
@@ -31619,12 +31727,12 @@ __export(exports_service7, {
   gateExitCode: () => gateExitCode,
   readWikiFreshnessMetric: () => readWikiFreshnessMetric
 });
-import path102 from "path";
+import path103 from "path";
 
 // src/health/config.ts
 init_fs();
 init_json();
-import path83 from "path";
+import path84 from "path";
 var DEFAULT_HEALTH_CONFIG = {
   schemaVersion: 2,
   ignore: {
@@ -31680,7 +31788,7 @@ var DEFAULT_HEALTH_CONFIG = {
   }
 };
 function configPath2(cwd) {
-  return path83.join(cwd, ".metaproject", "health.config.json");
+  return path84.join(cwd, ".metaproject", "health.config.json");
 }
 var STRICTEST_GATE = {
   failOnPriorities: ["P0", "P1", "P2", "P3"],
@@ -31731,7 +31839,7 @@ async function loadHealthConfig(cwd) {
 // src/health/run.ts
 init_fs();
 import { mkdir as mkdir28, writeFile as writeFile21 } from "fs/promises";
-import path101 from "path";
+import path102 from "path";
 
 // src/metrics/provenance.ts
 async function collectGitProvenance(cwd) {
@@ -31831,12 +31939,12 @@ function computeGate2(input) {
 }
 
 // src/health/scopes.ts
-import path86 from "path";
+import path87 from "path";
 
 // src/health/util.ts
 init_fs();
 import { mkdir as mkdir25, readFile as readFile43, readdir as readdir15, writeFile as writeFile18 } from "fs/promises";
-import path84 from "path";
+import path85 from "path";
 var IGNORED_DIRS = new Set([
   "node_modules",
   ".git",
@@ -31880,14 +31988,14 @@ async function toolVersion(command, cwd) {
   }
 }
 function dataRoot3(cwd) {
-  return path84.join(cwd, ".metaproject", "data", "health");
+  return path85.join(cwd, ".metaproject", "data", "health");
 }
 async function writeRaw(cwd, source, content, stamp) {
-  const dir = path84.join(dataRoot3(cwd), "raw", source);
+  const dir = path85.join(dataRoot3(cwd), "raw", source);
   await mkdir25(dir, { recursive: true });
-  const file = path84.join(dir, `${stamp}.log`);
+  const file = path85.join(dir, `${stamp}.log`);
   await writeFile18(file, content, "utf8");
-  return path84.relative(cwd, file);
+  return path85.relative(cwd, file);
 }
 async function listSourceFiles(cwd, ignorePaths = []) {
   const { files } = await listSourceFilesWithReasons(cwd, ignorePaths);
@@ -31907,7 +32015,7 @@ async function walk2(root, dir, out, incompleteReasons) {
   try {
     entries = await readdir15(dir, { withFileTypes: true });
   } catch (error) {
-    incompleteReasons.push(`${path84.relative(root, dir) || "."}: ${error instanceof Error ? error.message : String(error)}`);
+    incompleteReasons.push(`${path85.relative(root, dir) || "."}: ${error instanceof Error ? error.message : String(error)}`);
     return;
   }
   for (const entry of entries) {
@@ -31915,14 +32023,14 @@ async function walk2(root, dir, out, incompleteReasons) {
       if (entry.isDirectory() && !IGNORED_DIRS.has(entry.name)) {}
       continue;
     }
-    const abs = path84.join(dir, entry.name);
+    const abs = path85.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) {
         continue;
       }
       await walk2(root, abs, out, incompleteReasons);
-    } else if (entry.isFile() && SOURCE_EXT.has(path84.extname(entry.name))) {
-      out.push(path84.relative(root, abs));
+    } else if (entry.isFile() && SOURCE_EXT.has(path85.extname(entry.name))) {
+      out.push(path85.relative(root, abs));
     }
   }
 }
@@ -31937,7 +32045,7 @@ function moduleOfFile(file) {
   return null;
 }
 function isSourceFile(file) {
-  return SOURCE_EXT.has(path84.extname(file));
+  return SOURCE_EXT.has(path85.extname(file));
 }
 function matchesAnyPattern(file, patterns) {
   const normalized = file.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -32037,7 +32145,7 @@ function rankHotspots(files, churn, sourceAnalysis) {
 // src/health/source-analysis.ts
 init_fs();
 import { readFile as readFile44 } from "fs/promises";
-import path85 from "path";
+import path86 from "path";
 
 // src/health/metrics/complexity.ts
 var CONTROL_KEYWORDS = new Set([
@@ -32271,7 +32379,7 @@ async function analyzeSourceFiles(cwd, sourceFiles) {
   return new Map(entries.filter((entry) => entry !== null));
 }
 async function analyzeSourceFile(cwd, file) {
-  const abs = path85.join(cwd, file);
+  const abs = path86.join(cwd, file);
   if (!await pathExists(abs)) {
     return null;
   }
@@ -32344,14 +32452,14 @@ async function computeMetrics(input) {
   }
   const components = new Map;
   for (const file of sourceFiles) {
-    const dir = path86.posix.dirname(file);
+    const dir = path87.posix.dirname(file);
     if (dir === "." || dir === moduleOfFile(file)) {
       continue;
     }
     components.set(dir, [...components.get(dir) ?? [], file]);
   }
   for (const [name, files] of [...components.entries()].sort()) {
-    const compFindings = findings.filter((f) => f.file && path86.posix.dirname(f.file) === name);
+    const compFindings = findings.filter((f) => f.file && path87.posix.dirname(f.file) === name);
     scopes.push(build("component", `component:${name}`, name, files, compFindings, averageCoverage(files, coverage)));
   }
   const findingFiles = findings.map((f) => f.file).filter((f) => Boolean(f));
@@ -32396,9 +32504,9 @@ function tally2(values) {
 // src/health/baseline.ts
 init_fs();
 import { mkdir as mkdir26, readFile as readFile45, writeFile as writeFile19 } from "fs/promises";
-import path87 from "path";
+import path88 from "path";
 function baselinePath(cwd) {
-  return path87.join(cwd, ".metaproject", "health", "baselines", "scores.json");
+  return path88.join(cwd, ".metaproject", "health", "baselines", "scores.json");
 }
 async function loadBaseline(cwd) {
   const file = baselinePath(cwd);
@@ -32430,7 +32538,7 @@ async function writeBaseline(cwd, metrics, generatedAt, selector) {
     scopes[key] = value;
   }
   const file = baselinePath(cwd);
-  await mkdir26(path87.dirname(file), { recursive: true });
+  await mkdir26(path88.dirname(file), { recursive: true });
   await writeFile19(file, `${JSON.stringify({ generatedAt, scopes }, null, 2)}
 `, "utf8");
   return updated;
@@ -32484,10 +32592,10 @@ async function getChurn(cwd, windowDays) {
 
 // src/health/metrics/wiki-freshness.ts
 import { readFile as readFile46, stat as stat14 } from "fs/promises";
-import path88 from "path";
+import path89 from "path";
 var DEFAULT_STALE_EVIDENCE_DAYS = 7;
 function freshnessReportPath(cwd) {
-  return path88.join(cwd, ".metaproject", "data", "wiki", "freshness", "latest.json");
+  return path89.join(cwd, ".metaproject", "data", "wiki", "freshness", "latest.json");
 }
 async function readWikiFreshnessMetric(cwd, options = {}) {
   const file = freshnessReportPath(cwd);
@@ -32508,7 +32616,7 @@ async function readWikiFreshnessMetric(cwd, options = {}) {
   } catch {
     return {
       status: "unreadable-report",
-      reason: `${path88.relative(cwd, file)} is not valid JSON; re-run \`keryx wiki freshness\`.`
+      reason: `${path89.relative(cwd, file)} is not valid JSON; re-run \`keryx wiki freshness\`.`
     };
   }
   const report = parsed;
@@ -32518,7 +32626,7 @@ async function readWikiFreshnessMetric(cwd, options = {}) {
   if (pagesTotal === null || pagesFresh === null) {
     return {
       status: "unreadable-report",
-      reason: `${path88.relative(cwd, file)} is missing its totals; re-run \`keryx wiki freshness\`.`
+      reason: `${path89.relative(cwd, file)} is missing its totals; re-run \`keryx wiki freshness\`.`
     };
   }
   const pagesUndecidable = numberOr3(totals.pagesUndecidable) ?? 0;
@@ -32572,12 +32680,12 @@ function renderWikiFreshnessLine(metric) {
 }
 
 // src/health/sources/helpers.ts
-import path89 from "path";
+import path90 from "path";
 import { existsSync as existsSync8 } from "fs";
 class NoImportError extends Error {
 }
 function resolveBin(cwd, name) {
-  const local = path89.join(cwd, "node_modules", ".bin", name);
+  const local = path90.join(cwd, "node_modules", ".bin", name);
   if (existsSync8(local)) {
     return local;
   }
@@ -32658,13 +32766,13 @@ async function getComplexityFindings(cwd, sourceFiles, config, sourceAnalysis) {
 
 // src/health/metrics/coverage.ts
 import { existsSync as existsSync9 } from "fs";
-import path90 from "path";
+import path91 from "path";
 var SUMMARY_PATHS = [
   "coverage/coverage-summary.json",
   "coverage/coverage-final.json"
 ];
 async function getCoverage(cwd) {
-  const summary = SUMMARY_PATHS.map((rel) => path90.join(cwd, rel)).find((abs) => existsSync9(abs));
+  const summary = SUMMARY_PATHS.map((rel) => path91.join(cwd, rel)).find((abs) => existsSync9(abs));
   if (!summary) {
     return { status: "missing", total: null, byFile: new Map };
   }
@@ -32685,7 +32793,7 @@ async function getCoverage(cwd) {
       total = pct;
       continue;
     }
-    const relative = path90.isAbsolute(key) ? path90.relative(cwd, key) : key;
+    const relative = path91.isAbsolute(key) ? path91.relative(cwd, key) : key;
     byFile.set(relative.replace(/\\/g, "/"), pct);
   }
   return { status: "available", total, byFile };
@@ -32818,10 +32926,10 @@ function renderWikiFreshness(metric) {
 // src/health/skills.ts
 init_fs();
 import { readFile as readFile47 } from "fs/promises";
-import path91 from "path";
+import path92 from "path";
 var EMPTY = { skills: [], skillForFile: () => null };
 async function loadSkillOwnership(cwd) {
-  const manifestPath = path91.join(cwd, ".metaproject", "metaproject.json");
+  const manifestPath = path92.join(cwd, ".metaproject", "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return EMPTY;
   }
@@ -32859,7 +32967,7 @@ function normalize(value) {
 
 // src/health/sources/eslint.ts
 import { existsSync as existsSync10 } from "fs";
-import path92 from "path";
+import path93 from "path";
 var CONFIG_FILES = [
   ".eslintrc",
   ".eslintrc.js",
@@ -32873,7 +32981,7 @@ var CONFIG_FILES = [
   "eslint.config.ts"
 ];
 function hasConfig(cwd) {
-  return CONFIG_FILES.some((file) => existsSync10(path92.join(cwd, file)));
+  return CONFIG_FILES.some((file) => existsSync10(path93.join(cwd, file)));
 }
 var eslintAdapter = {
   id: "eslint",
@@ -32898,7 +33006,7 @@ var eslintAdapter = {
     };
   },
   async import(ctx) {
-    const report = path92.join(ctx.cwd, "eslint-report.json");
+    const report = path93.join(ctx.cwd, "eslint-report.json");
     if (!existsSync10(report)) {
       throw new NoImportError("no eslint-report.json");
     }
@@ -32925,7 +33033,7 @@ var eslintAdapter = {
     }
     const findings = [];
     for (const file of data) {
-      const relative = path92.isAbsolute(file.filePath) ? path92.relative(ctx.cwd, file.filePath) : file.filePath;
+      const relative = path93.isAbsolute(file.filePath) ? path93.relative(ctx.cwd, file.filePath) : file.filePath;
       for (const message of file.messages ?? []) {
         const isError = message.severity === 2;
         findings.push(makeFinding({
@@ -32957,9 +33065,9 @@ var eslintAdapter = {
 
 // src/health/sources/typescript.ts
 import { existsSync as existsSync11 } from "fs";
-import path93 from "path";
+import path94 from "path";
 function hasTsconfig(cwd) {
-  return existsSync11(path93.join(cwd, "tsconfig.json"));
+  return existsSync11(path94.join(cwd, "tsconfig.json"));
 }
 var typescriptAdapter = {
   id: "typescript",
@@ -33035,7 +33143,7 @@ __export(exports_service6, {
 });
 import { existsSync as existsSync12 } from "fs";
 import { readFile as readFile50, readdir as readdir16 } from "fs/promises";
-import path98 from "path";
+import path99 from "path";
 
 // src/lib/git-env.ts
 var GIT_DISCOVERY_OVERRIDE_VARS = [
@@ -33060,7 +33168,7 @@ function withoutGitDiscoveryOverrides(env) {
 init_fs();
 init_guard();
 import { readFile as readFile48 } from "fs/promises";
-import path94 from "path";
+import path95 from "path";
 
 // src/metrics/record.ts
 var RELIABILITIES = new Set(["exact", "estimated", "unknown"]);
@@ -33075,7 +33183,7 @@ var RETRY_TYPES = new Set([
 
 // src/metrics/lifecycle.ts
 async function readArtifactPointer(root, expected) {
-  const pointerFile = path94.join(root, "latest.json");
+  const pointerFile = path95.join(root, "latest.json");
   if (!await pathExists(pointerFile))
     return { status: "missing", pointer: null };
   let pointer;
@@ -33084,7 +33192,7 @@ async function readArtifactPointer(root, expected) {
   } catch {
     return { status: "stale", pointer: null, reason: "latest pointer is invalid JSON" };
   }
-  const recordFile = pointer.record ? path94.join(root, pointer.record) : null;
+  const recordFile = pointer.record ? path95.join(root, pointer.record) : null;
   if (!recordFile || !isPathInside(root, recordFile) || !await pathExists(recordFile)) {
     return { status: "stale", pointer, reason: "pointer record is missing" };
   }
@@ -33100,9 +33208,9 @@ init_guard();
 // src/testing/capability.ts
 init_fs();
 init_json();
-import path95 from "path";
+import path96 from "path";
 async function isTestingCapabilityEnabled(cwd, capability) {
-  const manifestPath = path95.join(cwd, ".metaproject", "metaproject.json");
+  const manifestPath = path96.join(cwd, ".metaproject", "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return false;
   }
@@ -33128,10 +33236,10 @@ async function isTestingCapabilityEnabled(cwd, capability) {
 init_fs();
 init_guard();
 import { readFile as readFile49, mkdir as mkdir27, writeFile as writeFile20 } from "fs/promises";
-import path96 from "path";
+import path97 from "path";
 var COVERAGE_MAP_SCHEMA_VERSION = 1;
 function coverageMapPath(cwd, cfg) {
-  return path96.isAbsolute(cfg.coverageMap.artifact) ? cfg.coverageMap.artifact : path96.join(cwd, cfg.coverageMap.artifact);
+  return path97.isAbsolute(cfg.coverageMap.artifact) ? cfg.coverageMap.artifact : path97.join(cwd, cfg.coverageMap.artifact);
 }
 async function loadCoverageMap(cwd, cfg) {
   const file = coverageMapPath(cwd, cfg);
@@ -33205,20 +33313,20 @@ function normalizePath4(file) {
 }
 
 // src/testing/selection.ts
-import path97 from "path";
+import path98 from "path";
 var TEST_FILE_RE = /(^|\/)(__tests__\/.*|.*\.(test|spec)\.[cm]?[tj]sx?$|e2e\/.*\.[cm]?[tj]sx?$|tests\/.*\.[cm]?[tj]sx?$)/;
 function normalizePath5(file) {
   return file.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 function relatedByNamingAndDirectory(target, testFiles) {
   const normalized = normalizePath5(target);
-  const ext = path97.extname(normalized);
+  const ext = path98.extname(normalized);
   const withoutExt = ext ? normalized.slice(0, -ext.length) : normalized;
-  const base = path97.basename(withoutExt);
-  const dir = path97.dirname(normalized);
+  const base = path98.basename(withoutExt);
+  const dir = path98.dirname(normalized);
   return testFiles.filter((file) => {
-    const fileDir = path97.dirname(file);
-    const fileBase = path97.basename(file);
+    const fileDir = path98.dirname(file);
+    const fileBase = path98.basename(file);
     return file.startsWith(`${withoutExt}.`) || file.includes(`${withoutExt}.`) || fileDir === dir && fileBase.startsWith(`${base}.`) || fileDir.startsWith(dir) && fileBase.includes(base);
   }).sort();
 }
@@ -33348,7 +33456,7 @@ var DEFAULT_TESTING_CONFIG = {
   }
 };
 function testingDataRoot(cwd) {
-  return path98.join(cwd, ".metaproject", "data", "testing");
+  return path99.join(cwd, ".metaproject", "data", "testing");
 }
 async function computeTestingContext(cwd) {
   const { files, incompleteReasons } = await listProjectFiles(cwd);
@@ -33523,7 +33631,7 @@ async function runTesting(input) {
   return runResult;
 }
 async function loadTestingContext(cwd) {
-  const file = path98.join(testingDataRoot(cwd), "context.json");
+  const file = path99.join(testingDataRoot(cwd), "context.json");
   if (!await pathExists(file)) {
     return null;
   }
@@ -33534,18 +33642,18 @@ async function loadTestingContext(cwd) {
   }
 }
 async function loadTestingReport(cwd) {
-  const file = path98.join(testingDataRoot(cwd), "artifacts", "latest.json");
+  const file = path99.join(testingDataRoot(cwd), "artifacts", "latest.json");
   if (!await pathExists(file)) {
     return null;
   }
   try {
     const latest = JSON.parse(await readFile50(file, "utf8"));
     if (typeof latest.record === "string") {
-      const pointer = await readArtifactPointer(path98.join(testingDataRoot(cwd), "artifacts"), await collectGitProvenance(cwd));
+      const pointer = await readArtifactPointer(path99.join(testingDataRoot(cwd), "artifacts"), await collectGitProvenance(cwd));
       if (pointer.status !== "fresh")
         return null;
-      const recordFile = path98.join(testingDataRoot(cwd), "artifacts", latest.record);
-      if (!isPathInside(path98.join(testingDataRoot(cwd), "artifacts"), recordFile))
+      const recordFile = path99.join(testingDataRoot(cwd), "artifacts", latest.record);
+      if (!isPathInside(path99.join(testingDataRoot(cwd), "artifacts"), recordFile))
         return null;
       if (!await pathExists(recordFile))
         return null;
@@ -33592,28 +33700,28 @@ async function ensureContext(cwd) {
 }
 async function writeContext(cwd, context) {
   const root = testingDataRoot(cwd);
-  const rel = (p) => path98.relative(cwd, p);
+  const rel = (p) => path99.relative(cwd, p);
   await mkdirContained(cwd, rel(root));
-  await writeContained(cwd, rel(path98.join(root, "context.json")), `${JSON.stringify(context, null, 2)}
+  await writeContained(cwd, rel(path99.join(root, "context.json")), `${JSON.stringify(context, null, 2)}
 `);
-  await writeContained(cwd, rel(path98.join(root, "context.md")), renderContextMarkdown(context));
-  await writeContained(cwd, rel(path98.join(root, "recommendations.md")), renderRecommendationsMarkdown(context));
+  await writeContained(cwd, rel(path99.join(root, "context.md")), renderContextMarkdown(context));
+  await writeContained(cwd, rel(path99.join(root, "recommendations.md")), renderRecommendationsMarkdown(context));
 }
 async function writeReport(cwd, report) {
   const root = testingDataRoot(cwd);
-  const artifacts = path98.join(root, "artifacts");
-  const history = path98.join(root, "history");
-  const rel = (p) => path98.relative(cwd, p);
+  const artifacts = path99.join(root, "artifacts");
+  const history = path99.join(root, "history");
+  const rel = (p) => path99.relative(cwd, p);
   await mkdirContained(cwd, rel(artifacts));
   await mkdirContained(cwd, rel(history));
   const stamp = report.generatedAt.replace(/[:.]/g, "-");
-  const json = path98.join(artifacts, "latest.json");
-  const markdown = path98.join(artifacts, "latest.md");
+  const json = path99.join(artifacts, "latest.json");
+  const markdown = path99.join(artifacts, "latest.md");
   const serialized = `${JSON.stringify(report, null, 2)}
 `;
   if (report.runId) {
-    const runJson = path98.join(artifacts, "runs", `${report.runId}.json`);
-    const runMarkdown = path98.join(artifacts, "runs", `${report.runId}.md`);
+    const runJson = path99.join(artifacts, "runs", `${report.runId}.json`);
+    const runMarkdown = path99.join(artifacts, "runs", `${report.runId}.md`);
     if (await pathExists(runJson))
       throw new Error(`immutable testing run already exists: ${report.runId}`);
     await writeContained(cwd, rel(runJson), serialized);
@@ -33624,26 +33732,26 @@ async function writeReport(cwd, report) {
       branch: report.provenance?.branch ?? null,
       worktree: report.provenance?.worktree ?? null,
       generated_at: report.generatedAt,
-      record: path98.posix.join("runs", `${report.runId}.json`)
+      record: path99.posix.join("runs", `${report.runId}.json`)
     }, null, 2)}
 `);
   } else {
     await writeContained(cwd, rel(json), serialized);
   }
   await writeContained(cwd, rel(markdown), renderReportMarkdown3(report));
-  await writeContained(cwd, rel(path98.join(history, `${stamp}.json`)), serialized);
+  await writeContained(cwd, rel(path99.join(history, `${stamp}.json`)), serialized);
   return {
-    markdownPath: path98.relative(cwd, markdown),
-    jsonPath: path98.relative(cwd, json)
+    markdownPath: path99.relative(cwd, markdown),
+    jsonPath: path99.relative(cwd, json)
   };
 }
 async function writeRawLog(cwd, raw) {
-  const logs = path98.join(testingDataRoot(cwd), "logs");
-  const rel = (p) => path98.relative(cwd, p);
+  const logs = path99.join(testingDataRoot(cwd), "logs");
+  const rel = (p) => path99.relative(cwd, p);
   await mkdirContained(cwd, rel(logs));
-  const latest = path98.join(logs, "latest.raw.log");
+  const latest = path99.join(logs, "latest.raw.log");
   await writeContained(cwd, rel(latest), raw);
-  return path98.relative(cwd, latest);
+  return path99.relative(cwd, latest);
 }
 async function listProjectFiles(cwd) {
   const out = [];
@@ -33656,11 +33764,11 @@ async function walk3(root, dir, out, incompleteReasons) {
   try {
     entries = await readdir16(dir, { withFileTypes: true });
   } catch (error) {
-    incompleteReasons.push(`${normalizePath6(path98.relative(root, dir)) || "."}: ${error instanceof Error ? error.message : String(error)}`);
+    incompleteReasons.push(`${normalizePath6(path99.relative(root, dir)) || "."}: ${error instanceof Error ? error.message : String(error)}`);
     return;
   }
   for (const entry of entries) {
-    const abs = path98.join(dir, entry.name);
+    const abs = path99.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (IGNORED_DIRS2.has(entry.name) || entry.name.startsWith(".tmp-")) {
         continue;
@@ -33669,12 +33777,12 @@ async function walk3(root, dir, out, incompleteReasons) {
       continue;
     }
     if (entry.isFile()) {
-      out.push(normalizePath6(path98.relative(root, abs)));
+      out.push(normalizePath6(path99.relative(root, abs)));
     }
   }
 }
 async function readPackageJson(cwd) {
-  const file = path98.join(cwd, "package.json");
+  const file = path99.join(cwd, "package.json");
   if (!await pathExists(file)) {
     return null;
   }
@@ -33685,7 +33793,7 @@ async function readPackageJson(cwd) {
   }
 }
 async function loadTestingConfig(cwd) {
-  const file = path98.join(cwd, ".metaproject", "testing.config.json");
+  const file = path99.join(cwd, ".metaproject", "testing.config.json");
   if (!await pathExists(file)) {
     return DEFAULT_TESTING_CONFIG;
   }
@@ -33750,7 +33858,7 @@ function detectFrameworks(input) {
 async function extractConventions(cwd, files) {
   const conventions = new Set;
   for (const file of files.slice(0, 40)) {
-    const abs = path98.join(cwd, file);
+    const abs = path99.join(cwd, file);
     if (!await pathExists(abs)) {
       continue;
     }
@@ -33880,7 +33988,7 @@ async function findTestsByImportedTargets(cwd, targets, testFiles) {
   const targetKeys = new Set(targets.map((target) => modulePathKey(normalizePath6(target))));
   const selected = new Set;
   for (const testFile of testFiles) {
-    const absoluteTest = path98.join(cwd, testFile);
+    const absoluteTest = path99.join(cwd, testFile);
     if (!await pathExists(absoluteTest)) {
       continue;
     }
@@ -33914,10 +34022,10 @@ function resolveImportPath(cwd, testFile, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const importerDir = path98.dirname(testFile);
-  const absoluteResolved = path98.resolve(path98.join(cwd, importerDir), importPath);
-  const relative = path98.relative(cwd, absoluteResolved);
-  if (relative.startsWith(`..${path98.sep}`) || relative === "..") {
+  const importerDir = path99.dirname(testFile);
+  const absoluteResolved = path99.resolve(path99.join(cwd, importerDir), importPath);
+  const relative = path99.relative(cwd, absoluteResolved);
+  if (relative.startsWith(`..${path99.sep}`) || relative === "..") {
     return null;
   }
   const relativeNormalized = normalizePath6(relative);
@@ -33969,13 +34077,13 @@ function resolveTestCommand(cwd, context, input) {
 }
 var BUN_LOCKFILES = ["bun.lock", "bun.lockb"];
 function detectPackageManager(cwd) {
-  if (resolveBunBin() && BUN_LOCKFILES.some((name) => pathExistsSync(path98.join(cwd, name)))) {
+  if (resolveBunBin() && BUN_LOCKFILES.some((name) => pathExistsSync(path99.join(cwd, name)))) {
     return "bun";
   }
-  if (Bun.which("pnpm") && pathExistsSync(path98.join(cwd, "pnpm-lock.yaml"))) {
+  if (Bun.which("pnpm") && pathExistsSync(path99.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (Bun.which("yarn") && pathExistsSync(path98.join(cwd, "yarn.lock"))) {
+  if (Bun.which("yarn") && pathExistsSync(path99.join(cwd, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
@@ -34315,7 +34423,7 @@ async function compatibleReportForHealth(ctx) {
 
 // src/health/sources/dependency-audit.ts
 import { existsSync as existsSync13 } from "fs";
-import path99 from "path";
+import path100 from "path";
 function auditSeverityToPriority(severity) {
   if (severity === "critical" || severity === "high")
     return "P0";
@@ -34434,7 +34542,7 @@ var LOCKFILE_COMMANDS = [
 ];
 function auditCommand(cwd) {
   for (const entry of LOCKFILE_COMMANDS) {
-    if (!entry.lockfiles.some((name) => existsSync13(path99.join(cwd, name))))
+    if (!entry.lockfiles.some((name) => existsSync13(path100.join(cwd, name))))
       continue;
     const bin = resolveBin(cwd, entry.bin);
     if (bin)
@@ -34493,13 +34601,13 @@ var dependencyAuditAdapter = {
 
 // src/health/sources/sonarqube.ts
 import { existsSync as existsSync14 } from "fs";
-import path100 from "path";
+import path101 from "path";
 var REPORT_FILES = ["sonar-issues.json", ".metaproject/data/health/sonar-issues.json"];
 function reportPath(cwd) {
   const fromEnv = process.env.SONAR_ISSUES_FILE;
   const candidates = fromEnv ? [fromEnv, ...REPORT_FILES] : REPORT_FILES;
   for (const rel of candidates) {
-    const abs = path100.isAbsolute(rel) ? rel : path100.join(cwd, rel);
+    const abs = path101.isAbsolute(rel) ? rel : path101.join(cwd, rel);
     if (existsSync14(abs)) {
       return abs;
     }
@@ -34583,7 +34691,7 @@ var sonarqubeAdapter = {
 function relativizeComponent(component, cwd) {
   const colon = component.indexOf(":");
   const value = colon >= 0 ? component.slice(colon + 1) : component;
-  return path100.isAbsolute(value) ? path100.relative(cwd, value) : value;
+  return path101.isAbsolute(value) ? path101.relative(cwd, value) : value;
 }
 
 // src/health/sources/index.ts
@@ -34920,19 +35028,19 @@ function filteredInfo(source, cfg) {
   };
 }
 async function writeOutputs(cwd, report, config, stamp) {
-  const artifacts = path101.join(dataRoot3(cwd), "artifacts");
-  const history = path101.join(dataRoot3(cwd), "history");
+  const artifacts = path102.join(dataRoot3(cwd), "artifacts");
+  const history = path102.join(dataRoot3(cwd), "history");
   await mkdir28(artifacts, { recursive: true });
   await mkdir28(history, { recursive: true });
-  const markdown = path101.join(artifacts, "latest.md");
-  const json = path101.join(artifacts, "latest.json");
-  const historyJson = path101.join(history, `${stamp}.json`);
+  const markdown = path102.join(artifacts, "latest.md");
+  const json = path102.join(artifacts, "latest.json");
+  const historyJson = path102.join(history, `${stamp}.json`);
   const serialized = `${JSON.stringify(report, null, 2)}
 `;
   await writeFile21(markdown, renderReportMarkdown2(report, config), "utf8");
   if (report.runId) {
-    const runJson = path101.join(artifacts, "runs", `${report.runId}.json`);
-    const runMarkdown = path101.join(artifacts, "runs", `${report.runId}.md`);
+    const runJson = path102.join(artifacts, "runs", `${report.runId}.json`);
+    const runMarkdown = path102.join(artifacts, "runs", `${report.runId}.md`);
     if (await pathExists(runJson))
       throw new Error(`immutable health run already exists: ${report.runId}`);
     await writeFileAtomic(runJson, serialized);
@@ -34943,7 +35051,7 @@ async function writeOutputs(cwd, report, config, stamp) {
       branch: report.provenance?.branch ?? null,
       worktree: report.provenance?.worktree ?? null,
       generated_at: report.generatedAt,
-      record: path101.posix.join("runs", `${report.runId}.json`)
+      record: path102.posix.join("runs", `${report.runId}.json`)
     }, null, 2)}
 `);
   } else {
@@ -34951,8 +35059,8 @@ async function writeOutputs(cwd, report, config, stamp) {
   }
   await writeFile21(historyJson, serialized, "utf8");
   return {
-    markdownPath: path101.relative(cwd, markdown),
-    jsonPath: path101.relative(cwd, json)
+    markdownPath: path102.relative(cwd, markdown),
+    jsonPath: path102.relative(cwd, json)
   };
 }
 async function resolveChanged(cwd, selector) {
@@ -35005,7 +35113,7 @@ function hasGateShape(value) {
   return Array.isArray(report.metrics) && Array.isArray(report.sources) && Array.isArray(report.findings);
 }
 async function readLatest(cwd) {
-  const file = path102.join(dataRoot3(cwd), "artifacts", "latest.json");
+  const file = path103.join(dataRoot3(cwd), "artifacts", "latest.json");
   if (!await pathExists(file)) {
     return null;
   }
@@ -35016,11 +35124,11 @@ async function readLatest(cwd) {
     const latest = read.value;
     const record = latest.record;
     if (typeof record === "string") {
-      const pointer = await readArtifactPointer(path102.join(dataRoot3(cwd), "artifacts"), await collectGitProvenance(cwd));
+      const pointer = await readArtifactPointer(path103.join(dataRoot3(cwd), "artifacts"), await collectGitProvenance(cwd));
       if (pointer.status !== "fresh")
         return null;
-      const recordFile = path102.join(dataRoot3(cwd), "artifacts", record);
-      if (!isPathInside(path102.join(dataRoot3(cwd), "artifacts"), recordFile))
+      const recordFile = path103.join(dataRoot3(cwd), "artifacts", record);
+      if (!isPathInside(path103.join(dataRoot3(cwd), "artifacts"), recordFile))
         return null;
       if (!await pathExists(recordFile))
         return null;
@@ -35093,7 +35201,7 @@ function createCodeHealthService() {
   return {
     run: (input) => runHealth(input),
     async status(input) {
-      const enabled = await pathExists(path102.join(input.cwd, ".metaproject", "health.config.json"));
+      const enabled = await pathExists(path103.join(input.cwd, ".metaproject", "health.config.json"));
       const latest = await readLatest(input.cwd);
       const project = latest?.metrics.find((m) => m.key === "project") ?? null;
       const decliningScopes = latest ? latest.metrics.filter((m) => m.regression_score > 0).length : 0;
@@ -35251,10 +35359,10 @@ function renderEvidenceBlock(evidences, siblings) {
 init_fs();
 init_contained_write();
 init_json();
-import path103 from "path";
+import path104 from "path";
 import { createHash as createHash17 } from "crypto";
 function impactEvidenceDataRoot(root) {
-  return path103.join(root, ".metaproject", "data", "security", "impact-evidence");
+  return path104.join(root, ".metaproject", "data", "security", "impact-evidence");
 }
 function sanitizeSessionId(sessionId) {
   const cleaned = sessionId.replace(/[^A-Za-z0-9._-]/g, "_");
@@ -35266,7 +35374,7 @@ function sessionStateFilename(sessionId) {
   return `${sanitized}-${suffix}.json`;
 }
 function sessionStatePath(root, sessionId) {
-  return path103.join(impactEvidenceDataRoot(root), "sessions", sessionStateFilename(sessionId));
+  return path104.join(impactEvidenceDataRoot(root), "sessions", sessionStateFilename(sessionId));
 }
 async function loadSessionState(root, sessionId) {
   const file = sessionStatePath(root, sessionId);
@@ -35285,11 +35393,11 @@ async function loadSessionState(root, sessionId) {
 }
 async function saveSessionState(root, sessionId, state) {
   const file = sessionStatePath(root, sessionId);
-  await writeContained(root, path103.relative(root, file), `${JSON.stringify(state, null, 2)}
+  await writeContained(root, path104.relative(root, file), `${JSON.stringify(state, null, 2)}
 `);
 }
 function logPath(root) {
-  return path103.join(impactEvidenceDataRoot(root), "log.jsonl");
+  return path104.join(impactEvidenceDataRoot(root), "log.jsonl");
 }
 async function appendLogRecord(root, record) {
   const full = {
@@ -35300,7 +35408,7 @@ async function appendLogRecord(root, record) {
     ...record.detail !== undefined ? { detail: record.detail } : {}
   };
   const file = logPath(root);
-  await appendContained(root, path103.relative(root, file), `${JSON.stringify(full)}
+  await appendContained(root, path104.relative(root, file), `${JSON.stringify(full)}
 `);
   return full;
 }
@@ -35327,7 +35435,7 @@ init_command_risk();
 init_shell_syntax();
 init_fs();
 init_service2();
-import path104 from "path";
+import path105 from "path";
 import { createHash as createHash18 } from "crypto";
 import { realpathSync as realpathSync2 } from "fs";
 function impactEvidenceHookClass(strict) {
@@ -35343,29 +35451,29 @@ function realpathNearestExisting(p) {
   for (;; ) {
     try {
       const real = realpathSync2(current);
-      return tail.length > 0 ? path104.join(real, ...tail) : real;
+      return tail.length > 0 ? path105.join(real, ...tail) : real;
     } catch {
-      const parent = path104.dirname(current);
+      const parent = path105.dirname(current);
       if (parent === current) {
-        return tail.length > 0 ? path104.join(current, ...tail) : current;
+        return tail.length > 0 ? path105.join(current, ...tail) : current;
       }
-      tail.unshift(path104.basename(current));
+      tail.unshift(path105.basename(current));
       current = parent;
     }
   }
 }
 function normalizeRequestFiles(root, files) {
-  const rootReal = realpathNearestExisting(path104.resolve(root));
+  const rootReal = realpathNearestExisting(path105.resolve(root));
   const normalized = [];
   const rejected = [];
   for (const file of files) {
-    const lexicalAbsolute = path104.isAbsolute(file) ? path104.resolve(file) : path104.resolve(rootReal, toPosix(file).replace(/^\.\//, ""));
+    const lexicalAbsolute = path105.isAbsolute(file) ? path105.resolve(file) : path105.resolve(rootReal, toPosix(file).replace(/^\.\//, ""));
     const effective = realpathNearestExisting(lexicalAbsolute);
     if (!isPathInside(rootReal, effective)) {
       rejected.push(file);
       continue;
     }
-    normalized.push(toPosix(path104.relative(rootReal, effective)));
+    normalized.push(toPosix(path105.relative(rootReal, effective)));
   }
   return { files: [...new Set(normalized)], rejected };
 }
@@ -35651,7 +35759,7 @@ __export(exports_service8, {
   createJobService: () => createJobService
 });
 import { copyFile, mkdir as mkdir30 } from "fs/promises";
-import path107 from "path";
+import path108 from "path";
 
 // src/job/types.ts
 var JOB_INTENTS = ["implement", "analyze", "review", "custom"];
@@ -35792,15 +35900,15 @@ init_validator();
 init_contracts();
 init_fs();
 import { appendFile as appendFile6, mkdir as mkdir29, readFile as readFile52, readdir as readdir17 } from "fs/promises";
-import path106 from "path";
+import path107 from "path";
 function jobsRoot(cwd) {
-  return path106.join(cwd, ".metaproject", "jobs");
+  return path107.join(cwd, ".metaproject", "jobs");
 }
 function jobDir(cwd, name) {
-  return path106.join(jobsRoot(cwd), name);
+  return path107.join(jobsRoot(cwd), name);
 }
 function jobStatePath(cwd, name) {
-  return path106.join(jobDir(cwd, name), "state.json");
+  return path107.join(jobDir(cwd, name), "state.json");
 }
 var JOB_NAME_PATTERN = /^[a-z0-9-]+$/;
 function assertJobName(name) {
@@ -35837,12 +35945,12 @@ async function writeJob(cwd, name, state) {
 `));
   }
   const file = jobStatePath(cwd, name);
-  await mkdir29(path106.dirname(file), { recursive: true });
+  await mkdir29(path107.dirname(file), { recursive: true });
   await writeFileAtomic(file, `${JSON.stringify(state, null, 2)}
 `);
 }
 async function appendJournal2(cwd, name, at, line) {
-  await appendFile6(path106.join(jobDir(cwd, name), "journal.md"), `- ${at} - ${line}
+  await appendFile6(path107.join(jobDir(cwd, name), "journal.md"), `- ${at} - ${line}
 `, "utf8");
 }
 function renderJournal2(name, at) {
@@ -35863,7 +35971,7 @@ function assertDocumentType(raw) {
   return raw;
 }
 function documentFileName(type, sourcePath) {
-  const extension = path106.extname(sourcePath) || ".md";
+  const extension = path107.extname(sourcePath) || ".md";
   return `${type}${extension}`;
 }
 
@@ -35871,7 +35979,7 @@ function documentFileName(type, sourcePath) {
 function createJobService(deps) {
   const now = () => deps.now().toISOString();
   function lockPath(cwd, name) {
-    return path107.join(jobsRoot(cwd), `.job-lock-${name}`);
+    return path108.join(jobsRoot(cwd), `.job-lock-${name}`);
   }
   async function mutate(cwd, name, run) {
     assertJobName(name);
@@ -35920,20 +36028,20 @@ function createJobService(deps) {
         },
         plan: { steps: defaultPlan(intent) },
         documentation: {
-          job_path: path107.join(".metaproject", "jobs", name),
+          job_path: path108.join(".metaproject", "jobs", name),
           documents_created: []
         },
         metrics: { steps: [] },
-        jobs_root: path107.join(".metaproject", "jobs"),
+        jobs_root: path108.join(".metaproject", "jobs"),
         updated_at: createdAt
       };
       const first = firstOpenStep(state.plan.steps);
       if (first) {
         state.plan.current_step = first.id;
       }
-      await writeFileAtomic(path107.join(absolute, "journal.md"), renderJournal2(name, createdAt));
+      await writeFileAtomic(path108.join(absolute, "journal.md"), renderJournal2(name, createdAt));
       await writeJob(input.cwd, name, state);
-      return { state, dir: path107.relative(input.cwd, absolute) };
+      return { state, dir: path108.relative(input.cwd, absolute) };
     },
     async status({ cwd, name }) {
       assertJobName(name);
@@ -35945,7 +36053,7 @@ function createJobService(deps) {
       }
       return {
         state,
-        dir: path107.join(".metaproject", "jobs", name),
+        dir: path108.join(".metaproject", "jobs", name),
         stepsDone: state.plan.steps.filter((step) => isTerminalStep(step.status)).length,
         stepsTotal: state.plan.steps.length,
         nextStep: firstOpenStep(state.plan.steps),
@@ -36002,23 +36110,23 @@ function createJobService(deps) {
       if (!input.file) {
         throw new Error("Missing --file. Usage: keryx job document <name> --type <type> --file <path>");
       }
-      const source = path107.isAbsolute(input.file) ? input.file : path107.join(input.cwd, input.file);
+      const source = path108.isAbsolute(input.file) ? input.file : path108.join(input.cwd, input.file);
       if (!await pathExists(source)) {
         throw new Error(`--file not found: ${input.file}. Write the document first, then record it.`);
       }
       let recorded;
       await mutate(input.cwd, input.name, async (state) => {
         const fileName = documentFileName(type, source);
-        const target = path107.join(jobDir(input.cwd, state.job_name), fileName);
+        const target = path108.join(jobDir(input.cwd, state.job_name), fileName);
         await copyFile(source, target);
         state.documentation ??= {};
-        state.documentation.job_path ??= path107.join(".metaproject", "jobs", state.job_name);
+        state.documentation.job_path ??= path108.join(".metaproject", "jobs", state.job_name);
         const created = state.documentation.documents_created ?? [];
         state.documentation.documents_created = created.includes(fileName) ? created : [...created, fileName];
         recorded = {
           state,
           document: fileName,
-          path: path107.join(".metaproject", "jobs", state.job_name, fileName)
+          path: path108.join(".metaproject", "jobs", state.job_name, fileName)
         };
         return { state, event: "document", detail: `${type} -> ${fileName}` };
       });
@@ -36053,7 +36161,7 @@ function createJobService(deps) {
             name: state.job_name,
             phase: state.phase,
             intent: state.intent,
-            dir: path107.join(".metaproject", "jobs", name),
+            dir: path108.join(".metaproject", "jobs", name),
             stepsDone: state.plan.steps.filter((step) => isTerminalStep(step.status)).length,
             stepsTotal: state.plan.steps.length,
             nextStep: firstOpenStep(state.plan.steps)?.id ?? null
@@ -36158,12 +36266,12 @@ function normalizeWorkspaceReference(raw) {
 // src/sac/fwk-service.ts
 init_assembly();
 import { appendFile as appendFile7, mkdir as mkdir32, open as open4, readFile as readFile55, rename as rename7, rm as rm6, stat as stat15, writeFile as writeFile22 } from "fs/promises";
-import path111 from "path";
+import path112 from "path";
 
 // src/sac/index.ts
 import { access as access3, readFile as readFile53, realpath as realpath12 } from "fs/promises";
 import { createHash as createHash19 } from "crypto";
-import path108 from "path";
+import path109 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var idPattern = /^[a-z][a-z0-9-]{2,63}$/;
 var subjectPattern = /^(?:user|team|service|agent):[a-z0-9][a-z0-9._-]{0,127}$/;
@@ -36181,21 +36289,21 @@ var normativeSchemaFiles = {
   "review-decision": "review-decision.schema.json"
 };
 var normativeSchemas = new Map;
-var NORMATIVE_SCHEMA_DIR = path108.join("docs", "requirements", "shared-agent-context", "schemas");
+var NORMATIVE_SCHEMA_DIR = path109.join("docs", "requirements", "shared-agent-context", "schemas");
 async function resolveSacNormativeSchemaPath(fileName, searchFrom = [fileURLToPath3(new URL(".", import.meta.url)), process.cwd()]) {
   const seen = new Set;
   for (const start of searchFrom) {
-    let dir = path108.resolve(start);
+    let dir = path109.resolve(start);
     for (let i = 0;i < 10; i++) {
       if (seen.has(dir))
         break;
       seen.add(dir);
-      const candidate = path108.join(dir, NORMATIVE_SCHEMA_DIR, fileName);
+      const candidate = path109.join(dir, NORMATIVE_SCHEMA_DIR, fileName);
       try {
         await access3(candidate);
         return candidate;
       } catch {}
-      const parent = path108.dirname(dir);
+      const parent = path109.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -36864,12 +36972,12 @@ class SacReferenceError extends Error {
   code = "unsafe_workspace_reference";
 }
 async function resolveWorkspaceReference(input) {
-  if (!workspacePathPattern.test(input.uri) || path108.isAbsolute(input.uri) || /^[a-z][a-z0-9+.-]*:/i.test(input.uri) || input.uri.includes("\\"))
+  if (!workspacePathPattern.test(input.uri) || path109.isAbsolute(input.uri) || /^[a-z][a-z0-9+.-]*:/i.test(input.uri) || input.uri.includes("\\"))
     throw new SacReferenceError("unsafe workspace reference");
-  const lexicalRoot = path108.resolve(input.workspaceRoot);
+  const lexicalRoot = path109.resolve(input.workspaceRoot);
   const root = await realpath12(lexicalRoot);
-  const candidate = path108.resolve(lexicalRoot, input.uri.slice(2));
-  if (candidate !== lexicalRoot && !candidate.startsWith(`${lexicalRoot}${path108.sep}`))
+  const candidate = path109.resolve(lexicalRoot, input.uri.slice(2));
+  if (candidate !== lexicalRoot && !candidate.startsWith(`${lexicalRoot}${path109.sep}`))
     throw new SacReferenceError("workspace reference escapes root");
   let resolved;
   try {
@@ -36877,7 +36985,7 @@ async function resolveWorkspaceReference(input) {
   } catch {
     throw new SacReferenceError("workspace reference is not resolvable");
   }
-  if (resolved !== root && !resolved.startsWith(`${root}${path108.sep}`))
+  if (resolved !== root && !resolved.startsWith(`${root}${path109.sep}`))
     throw new SacReferenceError("workspace reference escapes root after realpath");
   return candidate;
 }
@@ -36933,16 +37041,16 @@ async function evaluateStrictSacGuard(input) {
 init_fs();
 import { mkdir as mkdir31, readdir as readdir18, readFile as readFile54 } from "fs/promises";
 import { createHash as createHash20, randomUUID as randomUUID3 } from "crypto";
-import path110 from "path";
+import path111 from "path";
 
 // src/sac/secure-resource-read.ts
 init_contained_read();
 init_descriptor_read();
-import path109 from "path";
+import path110 from "path";
 function readWorkspaceFileNoFollow(workspaceRoot, absolutePath) {
-  const relativePath = path109.relative(workspaceRoot, absolutePath);
-  const components = relativePath.split(path109.sep);
-  if (!relativePath || path109.isAbsolute(relativePath) || components.some((component) => !component || component === "." || component === "..")) {
+  const relativePath = path110.relative(workspaceRoot, absolutePath);
+  const components = relativePath.split(path110.sep);
+  if (!relativePath || path110.isAbsolute(relativePath) || components.some((component) => !component || component === "." || component === "..")) {
     throw new Error("safe source path is not workspace-relative");
   }
   return readDescriptorChain(workspaceRoot, absolutePath, {
@@ -36969,8 +37077,8 @@ class WorkspaceService {
   now;
   constructor(options) {
     this.options = options;
-    this.root = path110.resolve(options.workspaceRoot);
-    this.storageRoot = path110.resolve(options.storageRoot ?? path110.join(this.root, ".metaproject", "workspaces"));
+    this.root = path111.resolve(options.workspaceRoot);
+    this.storageRoot = path111.resolve(options.storageRoot ?? path111.join(this.root, ".metaproject", "workspaces"));
     this.now = options.now ?? (() => new Date);
   }
   async create(input) {
@@ -37295,13 +37403,13 @@ class WorkspaceService {
     return parsed;
   }
   workspaceDir(id) {
-    return path110.join(this.storageRoot, id);
+    return path111.join(this.storageRoot, id);
   }
   manifestPath(id) {
-    return path110.join(this.workspaceDir(id), "workspace.json");
+    return path111.join(this.workspaceDir(id), "workspace.json");
   }
   lockPath(id) {
-    return path110.join(this.storageRoot, `.${id}.lock`);
+    return path111.join(this.storageRoot, `.${id}.lock`);
   }
   timestamp() {
     return this.now().toISOString();
@@ -38090,7 +38198,7 @@ function hasReportIntegrity(report) {
   return reportHashPattern.test(reportDigest) && sha2565(body) === reportDigest;
 }
 async function resolvePolicySelection(workspaceRoot, canonicalFallback) {
-  const configPath = path111.join(workspaceRoot, ...policyExperimentConfigPath);
+  const configPath = path112.join(workspaceRoot, ...policyExperimentConfigPath);
   let configJson;
   try {
     const raw = await readFile55(configPath, "utf8").catch((error) => {
@@ -38288,9 +38396,9 @@ class FwkReadService {
     const recordedAt = nowIso(now);
     const id = `receipt-${randomUUID4().replace(/-/g, "").slice(0, 16)}`;
     const base = { schemaVersion: "1.0", id, workspaceId, actor, action, decision, recordedAt, cost: { tokens: 0, toolCalls: 1, elapsedMs: 0 }, contextAssembly: { traceRef: assembly.traceRef, configurationRevision: assembly.configurationRevision, selected: assembly.selected.map((id) => `./ids/${id}`), omittedOptional: assembly.omittedOptional.map((id) => `./ids/${id}`) }, policy: { ref: assembly.policyRef, revision: assembly.policyRevision }, ...action === "resource" ? { resourceRef: `./ids/${resourceId ?? "unknown"}` } : {} };
-    const ledger = path111.join(this.options.canonical.workspaceRoot, ".metaproject", "context-operations", "access-receipts.jsonl");
-    const checkpointPath = path111.join(path111.dirname(ledger), "access-receipts.checkpoint.json");
-    await mkdir32(path111.dirname(ledger), { recursive: true, mode: 448 });
+    const ledger = path112.join(this.options.canonical.workspaceRoot, ".metaproject", "context-operations", "access-receipts.jsonl");
+    const checkpointPath = path112.join(path112.dirname(ledger), "access-receipts.checkpoint.json");
+    await mkdir32(path112.dirname(ledger), { recursive: true, mode: 448 });
     return withFileLock(`${ledger}.lock`, async () => {
       const state = await resolveLedgerState(ledger, checkpointPath, this.options.verifyReceiptLedger ?? verifyAccessReceiptLedger);
       const receipt = sealAccessReceipt(base, state.headHash);
@@ -38394,7 +38502,7 @@ function normalizeFwkResult(result) {
 init_fs();
 import { createHash as createHash30, randomUUID as randomUUID7 } from "crypto";
 import { appendFile as appendFile8, mkdir as mkdir35, readdir as readdir21, readFile as readFile64 } from "fs/promises";
-import path121 from "path";
+import path122 from "path";
 
 // src/sac/trusted-wrap-up.ts
 import { createHash as createHash24, randomUUID as randomUUID5 } from "crypto";
@@ -38466,7 +38574,7 @@ function bindingHash(owner, intent) {
 // src/sac/session-wrap-up.ts
 import { createHash as createHash26 } from "crypto";
 import { mkdir as mkdir34, writeFile as writeFile23 } from "fs/promises";
-import path115 from "path";
+import path116 from "path";
 
 // src/session/store.ts
 init_config_dir();
@@ -38478,12 +38586,12 @@ import {
   renameSync as renameSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-import path114 from "path";
+import path115 from "path";
 
 // src/session/paths.ts
 import { existsSync as existsSync16 } from "fs";
 import { homedir } from "os";
-import path112 from "path";
+import path113 from "path";
 function keryxDataDir(override) {
   if (override !== undefined && override.length > 0) {
     return override;
@@ -38495,22 +38603,22 @@ function keryxDataDir(override) {
   const home = homedir();
   if (process.platform === "win32") {
     const appData = process.env.APPDATA;
-    const base = appData !== undefined && appData.length > 0 ? appData : path112.join(home, "AppData", "Roaming");
-    return path112.join(base, "keryx");
+    const base = appData !== undefined && appData.length > 0 ? appData : path113.join(home, "AppData", "Roaming");
+    return path113.join(base, "keryx");
   }
   const xdg = process.env.XDG_DATA_HOME;
-  const base = xdg !== undefined && xdg.length > 0 ? xdg : path112.join(home, ".local", "share");
-  return path112.join(base, "keryx");
+  const base = xdg !== undefined && xdg.length > 0 ? xdg : path113.join(home, ".local", "share");
+  return path113.join(base, "keryx");
 }
 function resolveProjectRoot2(cwd) {
-  const abs = path112.resolve(cwd);
+  const abs = path113.resolve(cwd);
   let dir = abs;
   for (;; ) {
-    const gitPath = path112.join(dir, ".git");
+    const gitPath = path113.join(dir, ".git");
     if (existsSync16(gitPath)) {
       return dir;
     }
-    const parent = path112.dirname(dir);
+    const parent = path113.dirname(dir);
     if (parent === dir) {
       break;
     }
@@ -38519,12 +38627,12 @@ function resolveProjectRoot2(cwd) {
   return abs;
 }
 function projectKeyFromPath(projectPath) {
-  const abs = path112.resolve(projectPath);
+  const abs = path113.resolve(projectPath);
   const encoded = encodeURIComponent(abs);
   if (encoded.length <= 200) {
     return encoded;
   }
-  const base = path112.basename(abs).replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40);
+  const base = path113.basename(abs).replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40);
   let h = 0;
   for (let i = 0;i < abs.length; i++) {
     h = Math.imul(31, h) + abs.charCodeAt(i) | 0;
@@ -38534,17 +38642,17 @@ function projectKeyFromPath(projectPath) {
 }
 function projectSessionsDir(projectPath, dataDir) {
   const key = projectKeyFromPath(resolveProjectRoot2(projectPath));
-  return path112.join(keryxDataDir(dataDir), "sessions", key);
+  return path113.join(keryxDataDir(dataDir), "sessions", key);
 }
 function sessionDir(projectPath, sessionId, dataDir) {
-  return path112.join(projectSessionsDir(projectPath, dataDir), sessionId);
+  return path113.join(projectSessionsDir(projectPath, dataDir), sessionId);
 }
 
 // src/session/slate.ts
 init_fs();
 init_assembly();
 import { mkdir as mkdir33, readFile as readFile56, readdir as readdir19, rm as rm7, stat as stat16 } from "fs/promises";
-import path113 from "path";
+import path114 from "path";
 init_redact();
 var SLATE_SEED_KINDS = [
   "decision",
@@ -38559,7 +38667,7 @@ function isSlateSeedKind(value) {
 }
 var SEED_TEXT_MAX_LENGTH = 4000;
 function slatePath(dir) {
-  return path113.join(dir, "slate.json");
+  return path114.join(dir, "slate.json");
 }
 function slateLockPath(dir) {
   return `${slatePath(dir)}.lock`;
@@ -38789,11 +38897,11 @@ function listSessions(cwd, dataDir) {
     if (name.startsWith(".")) {
       continue;
     }
-    const summary = readSummaryFile(path114.join(root, name, "summary.json"));
+    const summary = readSummaryFile(path115.join(root, name, "summary.json"));
     if (summary === undefined) {
       continue;
     }
-    if (path114.resolve(summary.projectPath) !== path114.resolve(projectPath)) {
+    if (path115.resolve(summary.projectPath) !== path115.resolve(projectPath)) {
       continue;
     }
     out.push(summary);
@@ -38826,15 +38934,15 @@ async function readSessionSlate(cwd, sessionId, dataDir) {
 }
 function loadContext(cwd, sessionId, dataDir) {
   const dir = sessionDir(resolveProjectRoot2(cwd), sessionId, dataDir);
-  const contextPath = path114.join(dir, "context.jsonl");
+  const contextPath = path115.join(dir, "context.jsonl");
   if (existsSync17(contextPath)) {
     return readJsonl2(contextPath);
   }
-  return readJsonl2(path114.join(dir, "transcript.jsonl"));
+  return readJsonl2(path115.join(dir, "transcript.jsonl"));
 }
 function loadArchive(cwd, sessionId, dataDir, onDegraded) {
   const dir = sessionDir(resolveProjectRoot2(cwd), sessionId, dataDir);
-  const archivePath = path114.join(dir, "archive.jsonl");
+  const archivePath = path115.join(dir, "archive.jsonl");
   if (existsSync17(archivePath)) {
     try {
       const archive = readJsonl2(archivePath);
@@ -39018,7 +39126,7 @@ function sessionEvidenceRef(workspaceId, sessionId) {
 }
 async function resolveSessionWrapUp(input) {
   const now = input.now ?? (() => new Date);
-  const sessionId = path115.posix.basename(input.sourceRef, ".md");
+  const sessionId = path116.posix.basename(input.sourceRef, ".md");
   const summary = findSession(input.cwd, sessionId);
   if (summary === undefined || input.sourceRef !== sessionEvidenceRef(input.workspaceId, summary.id)) {
     throw new SessionWrapUpError("session_not_found", `no session matching "${input.sourceRef}" in this project \u2014 use \`keryx sessions list\``);
@@ -39035,7 +39143,7 @@ async function resolveSessionWrapUp(input) {
     throw new SessionWrapUpError("session_unreadable", `session "${summary.id}" could not be read: ${cause.message}`);
   }
   const relPath = sessionEvidenceRef(input.workspaceId, summary.id).slice(2);
-  const evidenceDir = path115.dirname(relPath);
+  const evidenceDir = path116.dirname(relPath);
   const slate = await readSessionSlate(input.cwd, summary.id);
   const diff = await gitDiff(input.cwd);
   const diffBody = diff.kind === "measured" ? diff.text : unmeasurableDiffBody(diff.detail);
@@ -39057,23 +39165,23 @@ async function resolveSessionWrapUp(input) {
     ""
   ].join(`
 `);
-  const wrapUpRelPath = path115.join(evidenceDir, `${summary.id}.wrap-up.md`);
-  const diffRelPath = path115.join(evidenceDir, `${summary.id}.diff.txt`);
-  const noticeRelPath = path115.join(evidenceDir, `${summary.id}.redaction.md`);
+  const wrapUpRelPath = path116.join(evidenceDir, `${summary.id}.wrap-up.md`);
+  const diffRelPath = path116.join(evidenceDir, `${summary.id}.diff.txt`);
+  const noticeRelPath = path116.join(evidenceDir, `${summary.id}.redaction.md`);
   const floor = await applyEvidenceRedactionFloor(input.cwd, [
-    { name: path115.basename(relPath), content: markdown, path: relPath, source: "generated" },
-    { name: path115.basename(wrapUpRelPath), content: wrapUpMarkdown, path: wrapUpRelPath, source: "generated" },
-    { name: path115.basename(diffRelPath), content: diffBody, path: diffRelPath, source: "tool-output" }
+    { name: path116.basename(relPath), content: markdown, path: relPath, source: "generated" },
+    { name: path116.basename(wrapUpRelPath), content: wrapUpMarkdown, path: wrapUpRelPath, source: "generated" },
+    { name: path116.basename(diffRelPath), content: diffBody, path: diffRelPath, source: "tool-output" }
   ]);
   if (!floor.ok)
     throw new SessionWrapUpError("security_denied", floor.reason);
   const [safeSession, safeWrapUp, safeDiff] = floor.bodies;
-  await mkdir34(path115.join(input.cwd, evidenceDir), { recursive: true });
-  await writeFile23(path115.join(input.cwd, relPath), safeSession.content, "utf8");
-  await writeFile23(path115.join(input.cwd, wrapUpRelPath), safeWrapUp.content, "utf8");
-  await writeFile23(path115.join(input.cwd, diffRelPath), safeDiff.content, "utf8");
+  await mkdir34(path116.join(input.cwd, evidenceDir), { recursive: true });
+  await writeFile23(path116.join(input.cwd, relPath), safeSession.content, "utf8");
+  await writeFile23(path116.join(input.cwd, wrapUpRelPath), safeWrapUp.content, "utf8");
+  await writeFile23(path116.join(input.cwd, diffRelPath), safeDiff.content, "utf8");
   if (floor.notice !== undefined)
-    await writeFile23(path115.join(input.cwd, noticeRelPath), floor.notice, "utf8");
+    await writeFile23(path116.join(input.cwd, noticeRelPath), floor.notice, "utf8");
   const observedAt = now().toISOString();
   const evidence = [
     { kind: "wrap-up", uri: `./${wrapUpRelPath}`, revision: createHash26("sha256").update(safeWrapUp.content).digest("hex"), observedAt },
@@ -39096,13 +39204,13 @@ async function resolveSessionWrapUp(input) {
 init_fs();
 import { createHash as createHash27, randomBytes as randomBytes6 } from "crypto";
 import { readFile as readFile57 } from "fs/promises";
-import path116 from "path";
+import path117 from "path";
 var CONFIRM_TOKEN_TTL_MS = 2 * 60000;
 function confirmTokenPath2(cwd, workspaceId, proposalId) {
-  return path116.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.confirm-token.json`);
+  return path117.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.confirm-token.json`);
 }
 function confirmReceiptPath(cwd, workspaceId, proposalId, idempotencyKey) {
-  return path116.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${sha2566(idempotencyKey)}.confirm-receipt.json`);
+  return path117.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${sha2566(idempotencyKey)}.confirm-receipt.json`);
 }
 function sha2566(text) {
   return createHash27("sha256").update(text).digest("hex");
@@ -39143,21 +39251,21 @@ init_store();
 init_config();
 import { readFile as readFile59, readdir as readdir20 } from "fs/promises";
 import { randomUUID as randomUUID6 } from "crypto";
-import path118 from "path";
+import path119 from "path";
 
 // src/sac/proposal-evidence.ts
 init_fs();
 import { createHash as createHash28 } from "crypto";
 import { readFile as readFile58, rm as rm8 } from "fs/promises";
-import path117 from "path";
+import path118 from "path";
 function proposalPath(cwd, workspaceId, proposalId) {
-  return path117.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.json`);
+  return path118.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.json`);
 }
 function ownerReceiptPath(cwd, owner, workspaceId, idempotencyKey) {
-  return path117.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-receipts`, `${idempotencyKey}.json`);
+  return path118.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-receipts`, `${idempotencyKey}.json`);
 }
 function proposalNotePath(cwd, workspaceId, proposalId) {
-  return path117.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.note.txt`);
+  return path118.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.note.txt`);
 }
 async function readVerifiedProposalEvidence(cwd, workspaceId, proposalId) {
   let proposal;
@@ -39171,7 +39279,7 @@ async function readVerifiedProposalEvidence(cwd, workspaceId, proposalId) {
     return { ok: false, code: "no_evidence_to_write" };
   let content;
   try {
-    content = await readFile58(path117.join(cwd, evidence.uri), "utf8");
+    content = await readFile58(path118.join(cwd, evidence.uri), "utf8");
   } catch {
     return { ok: false, code: "evidence_file_unreadable" };
   }
@@ -39201,22 +39309,22 @@ function targetRelPath(targetRef) {
   return targetRef.replace(/^\.\//, "");
 }
 function targetAbsolutePath(cwd, targetRef) {
-  return path117.join(cwd, ".metaproject", targetRelPath(targetRef));
+  return path118.join(cwd, ".metaproject", targetRelPath(targetRef));
 }
 function targetKey(targetRef) {
   return digestOf2(targetRelPath(targetRef)).slice(0, 32);
 }
 function ownerTargetVersionPath(cwd, owner, workspaceId, targetRef) {
-  return path117.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-target-versions`, `${targetKey(targetRef)}.json`);
+  return path118.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-target-versions`, `${targetKey(targetRef)}.json`);
 }
 function ownerTargetLockPath(cwd, owner, targetRef) {
-  return path117.join(cwd, ".metaproject", "data", "sac", "target-locks", owner, `${targetKey(targetRef)}.lock`);
+  return path118.join(cwd, ".metaproject", "data", "sac", "target-locks", owner, `${targetKey(targetRef)}.lock`);
 }
 function ownerStagingDir(cwd, owner, workspaceId, idempotencyKey) {
-  return path117.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-staging`, digestOf2(idempotencyKey).slice(0, 32));
+  return path118.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-staging`, digestOf2(idempotencyKey).slice(0, 32));
 }
 function ownerConflictDir(cwd, owner, workspaceId, idempotencyKey) {
-  return path117.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-conflicts`, digestOf2(idempotencyKey).slice(0, 32));
+  return path118.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-conflicts`, digestOf2(idempotencyKey).slice(0, 32));
 }
 async function readJson2(file) {
   try {
@@ -39287,7 +39395,7 @@ async function applyGuardedTargetWrite(input) {
       staged: input.staged,
       stagedAt: receipt.completedAt
     };
-    await writeFileAtomic(path117.join(ownerStagingDir(cwd, owner, intent.workspaceId, intent.idempotencyKey), "plan.json"), `${JSON.stringify(staged, null, 2)}
+    await writeFileAtomic(path118.join(ownerStagingDir(cwd, owner, intent.workspaceId, intent.idempotencyKey), "plan.json"), `${JSON.stringify(staged, null, 2)}
 `);
     const applied = await input.apply(input.staged);
     if (!applied.ok) {
@@ -39313,15 +39421,15 @@ async function recoverStagedOwnerWrite(input) {
   });
 }
 async function readStagedOwnerWrite(cwd, owner, workspaceId, idempotencyKey) {
-  return readJson2(path117.join(ownerStagingDir(cwd, owner, workspaceId, idempotencyKey), "plan.json"));
+  return readJson2(path118.join(ownerStagingDir(cwd, owner, workspaceId, idempotencyKey), "plan.json"));
 }
 async function recordConflict(input) {
   const base = { targetRef: input.targetRef, expectedVersion: input.expectedVersion, currentVersion: input.currentVersion };
   if (input.proposedContent === undefined)
     return base;
   const dir = ownerConflictDir(input.cwd, input.owner, input.intent.workspaceId, input.intent.idempotencyKey);
-  await writeFileAtomic(path117.join(dir, "proposed"), input.proposedContent);
-  const diffRef = `./workspaces/${input.intent.workspaceId}/${input.owner}-write-conflicts/${path117.basename(dir)}/proposed`;
+  await writeFileAtomic(path118.join(dir, "proposed"), input.proposedContent);
+  const diffRef = `./workspaces/${input.intent.workspaceId}/${input.owner}-write-conflicts/${path118.basename(dir)}/proposed`;
   return { ...base, diffRef };
 }
 
@@ -39371,7 +39479,7 @@ async function resolveWorkspaceModule(cwd, workspaceId) {
   }
 }
 async function collectWikiDecisionEntries(cwd) {
-  const dir = path118.join(cwd, ".metaproject", "wiki", "decisions");
+  const dir = path119.join(cwd, ".metaproject", "wiki", "decisions");
   let files;
   try {
     files = (await readdir20(dir)).filter((name) => name.endsWith(".md"));
@@ -39380,12 +39488,12 @@ async function collectWikiDecisionEntries(cwd) {
   }
   const entries = [];
   for (const file of files) {
-    const absolutePath = path118.join(dir, file);
+    const absolutePath = path119.join(dir, file);
     try {
       const content = await readFile59(absolutePath, "utf8");
       entries.push({
         absolutePath,
-        relativePath: path118.posix.join("decisions", file),
+        relativePath: path119.posix.join("decisions", file),
         type: extractHeaderField(content, "Type") ?? "decision",
         title: extractTitle(content),
         version: extractHeaderField(content, "Version") ?? null,
@@ -39607,7 +39715,7 @@ function createRealMemoryOwnerWriter(cwd, opts) {
 init_service4();
 init_guard();
 import { readFile as readFile61 } from "fs/promises";
-import path119 from "path";
+import path120 from "path";
 function renderWrapUpDecisionPage(input) {
   const note = input.note?.trim();
   return `# ${input.title}
@@ -39648,7 +39756,7 @@ export is the source of truth for what actually happened.
 `;
 }
 function wikiPageRelativePath(proposalId) {
-  return path119.posix.join("decisions", `sac-${proposalId}.md`);
+  return path120.posix.join("decisions", `sac-${proposalId}.md`);
 }
 function createRealWikiOwnerWriter(cwd, opts) {
   const now = opts?.now ?? (() => new Date);
@@ -39656,7 +39764,7 @@ function createRealWikiOwnerWriter(cwd, opts) {
     const relativePath = staged.relativePath;
     const content = staged.content;
     const history = await openWikiWriteContext(cwd, "sac proposal accept");
-    await writeWikiPage(history, path119.join(cwd, ".metaproject", "wiki", relativePath), content);
+    await writeWikiPage(history, path120.join(cwd, ".metaproject", "wiki", relativePath), content);
     return { ok: true };
   };
   return {
@@ -39726,7 +39834,7 @@ init_guard();
 import { createHash as createHash29 } from "crypto";
 import { homedir as homedir2 } from "os";
 import { readFile as readFile62, stat as stat17 } from "fs/promises";
-import path120 from "path";
+import path121 from "path";
 var VERSION = "0.1.0";
 var PROJECT_SKILLS_DIR = ".metaproject/project-skills";
 var PROJECT_SKILLS_MANIFEST_PATH = ".metaproject/metaproject.json";
@@ -39756,7 +39864,7 @@ async function assertProjectWritesContained(projectRoot, paths) {
   }
 }
 async function createProjectSkill(projectRoot, options) {
-  const metaprojectRoot = path120.join(projectRoot, ".metaproject");
+  const metaprojectRoot = path121.join(projectRoot, ".metaproject");
   if (!await pathExists(metaprojectRoot)) {
     throw new Error("Metaproject is not initialized. Run: keryx init");
   }
@@ -39767,7 +39875,7 @@ async function createProjectSkill(projectRoot, options) {
   const skillName = projectSkillSlug(options.name ?? inferSkillName(options.target));
   const format = options.format ?? "auto";
   const relativeSkillPath = projectSkillPackagePath(moduleName, skillName);
-  const packageRoot = path120.join(projectRoot, relativeSkillPath);
+  const packageRoot = path121.join(projectRoot, relativeSkillPath);
   await assertProjectWritesContained(projectRoot, projectSkillWritePaths(moduleName, skillName, format));
   const origin = options.origin ? options.originContent !== undefined ? {
     ref: options.origin.trim(),
@@ -39778,7 +39886,7 @@ async function createProjectSkill(projectRoot, options) {
   const warnings = collectWarnings(evidence, format);
   const files = filesForPackage(packageRoot, format);
   if (!options.dryRun) {
-    await withFileLock(path120.join(projectRoot, PROJECT_SKILLS_LOCK_PATH), async () => {
+    await withFileLock(path121.join(projectRoot, PROJECT_SKILLS_LOCK_PATH), async () => {
       await writeProjectSkillPackage({
         projectRoot,
         packageRoot,
@@ -39807,7 +39915,7 @@ async function createProjectSkill(projectRoot, options) {
     name: skillName,
     target: options.target,
     skillPath: relativeSkillPath,
-    files: files.map((filePath) => toPosix(path120.relative(projectRoot, filePath))),
+    files: files.map((filePath) => toPosix(path121.relative(projectRoot, filePath))),
     warnings,
     dryRun: options.dryRun === true
   };
@@ -39816,9 +39924,9 @@ var MAX_SKILL_TARGET_LENGTH = 80;
 function resolveOriginPath(ref, projectRoot) {
   const trimmed = ref.trim();
   if (trimmed === "~" || trimmed.startsWith("~/")) {
-    return path120.join(homedir2(), trimmed.slice(1));
+    return path121.join(homedir2(), trimmed.slice(1));
   }
-  return path120.resolve(projectRoot, trimmed);
+  return path121.resolve(projectRoot, trimmed);
 }
 function hashOriginContent(content) {
   return `sha256:${createHash29("sha256").update(content).digest("hex")}`;
@@ -39856,16 +39964,16 @@ async function writeProjectSkillPackage({
 }) {
   const packageFormat = format === "single" ? "single" : "package";
   const skillContent = renderProjectSkill({ moduleName, skillName, target, note, origin, evidence, packageFormat });
-  const relativeSkillMdPath = toPosix(path120.join(path120.relative(projectRoot, packageRoot), "SKILL.md"));
+  const relativeSkillMdPath = toPosix(path121.join(path121.relative(projectRoot, packageRoot), "SKILL.md"));
   const guard = await guardOutput({ cwd: projectRoot, content: skillContent, target: "skill", source: "generated", path: relativeSkillMdPath });
   const output = prepareOutputForPersistence(guard, skillContent);
   if (!output.allowed) {
     throw new Error(`Project skill blocked by the security gate: ${output.reason}`);
   }
-  const packageRel = toPosix(path120.relative(projectRoot, packageRoot));
+  const packageRel = toPosix(path121.relative(projectRoot, packageRoot));
   const write = (file, content) => writeContained(projectRoot, `${packageRel}/${file}`, content);
   await write("SKILL.md", output.content);
-  if (!await pathExists(path120.join(packageRoot, "skill-changelog.md"))) {
+  if (!await pathExists(path121.join(packageRoot, "skill-changelog.md"))) {
     await write("skill-changelog.md", renderSkillChangelog({ moduleName, skillName, target }));
   }
   if (packageFormat === "package") {
@@ -39875,10 +39983,10 @@ async function writeProjectSkillPackage({
   }
 }
 async function collectEvidence(projectRoot, target) {
-  const absoluteTarget = path120.resolve(projectRoot, target);
+  const absoluteTarget = path121.resolve(projectRoot, target);
   const targetExists = await pathExists(absoluteTarget);
   const targetKind = await classifyTarget(absoluteTarget, targetExists);
-  const maybeRelativeTarget = targetExists ? toPosix(path120.relative(projectRoot, absoluteTarget)) : undefined;
+  const maybeRelativeTarget = targetExists ? toPosix(path121.relative(projectRoot, absoluteTarget)) : undefined;
   const graphArtifacts = await existingRelativePaths(projectRoot, [
     ".metaproject/data/gdgraph/artifacts/summary.md",
     ".metaproject/data/gdgraph/artifacts/module-map.json"
@@ -39908,7 +40016,7 @@ async function classifyTarget(absoluteTarget, targetExists) {
 async function existingRelativePaths(projectRoot, candidates) {
   const existing = [];
   for (const candidate of candidates) {
-    if (await pathExists(path120.join(projectRoot, candidate))) {
+    if (await pathExists(path121.join(projectRoot, candidate))) {
       existing.push(candidate);
     }
   }
@@ -39935,17 +40043,17 @@ function collectWarnings(evidence, format) {
 }
 function filesForPackage(packageRoot, format) {
   const base = [
-    path120.join(packageRoot, "SKILL.md"),
-    path120.join(packageRoot, "skill-changelog.md")
+    path121.join(packageRoot, "SKILL.md"),
+    path121.join(packageRoot, "skill-changelog.md")
   ];
   if (format === "single") {
     return base;
   }
   return [
     ...base,
-    path120.join(packageRoot, "verification.md"),
-    path120.join(packageRoot, "references", "context.md"),
-    path120.join(packageRoot, "templates", "README.md")
+    path121.join(packageRoot, "verification.md"),
+    path121.join(packageRoot, "references", "context.md"),
+    path121.join(packageRoot, "templates", "README.md")
   ];
 }
 function renderProjectSkill({
@@ -40173,7 +40281,7 @@ keryx skills verify ${moduleName}/${skillName}
 `;
 }
 async function updateManifest(projectRoot, entry) {
-  const manifestPath = path120.join(projectRoot, PROJECT_SKILLS_MANIFEST_PATH);
+  const manifestPath = path121.join(projectRoot, PROJECT_SKILLS_MANIFEST_PATH);
   const manifest = await readJsonFileOr(manifestPath, {});
   manifest.modules ??= {};
   manifest.modules.gdskills ??= {};
@@ -40187,8 +40295,8 @@ async function updateManifest(projectRoot, entry) {
 `);
 }
 async function updateSkillsCatalog(projectRoot) {
-  const manifestPath = path120.join(projectRoot, PROJECT_SKILLS_MANIFEST_PATH);
-  const catalogPath = path120.join(projectRoot, PROJECT_SKILLS_CATALOG_PATH);
+  const manifestPath = path121.join(projectRoot, PROJECT_SKILLS_MANIFEST_PATH);
+  const catalogPath = path121.join(projectRoot, PROJECT_SKILLS_CATALOG_PATH);
   const manifest = await readJsonFileOr(manifestPath, {});
   const registry = manifest.modules?.gdskills?.projectSkillRegistry ?? [];
   const rows = registry.length > 0 ? registry.map(projectSkillCatalogRow).join(`
@@ -40228,7 +40336,7 @@ function inferModule(target) {
 }
 function inferSkillName(target) {
   const normalized = target.trim().replace(/[#:]+/g, "/");
-  const base = path120.basename(normalized).replace(/\.[^.]+$/, "");
+  const base = path121.basename(normalized).replace(/\.[^.]+$/, "");
   return base || "entity";
 }
 function projectSkillSlug(value) {
@@ -40333,7 +40441,7 @@ class ProposalLifecycleService {
   now;
   constructor(options) {
     this.options = options;
-    this.root = path121.resolve(options.workspaceRoot);
+    this.root = path122.resolve(options.workspaceRoot);
     this.now = options.now ?? (() => new Date);
   }
   async create(input) {
@@ -40352,7 +40460,7 @@ class ProposalLifecycleService {
       if (manifest.status === "archived")
         throw new ProposalLifecycleError("guard_denied", "workspace is archived");
       const file = this.proposalPath(workspaceId, proposal.id);
-      await mkdir35(path121.dirname(file), { recursive: true, mode: 448 });
+      await mkdir35(path122.dirname(file), { recursive: true, mode: 448 });
       return withFileLock(`${file}.lock`, async () => {
         const consume = this.options.wrapUpAuthority.consume(input.wrapUp, { actor, workspaceId });
         if (consume !== "ok")
@@ -40380,7 +40488,7 @@ class ProposalLifecycleService {
     return this.options.workspaces.withAuthorizedActor({ actorContext: actor, workspaceId: input.workspaceId, action: "review", execute: async (manifest) => {
       const proposal = await this.loadProposal(input.workspaceId, input.proposalId);
       const ledger = this.ledgerPath(input.workspaceId);
-      await mkdir35(path121.dirname(ledger), { recursive: true, mode: 448 });
+      await mkdir35(path122.dirname(ledger), { recursive: true, mode: 448 });
       return withFileLock(`${ledger}.lock`, async () => {
         const records = (await this.records(ledger)).filter((record) => record.proposalId === proposal.id);
         const events = records.filter((record) => record.recordType === "proposal-transition");
@@ -40422,7 +40530,7 @@ class ProposalLifecycleService {
     } });
   }
   async listProposedProposals(workspaceId) {
-    const proposalsDir = path121.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals");
+    const proposalsDir = path122.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals");
     let entries;
     try {
       entries = (await readdir21(proposalsDir)).filter((name) => name.endsWith(".json"));
@@ -40434,7 +40542,7 @@ class ProposalLifecycleService {
     const proposals = [];
     for (const entry of entries) {
       try {
-        const parsed = JSON.parse(await readFile64(path121.join(proposalsDir, entry), "utf8"));
+        const parsed = JSON.parse(await readFile64(path122.join(proposalsDir, entry), "utf8"));
         if (parsed.recordType === "proposal-created")
           proposals.push(parsed);
       } catch {}
@@ -40700,31 +40808,31 @@ class ProposalLifecycleService {
     }
   }
   proposalPath(workspaceId, proposalId) {
-    return path121.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.json`);
+    return path122.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.json`);
   }
   decisionRef(proposalId, key) {
     return `./proposals/${proposalId}.${hash(key)}.decision.json`;
   }
   decisionPath(workspaceId, proposalId, key) {
-    return path121.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash(key)}.decision.json`);
+    return path122.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash(key)}.decision.json`);
   }
   approvalRef(proposalId, key) {
     return `./proposals/${proposalId}.${hash(key)}.approval.json`;
   }
   approvalPath(workspaceId, proposalId, key) {
-    return path121.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash(key)}.approval.json`);
+    return path122.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash(key)}.approval.json`);
   }
   writeResultPath(workspaceId, proposalId, key) {
-    return path121.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash(key)}.write-result.json`);
+    return path122.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash(key)}.write-result.json`);
   }
   intentRef(proposalId, key) {
     return `./proposals/${proposalId}.${hash(key)}.write-intent.json`;
   }
   intentPath(workspaceId, proposalId, key) {
-    return path121.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash(key)}.write-intent.json`);
+    return path122.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash(key)}.write-intent.json`);
   }
   attemptPath(workspaceId, proposalId, key) {
-    return path121.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash(key)}.owner-write-attempt.json`);
+    return path122.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash(key)}.owner-write-attempt.json`);
   }
   async loadWriteResult(workspaceId, proposalId, key) {
     try {
@@ -40751,7 +40859,7 @@ class ProposalLifecycleService {
     }
   }
   ledgerPath(workspaceId) {
-    return path121.join(this.root, ".metaproject", "workspaces", workspaceId, "activity.jsonl");
+    return path122.join(this.root, ".metaproject", "workspaces", workspaceId, "activity.jsonl");
   }
   timestamp() {
     return this.now().toISOString();
@@ -40834,7 +40942,7 @@ function normalizeProposalLifecycleResult(value) {
 // src/sac/collaboration-service.ts
 import { appendFile as appendFile9, mkdir as mkdir36, readFile as readFile65 } from "fs/promises";
 import { randomUUID as randomUUID8 } from "crypto";
-import path122 from "path";
+import path123 from "path";
 class CollaborationServiceError extends Error {
   code;
   constructor(code, message) {
@@ -40849,7 +40957,7 @@ class CollaborationService {
     this.input = input;
   }
   file(id) {
-    return path122.join(this.input.workspaceRoot, ".metaproject", "workspaces", id, "activity.jsonl");
+    return path123.join(this.input.workspaceRoot, ".metaproject", "workspaces", id, "activity.jsonl");
   }
   async overview(input) {
     const manifest = await this.input.workspaces.show(input);
@@ -40886,7 +40994,7 @@ class CollaborationService {
         occurredAt: (this.input.now ?? (() => new Date))().toISOString(),
         ...suppliedHandoff ? { handoff: { ...suppliedHandoff, from: actor.subject } } : {}
       });
-      await mkdir36(path122.dirname(this.file(manifest.id)), { recursive: true, mode: 448 });
+      await mkdir36(path123.dirname(this.file(manifest.id)), { recursive: true, mode: 448 });
       await appendFile9(this.file(manifest.id), `${JSON.stringify(activity)}
 `, { mode: 384 });
       return normalizeCollaborationResult(activity);
@@ -40936,13 +41044,13 @@ function normalizeCollaborationResult(value) {
 // src/session/external-slate.ts
 init_fs();
 import { mkdir as mkdir38, readdir as readdir22, readFile as readFile66 } from "fs/promises";
-import path124 from "path";
+import path125 from "path";
 
 // src/sac/machine-wrap-up.ts
 init_fs();
 import { createHash as createHash31, randomUUID as randomUUID10 } from "crypto";
 import { mkdir as mkdir37 } from "fs/promises";
-import path123 from "path";
+import path124 from "path";
 
 // src/sac/workspace-resolve.ts
 init_redact();
@@ -41083,11 +41191,11 @@ async function resolveMachineWrapUp(input) {
 `;
   const seedsJson = `${JSON.stringify(seedsForKind.map((seed) => ({ text: seed.text, source: describeSource(seed.source) })), null, 2)}
 `;
-  const evidenceRelBase = path123.posix.join(".metaproject", "workspaces", input.workspaceId, "machine-evidence");
+  const evidenceRelBase = path124.posix.join(".metaproject", "workspaces", input.workspaceId, "machine-evidence");
   const floor = await applyEvidenceRedactionFloor(input.cwd, [
-    { name: `${input.kind}.diff.txt`, content: diffBody, path: path123.posix.join(evidenceRelBase, `${input.kind}.diff.txt`), source: "tool-output" },
-    { name: `${input.kind}.flow.json`, content: flowSnapshotJson, path: path123.posix.join(evidenceRelBase, `${input.kind}.flow.json`), source: "generated" },
-    { name: `${input.kind}.seeds.json`, content: seedsJson, path: path123.posix.join(evidenceRelBase, `${input.kind}.seeds.json`), source: "generated" }
+    { name: `${input.kind}.diff.txt`, content: diffBody, path: path124.posix.join(evidenceRelBase, `${input.kind}.diff.txt`), source: "tool-output" },
+    { name: `${input.kind}.flow.json`, content: flowSnapshotJson, path: path124.posix.join(evidenceRelBase, `${input.kind}.flow.json`), source: "generated" },
+    { name: `${input.kind}.seeds.json`, content: seedsJson, path: path124.posix.join(evidenceRelBase, `${input.kind}.seeds.json`), source: "generated" }
   ]);
   if (!floor.ok)
     return { ok: false, code: "security_denied", detail: floor.reason };
@@ -41141,14 +41249,14 @@ ${safeSeeds.content}`;
     }
     summary = result.text.trim().length > 0 ? result.text.trim() : mechanicalSummary(summaryDiff, course);
   }
-  const evidenceDir = path123.join(input.cwd, ".metaproject", "workspaces", input.workspaceId, "machine-evidence");
+  const evidenceDir = path124.join(input.cwd, ".metaproject", "workspaces", input.workspaceId, "machine-evidence");
   await mkdir37(evidenceDir, { recursive: true });
   const diffFile = `${input.kind}.${shortHash}.diff.txt`;
   const flowFile = `${input.kind}.${shortHash}.flow.json`;
   const seedsFile = `${input.kind}.${shortHash}.seeds.json`;
-  await writeFileAtomic(path123.join(evidenceDir, diffFile), safeDiff.content);
-  await writeFileAtomic(path123.join(evidenceDir, flowFile), safeFlow.content);
-  await writeFileAtomic(path123.join(evidenceDir, seedsFile), safeSeeds.content);
+  await writeFileAtomic(path124.join(evidenceDir, diffFile), safeDiff.content);
+  await writeFileAtomic(path124.join(evidenceDir, flowFile), safeFlow.content);
+  await writeFileAtomic(path124.join(evidenceDir, seedsFile), safeSeeds.content);
   const observedAt = now().toISOString();
   const relBase = `./.metaproject/workspaces/${input.workspaceId}/machine-evidence`;
   const evidence = [
@@ -41158,7 +41266,7 @@ ${safeSeeds.content}`;
   ];
   if (floor.notice !== undefined) {
     const noticeFile = `${input.kind}.${shortHash}.redaction.md`;
-    await writeFileAtomic(path123.join(evidenceDir, noticeFile), floor.notice);
+    await writeFileAtomic(path124.join(evidenceDir, noticeFile), floor.notice);
     evidence.push({ kind: REDACTION_NOTICE_KIND, uri: `${relBase}/${noticeFile}`, revision: sha2567(floor.notice), observedAt });
   }
   return {
@@ -41177,18 +41285,18 @@ async function writeFlooredArchiveArtifact(params) {
     {
       name: params.filename,
       content: params.content,
-      path: path123.posix.join("slate-archive", params.filename),
+      path: path124.posix.join("slate-archive", params.filename),
       source: "generated"
     }
   ]);
   if (!floor.ok)
     return { ok: false, code: "security_denied", detail: floor.reason };
   const body = floor.bodies[0];
-  const archiveDir = path123.join(params.dir, "slate-archive");
+  const archiveDir = path124.join(params.dir, "slate-archive");
   await mkdir37(archiveDir, { recursive: true });
-  await writeFileAtomic(path123.join(archiveDir, params.filename), body.content);
+  await writeFileAtomic(path124.join(archiveDir, params.filename), body.content);
   if (floor.notice !== undefined) {
-    await writeFileAtomic(path123.join(archiveDir, `${params.filename}${ARCHIVE_REDACTION_NOTICE_SUFFIX}`), floor.notice);
+    await writeFileAtomic(path124.join(archiveDir, `${params.filename}${ARCHIVE_REDACTION_NOTICE_SUFFIX}`), floor.notice);
   }
   return { ok: true, altered: body.altered };
 }
@@ -41224,9 +41332,9 @@ async function writeWrapUpOutcomeArtifact(cwd, dir, trigger, now, groups) {
       return;
     const refusalIso = now().toISOString();
     const refusalFilename = `${refusalIso.replace(/[:.]/g, "-")}-wrap-up-outcome.json`;
-    const archiveDir = path123.join(dir, "slate-archive");
+    const archiveDir = path124.join(dir, "slate-archive");
     await mkdir37(archiveDir, { recursive: true });
-    await writeFileAtomic(path123.join(archiveDir, refusalFilename), `${JSON.stringify({
+    await writeFileAtomic(path124.join(archiveDir, refusalFilename), `${JSON.stringify({
       recordType: "wrap-up-outcome",
       trigger,
       generatedAt: refusalIso,
@@ -41362,7 +41470,7 @@ async function runWrapUp(input) {
 
 // src/session/external-slate.ts
 function externalSlatesDir(cwd) {
-  return path124.join(cwd, ".keryx", "external-slates");
+  return path125.join(cwd, ".keryx", "external-slates");
 }
 var EXTERNAL_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 function assertValidExternalSessionId(externalSessionId) {
@@ -41372,14 +41480,14 @@ function assertValidExternalSessionId(externalSessionId) {
 }
 function externalSlatePath(cwd, externalSessionId) {
   assertValidExternalSessionId(externalSessionId);
-  return path124.join(externalSlatesDir(cwd), `${externalSessionId}.json`);
+  return path125.join(externalSlatesDir(cwd), `${externalSessionId}.json`);
 }
 function externalSlateLockPath(cwd, externalSessionId) {
   return `${externalSlatePath(cwd, externalSessionId)}.lock`;
 }
 function externalSlateEvidenceDir(cwd, externalSessionId) {
   assertValidExternalSessionId(externalSessionId);
-  return path124.join(externalSlatesDir(cwd), externalSessionId);
+  return path125.join(externalSlatesDir(cwd), externalSessionId);
 }
 async function readExternalSlate(cwd, externalSessionId) {
   try {
@@ -41485,12 +41593,12 @@ __export(exports_service10, {
   runDoctor: () => runDoctor,
   runValidate: () => runValidate
 });
-import path127 from "path";
+import path128 from "path";
 import { readFile as readFile69 } from "fs/promises";
 
 // src/standard/validate.ts
 init_fs();
-import path126 from "path";
+import path127 from "path";
 import { readFile as readFile68 } from "fs/promises";
 
 // src/standard/schemas.ts
@@ -41620,7 +41728,7 @@ var SCHEMA_REGISTRY2 = {
 // src/standard/profiles.ts
 init_fs();
 init_entrypoint_targets();
-import path125 from "path";
+import path126 from "path";
 import { readFile as readFile67 } from "fs/promises";
 var AGENT_MODULES = ["gdgraph", "gdctx", "gdskills", "gdwiki", "memory"];
 var CI_MODULES = ["health", "testing"];
@@ -41645,7 +41753,7 @@ function enabledModuleKeys(manifest) {
 }
 async function rootEntrypointLinksIndex(cwd, manifest) {
   for (const { path: name } of namedEntrypoints(manifest)) {
-    const filePath = path125.join(cwd, name);
+    const filePath = path126.join(cwd, name);
     if (!await pathExists(filePath)) {
       continue;
     }
@@ -41657,16 +41765,16 @@ async function rootEntrypointLinksIndex(cwd, manifest) {
   return false;
 }
 async function minimalSatisfied(cwd) {
-  const metaprojectRoot = path125.join(cwd, ".metaproject");
+  const metaprojectRoot = path126.join(cwd, ".metaproject");
   const requiredFiles = ["index.md", "README.md", "metaproject.json"];
   const requiredDirs = ["modules", "rules", "skills", "data"];
   for (const file of requiredFiles) {
-    if (!await pathExists(path125.join(metaprojectRoot, file))) {
+    if (!await pathExists(path126.join(metaprojectRoot, file))) {
       return false;
     }
   }
   for (const dir of requiredDirs) {
-    if (!await pathExists(path125.join(metaprojectRoot, dir))) {
+    if (!await pathExists(path126.join(metaprojectRoot, dir))) {
       return false;
     }
   }
@@ -41679,7 +41787,7 @@ async function ciSatisfied(cwd, manifest) {
     return false;
   }
   for (const key of ciModules) {
-    if (await pathExists(path125.join(cwd, ".metaproject", "data", key, "artifacts"))) {
+    if (await pathExists(path126.join(cwd, ".metaproject", "data", key, "artifacts"))) {
       return true;
     }
   }
@@ -41692,7 +41800,7 @@ async function evaluateProfiles(cwd, manifest) {
     satisfied.push("minimal");
   }
   const hasAgentModule = AGENT_MODULES.some((key) => new Set(enabledModuleKeys(manifest)).has(key));
-  const agent = minimal && hasAgentModule && await rootEntrypointLinksIndex(cwd, manifest) && await pathExists(path125.join(cwd, ".metaproject", "rules"));
+  const agent = minimal && hasAgentModule && await rootEntrypointLinksIndex(cwd, manifest) && await pathExists(path126.join(cwd, ".metaproject", "rules"));
   if (agent) {
     satisfied.push("agent");
   }
@@ -41861,20 +41969,20 @@ var MANIFEST_TOP_LEVEL_SCHEMA = {
 async function validateWorkspace2(cwd) {
   const errors = [];
   const warnings = [];
-  const metaprojectRoot = path126.join(cwd, ".metaproject");
+  const metaprojectRoot = path127.join(cwd, ".metaproject");
   const requiredFiles = ["index.md", "README.md", "metaproject.json"];
   for (const file of requiredFiles) {
-    if (!await pathExists(path126.join(metaprojectRoot, file))) {
+    if (!await pathExists(path127.join(metaprojectRoot, file))) {
       errors.push(issue("missing-required-file", `Required file .metaproject/${file} is missing`, `Run \`keryx init\` to scaffold .metaproject/${file}.`));
     }
   }
   const requiredDirs = ["modules", "rules", "skills", "data"];
   for (const dir of requiredDirs) {
-    if (!await pathExists(path126.join(metaprojectRoot, dir))) {
+    if (!await pathExists(path127.join(metaprojectRoot, dir))) {
       errors.push(issue("missing-required-dir", `Required directory .metaproject/${dir}/ is missing`, `Run \`keryx init\` to create .metaproject/${dir}/.`));
     }
   }
-  const manifestPath = path126.join(metaprojectRoot, "metaproject.json");
+  const manifestPath = path127.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return { ok: errors.length === 0, errors, warnings };
   }
@@ -41906,7 +42014,7 @@ async function validateWorkspace2(cwd) {
       if (typeof value !== "string") {
         continue;
       }
-      if (!await pathExists(path126.join(cwd, value))) {
+      if (!await pathExists(path127.join(cwd, value))) {
         errors.push(issue("missing-declared-path", `Declared path paths.${key} -> ${value} does not exist`, `Create ${value} or remove paths.${key} from metaproject.json.`));
       }
     }
@@ -41916,7 +42024,7 @@ async function validateWorkspace2(cwd) {
       continue;
     }
     if (typeof entry.manifest === "string") {
-      if (!await pathExists(path126.join(cwd, entry.manifest))) {
+      if (!await pathExists(path127.join(cwd, entry.manifest))) {
         errors.push(issue("missing-module-manifest", `Enabled module "${key}" manifest ${entry.manifest} is missing`, `Create ${entry.manifest} or run \`keryx update\` to regenerate module manifests.`));
       }
     }
@@ -41925,14 +42033,14 @@ async function validateWorkspace2(cwd) {
       if (typeof value !== "string") {
         continue;
       }
-      if (!await pathExists(path126.join(cwd, value))) {
+      if (!await pathExists(path127.join(cwd, value))) {
         const sink = field === "data" ? warnings : errors;
         sink.push(issue("missing-module-path", `Module "${key}" declares ${String(field)} ${value}, which does not exist`, field === "data" ? `Run the module (e.g. \`keryx ${key} ...\`) to generate ${value}, or update modules.${key}.data in metaproject.json.` : `Create ${value} or update modules.${key}.${String(field)} in metaproject.json.`));
       }
     }
   }
   for (const { path: name, scope } of namedEntrypoints(manifest)) {
-    const filePath = path126.join(cwd, name);
+    const filePath = path127.join(cwd, name);
     if (!await pathExists(filePath)) {
       continue;
     }
@@ -42932,7 +43040,7 @@ async function runDoctor(cwd) {
   return validateWorkspace2(cwd);
 }
 async function readManifest(cwd) {
-  const manifestPath = path127.join(cwd, ".metaproject", "metaproject.json");
+  const manifestPath = path128.join(cwd, ".metaproject", "metaproject.json");
   if (!await pathExists(manifestPath)) {
     throw new Error("Metaproject is not initialized (missing .metaproject/metaproject.json). Run `keryx init` first.");
   }