@c4a/context-cli 0.7.81 → 0.7.83

package/cli.js

@@ -88170,6 +88170,36 @@ var init_packageSiteExtensions = __esm(() => {
   invalid = invalidSiteExtension;
 });
 
+// src/lib/packageVersion.ts
+import { existsSync as existsSync16, readFileSync as readFileSync7 } from "node:fs";
+import { dirname as dirname29, join as join68 } from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+function readPackageVersion() {
+  try {
+    let dir = dirname29(fileURLToPath6(import.meta.url));
+    for (let depth = 0;depth < 8; depth += 1) {
+      const packagePath = join68(dir, "package.json");
+      if (existsSync16(packagePath)) {
+        const parsed = JSON.parse(readFileSync7(packagePath, "utf8"));
+        if (typeof parsed.version === "string" && parsed.version.length > 0) {
+          return parsed.version;
+        }
+        break;
+      }
+      const parent = dirname29(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch (error) {
+    throw new TypeError("Context CLI package version cannot be read", {
+      cause: error
+    });
+  }
+  throw new TypeError("Context CLI package version is missing from package.json");
+}
+var init_packageVersion = () => {};
+
 // src/project/packageArticleLinks.ts
 import { posix as posix8 } from "node:path";
 function projectPackageArticleLinks(input) {
@@ -88217,11 +88247,11 @@ var init_packageArticleLinks = __esm(() => {
 // src/project/packageRenderCache.ts
 import { createHash as createHash19 } from "node:crypto";
 import { readFile as readFile60 } from "node:fs/promises";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 async function cachedPackageKnowledgeMarkdown(input) {
   const fingerprint = digest3(`${PACKAGE_READER_MARKDOWN_VERSION}
 ${input.content}`);
-  const path2 = join68(input.projectRoot, ".tmp/context-runtime/package-render", `${digest3(input.key)}.json`);
+  const path2 = join69(input.projectRoot, ".tmp/context-runtime/package-render", `${digest3(input.key)}.json`);
   try {
     const cached = JSON.parse(await readFile60(path2, "utf8"));
     if (cached !== null && typeof cached === "object" && "fingerprint" in cached && cached.fingerprint === fingerprint && "markdown" in cached && typeof cached.markdown === "string") {
@@ -88243,7 +88273,7 @@ var init_packageRenderCache = __esm(() => {
 
 // src/project/packageAssets.ts
 import { readFile as readFile61 } from "node:fs/promises";
-import { dirname as dirname29, relative as relative21, sep as sep6 } from "node:path";
+import { dirname as dirname30, relative as relative21, sep as sep6 } from "node:path";
 function posixPath2(value) {
   return value.split(sep6).join("/");
 }
@@ -88265,7 +88295,7 @@ function packageAssetPath(projectRoot, absolute) {
   };
 }
 function packageMarkdownTarget(pageOutputPath, assetOutputPath) {
-  const target = posixPath2(relative21(dirname29(pageOutputPath), assetOutputPath));
+  const target = posixPath2(relative21(dirname30(pageOutputPath), assetOutputPath));
   return target.startsWith(".") ? target : `./${target}`;
 }
 async function projectPackageKnowledgeAssets(input) {
@@ -88310,7 +88340,7 @@ var init_packageAssets = __esm(() => {
 // src/project/packageAssetOptimization.ts
 import { createHash as createHash20 } from "node:crypto";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname30, extname as extname10 } from "node:path";
+import { dirname as dirname31, extname as extname10 } from "node:path";
 function isPng(bytes) {
   return bytes.byteLength >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10;
 }
@@ -88364,7 +88394,7 @@ function isWebp(bytes) {
 }
 function contentAddressedWebpPath(asset, bytes) {
   const digest4 = createHash20("sha256").update(bytes).digest("hex");
-  return `${dirname30(asset.packageRelPath)}/${digest4}.webp`;
+  return `${dirname31(asset.packageRelPath)}/${digest4}.webp`;
 }
 async function loadSharpProcessor() {
   const requireFromCli = createRequire4(import.meta.url);
@@ -88577,7 +88607,7 @@ var init_packageAssetOptimization = __esm(() => {
 // src/project/packageAssetDelivery.ts
 import { execFile as execFile8 } from "node:child_process";
 import { realpath as realpath10 } from "node:fs/promises";
-import { join as join69, relative as relative22, sep as sep7 } from "node:path";
+import { join as join70, relative as relative22, sep as sep7 } from "node:path";
 import { promisify as promisify8 } from "node:util";
 async function git(projectRoot, args) {
   try {
@@ -88597,7 +88627,7 @@ async function git(projectRoot, args) {
   }
 }
 function repositoryPath(repoRoot, projectRoot, asset) {
-  const path2 = relative22(repoRoot, join69(projectRoot, asset.knowledgeRelPath)).split(sep7).join("/");
+  const path2 = relative22(repoRoot, join70(projectRoot, asset.knowledgeRelPath)).split(sep7).join("/");
   if (path2 === ".." || path2.startsWith("../") || path2.startsWith("/")) {
     throw new ContextError(ExitCode.WorkspaceStateError, "knowledge asset is outside the current Git repository", {
       category: ErrorCategory.WorkspaceStateInvalid,
@@ -88776,9 +88806,9 @@ var init_packageAssetDelivery = __esm(() => {
 });
 
 // src/project/packageBuildContent.ts
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 import { mkdir as mkdir24, readFile as readFile62, writeFile as writeFile20 } from "node:fs/promises";
-import { dirname as dirname31, join as join70 } from "node:path";
+import { dirname as dirname32, join as join71 } from "node:path";
 function globToRegExp(pattern) {
   const normalized = toPosixPath5(pattern);
   if (normalized.endsWith("/**")) {
@@ -88925,8 +88955,8 @@ async function writeRenderedPackageTemplate(input) {
       templateRelPath: renderedRelPath,
       logicalTemplateRelPath: renderedLogicalRelPath
     });
-    const outputPath = join70(input.projectRoot, input.pkg.outDir, renderedRelPath);
-    await mkdir24(dirname31(outputPath), { recursive: true });
+    const outputPath = join71(input.projectRoot, input.pkg.outDir, renderedRelPath);
+    await mkdir24(dirname32(outputPath), { recursive: true });
     await writeFile20(outputPath, renderTemplateText(file.content, contentVars), "utf8");
     written++;
   }
@@ -88960,7 +88990,7 @@ async function writeSelectedPackageKnowledge(input) {
   for (let offset2 = 0;offset2 < projectedPages.length; offset2 += 8) {
     const results = await Promise.allSettled(projectedPages.slice(offset2, offset2 + 8).map(async (projected) => {
       assertSafeRenderedPath(projected.pageOutputPath, "knowledge path");
-      const outputPath = join70(input.projectRoot, input.pkg.outDir, projected.pageOutputPath);
+      const outputPath = join71(input.projectRoot, input.pkg.outDir, projected.pageOutputPath);
       let mediaContent = projected.content;
       const omitted = new Set((delivered.omittedImages ?? []).map((path2) => packageMarkdownTarget(projected.pageOutputPath, path2)));
       for (const link of markdownReaderLinks(mediaContent).reverse()) {
@@ -88977,7 +89007,7 @@ async function writeSelectedPackageKnowledge(input) {
         }
         return;
       });
-      await mkdir24(dirname31(outputPath), { recursive: true });
+      await mkdir24(dirname32(outputPath), { recursive: true });
       const links = projectPackageArticleLinks({ markdown: await projectLinks(rewritten), approvedPath: approvedByOutput.get(projected.pageOutputPath), outputPath: projected.pageOutputPath, selected: outputByApproved });
       const markdown = await cachedPackageKnowledgeMarkdown({
         projectRoot: input.projectRoot,
@@ -88997,8 +89027,8 @@ async function writeSelectedPackageKnowledge(input) {
   const deliveredAssets = new Map(delivered.assets.map((asset) => [asset.packageRelPath, asset]));
   for (const asset of deliveredAssets.values()) {
     assertSafeRenderedPath(asset.packageRelPath, "package resource path");
-    const outputPath = join70(input.projectRoot, input.pkg.outDir, asset.packageRelPath);
-    await mkdir24(dirname31(outputPath), { recursive: true });
+    const outputPath = join71(input.projectRoot, input.pkg.outDir, asset.packageRelPath);
+    await mkdir24(dirname32(outputPath), { recursive: true });
     await writeFile20(outputPath, asset.bytes);
   }
   return {
@@ -89012,8 +89042,8 @@ async function writeSelectedPackageKnowledge(input) {
 async function appendLlmsKnowledge(input) {
   if (packageKind(input.pkg) !== "llms" || input.templateConsumesKnowledge || input.knowledgeCount === 0)
     return 0;
-  const outputPath = join70(input.projectRoot, input.pkg.outDir, "llms.txt");
-  const existed = existsSync16(outputPath);
+  const outputPath = join71(input.projectRoot, input.pkg.outDir, "llms.txt");
+  const existed = existsSync17(outputPath);
   const existing = existed ? await readFile62(outputPath, "utf8") : "";
   const content3 = existing.trim().length > 0 ? `${existing.trimEnd()}
 
@@ -89022,7 +89052,7 @@ async function appendLlmsKnowledge(input) {
 ${input.bundle}
 ` : `${input.bundle}
 `;
-  await mkdir24(dirname31(outputPath), { recursive: true });
+  await mkdir24(dirname32(outputPath), { recursive: true });
   await writeFile20(outputPath, content3, "utf8");
   return existed ? 0 : 1;
 }
@@ -89050,9 +89080,9 @@ var init_packageBuildContent = __esm(() => {
 
 // src/project/siteTranslation.ts
 import { createHash as createHash21 } from "node:crypto";
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 import { mkdir as mkdir25, readFile as readFile63, readdir as readdir17, rename as rename8, rm as rm12, writeFile as writeFile21 } from "node:fs/promises";
-import { dirname as dirname32, join as join71, relative as relative23, resolve as resolve26 } from "node:path";
+import { dirname as dirname33, join as join72, relative as relative23, resolve as resolve26 } from "node:path";
 function sha256(value) {
   return createHash21("sha256").update(value).digest("hex");
 }
@@ -89096,7 +89126,7 @@ async function optionalText2(path2) {
   }
 }
 async function readMapTranslation(projectRoot, locale) {
-  const content3 = await optionalText2(join71(projectRoot, mapTranslationPath(locale)));
+  const content3 = await optionalText2(join72(projectRoot, mapTranslationPath(locale)));
   if (content3 === undefined)
     return {};
   const parsed = mapTranslationSchema.safeParse(import_yaml38.parse(content3));
@@ -89111,10 +89141,10 @@ async function readMapTranslation(projectRoot, locale) {
   return parsed.data.entries;
 }
 async function listTranslationFiles(root) {
-  if (!existsSync17(root))
+  if (!existsSync18(root))
     return [];
   const entries2 = await readdir17(root, { withFileTypes: true, recursive: true });
-  return entries2.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => relative23(root, join71(entry.parentPath, entry.name)).split("\\").join("/"));
+  return entries2.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => relative23(root, join72(entry.parentPath, entry.name)).split("\\").join("/"));
 }
 async function selectedArticles(projectRoot, packages) {
   const approved = await listApprovedKnowledge(projectRoot);
@@ -89126,7 +89156,7 @@ async function selectedArticles(projectRoot, packages) {
   return [...selected.values()].sort((left, right) => left.relPath.localeCompare(right.relPath));
 }
 async function readTranslatedArticle(projectRoot, locale, file) {
-  const content3 = await optionalText2(join71(projectRoot, translationArticlePath(locale, file.relPath)));
+  const content3 = await optionalText2(join72(projectRoot, translationArticlePath(locale, file.relPath)));
   if (content3 === undefined)
     return;
   const { frontmatter, body } = splitFrontmatter(content3);
@@ -89146,7 +89176,7 @@ async function readTranslatedMapTitles(projectRoot, locale) {
   return new Map(Object.entries(await readMapTranslation(projectRoot, locale)).map(([key, entry]) => [key, entry.title]));
 }
 async function readReceipt(projectRoot) {
-  const content3 = await optionalText2(join71(projectRoot, TRANSLATION_RUNTIME_ROOT, RECEIPT_FILE));
+  const content3 = await optionalText2(join72(projectRoot, TRANSLATION_RUNTIME_ROOT, RECEIPT_FILE));
   if (content3 === undefined)
     return;
   try {
@@ -89167,7 +89197,7 @@ async function inspectSiteTranslations(projectRoot, packages) {
   for (const locale of locales) {
     for (const file of articles) {
       const sourceDigest = approvedArticleDigest(file.content);
-      const content3 = await optionalText2(join71(projectRoot, translationArticlePath(locale, file.relPath)));
+      const content3 = await optionalText2(join72(projectRoot, translationArticlePath(locale, file.relPath)));
       const stored = content3 === undefined ? undefined : splitFrontmatter(content3).frontmatter.translation;
       items.push({
         kind: "article",
@@ -89194,7 +89224,7 @@ async function inspectSiteTranslations(projectRoot, packages) {
       });
     }
     const known = new Set(articles.map((file) => file.relPath));
-    for (const relPath of await listTranslationFiles(join71(projectRoot, TRANSLATIONS_ROOT, locale))) {
+    for (const relPath of await listTranslationFiles(join72(projectRoot, TRANSLATIONS_ROOT, locale))) {
       if (!known.has(relPath))
         orphans.push(translationArticlePath(locale, relPath));
     }
@@ -89245,31 +89275,31 @@ async function prepareSiteTranslation(projectRoot, packages) {
       if (item.state === "current")
         continue;
       const source2 = approved.get(item.approved_path);
-      const stored = await optionalText2(join71(projectRoot, item.translation_path));
+      const stored = await optionalText2(join72(projectRoot, item.translation_path));
       const file = `${DRAFT_ROOT}/${item.locale}/${source2.relPath}`;
       const seed = stored ?? source2.content;
-      const existing = await optionalText2(join71(projectRoot, file));
+      const existing = await optionalText2(join72(projectRoot, file));
       const body = (content3) => content3.slice(FRONTMATTER_RE3.exec(content3)?.[0].length ?? 0);
       const kept = existing !== undefined && body(existing) !== body(seed);
       if (!kept)
-        await atomicWrite(join71(projectRoot, file), seed);
+        await atomicWrite(join72(projectRoot, file), seed);
       const translation = stored === undefined ? undefined : splitFrontmatter(stored).frontmatter.translation;
       const diff = kept || stored === undefined ? undefined : await sourceDiffSince(projectRoot, source2.relPath, stringField3(translation?.source_digest));
       const diffFile = `${file}.diff`;
       if (diff)
-        await atomicWrite(join71(projectRoot, diffFile), `${diff}
+        await atomicWrite(join72(projectRoot, diffFile), `${diff}
 `);
       else
-        await rm12(join71(projectRoot, diffFile), { force: true });
+        await rm12(join72(projectRoot, diffFile), { force: true });
       items.push({ ...item, file, draft: kept ? "kept" : "generated", source_diff: diff ? diffFile : null });
       articles.push({ locale: item.locale, approved_path: item.approved_path, file });
     }
     const task = { expected_digest: inspection.source_set_digest, locales: inspection.locales, items, orphans: inspection.orphans };
     const taskPath = `${TRANSLATION_RUNTIME_ROOT}/${TASK_FILE}`;
     const submissionPath = `${TRANSLATION_RUNTIME_ROOT}/submission.yaml`;
-    await atomicWrite(join71(projectRoot, taskPath), JSON.stringify(task, null, 2) + `
+    await atomicWrite(join72(projectRoot, taskPath), JSON.stringify(task, null, 2) + `
 `);
-    await atomicWrite(join71(projectRoot, submissionPath), import_yaml38.stringify({ expected_digest: task.expected_digest, articles, map_entries }));
+    await atomicWrite(join72(projectRoot, submissionPath), import_yaml38.stringify({ expected_digest: task.expected_digest, articles, map_entries }));
     return { ...task, task_path: taskPath, submission_path: submissionPath };
   });
 }
@@ -89317,13 +89347,13 @@ function invalidSubmission(message, extra = {}) {
   });
 }
 async function atomicWrite(path2, content3) {
-  await mkdir25(dirname32(path2), { recursive: true });
+  await mkdir25(dirname33(path2), { recursive: true });
   const temp = `${path2}.${process.pid}.tmp`;
   await writeFile21(temp, content3, "utf8");
   await rename8(temp, path2);
 }
 async function writeReceipt(projectRoot, digest4, outcome) {
-  await atomicWrite(join71(projectRoot, TRANSLATION_RUNTIME_ROOT, RECEIPT_FILE), JSON.stringify({ source_set_digest: digest4, outcome, recorded_at: new Date().toISOString() }, null, 2) + `
+  await atomicWrite(join72(projectRoot, TRANSLATION_RUNTIME_ROOT, RECEIPT_FILE), JSON.stringify({ source_set_digest: digest4, outcome, recorded_at: new Date().toISOString() }, null, 2) + `
 `);
 }
 function assertExpectedDigest(inspection, expected) {
@@ -89404,12 +89434,12 @@ ${body.trimStart()}` });
       writes.push({ path: mapTranslationPath(locale), content: import_yaml38.stringify({ locale, entries: entries2 }) });
     }
     for (const write of writes)
-      await atomicWrite(join71(projectRoot, write.path), write.content);
+      await atomicWrite(join72(projectRoot, write.path), write.content);
     for (const draft of drafts)
       for (const path2 of [draft, `${draft}.diff`])
-        await rm12(join71(projectRoot, path2), { force: true });
+        await rm12(join72(projectRoot, path2), { force: true });
     for (const orphan of inspection.orphans)
-      await rm12(join71(projectRoot, orphan), { force: true });
+      await rm12(join72(projectRoot, orphan), { force: true });
     await writeReceipt(projectRoot, digest4, "submitted");
     return { written: writes.map((write) => write.path), removed: inspection.orphans };
   });
@@ -89427,9 +89457,9 @@ async function siteTranslationFingerprint(projectRoot, pkg) {
     return null;
   const files = [];
   for (const locale of locales) {
-    const root = join71(projectRoot, TRANSLATIONS_ROOT, locale);
-    for (const relPath of [...await listTranslationFiles(root), ...existsSync17(join71(root, TRANSLATION_MAP_FILE)) ? [TRANSLATION_MAP_FILE] : []].sort()) {
-      files.push([`${locale}/${relPath}`, sha256(await readFile63(join71(root, relPath), "utf8"))]);
+    const root = join72(projectRoot, TRANSLATIONS_ROOT, locale);
+    for (const relPath of [...await listTranslationFiles(root), ...existsSync18(join72(root, TRANSLATION_MAP_FILE)) ? [TRANSLATION_MAP_FILE] : []].sort()) {
+      files.push([`${locale}/${relPath}`, sha256(await readFile63(join72(root, relPath), "utf8"))]);
     }
   }
   return sha256(JSON.stringify(files));
@@ -89666,7 +89696,7 @@ import { createHash as createHash22 } from "node:crypto";
 import { spawn as spawn3 } from "node:child_process";
 import { mkdir as mkdir26, mkdtemp as mkdtemp2, readFile as readFile64, writeFile as writeFile22, rm as rm13, symlink as symlink2, cp, access as access5, stat as stat10 } from "node:fs/promises";
 import { createRequire as createRequire5 } from "node:module";
-import { dirname as dirname33, join as join72, posix as posix10 } from "node:path";
+import { dirname as dirname34, join as join73, posix as posix10 } from "node:path";
 function sitePagePath(identity) {
   return `pages/${createHash22("sha256").update(identity).digest("hex").slice(0, 32)}.html`;
 }
@@ -89769,18 +89799,11 @@ function sidebar(entries2, label2 = (entry) => entry.title) {
   }));
 }
 function siteSections(entries2) {
-  const directoriesFirst = (siblings) => {
-    const ordered = [
-      ...siblings.filter((entry) => entry.children.length > 0),
-      ...siblings.filter((entry) => entry.children.length === 0)
-    ];
-    return ordered.map((entry) => ({ ...entry, children: directoriesFirst(entry.children) }));
-  };
   const pageLinks = (entry) => [
     ...entry.href ? [entry.href.split("#")[0]] : [],
     ...entry.children.flatMap(pageLinks)
   ];
-  return entries2.map((entry) => ({ ...entry, children: directoriesFirst(entry.children) })).map((entry) => ({
+  return entries2.map((entry) => ({
     key: entry.key,
     title: entry.title,
     entry,
@@ -89791,9 +89814,9 @@ function siteSections(entries2) {
   }));
 }
 async function compileSite(root, outDir) {
-  const vitepressRoot = dirname33(require2.resolve("vitepress/package.json"));
+  const vitepressRoot = dirname34(require2.resolve("vitepress/package.json"));
   await new Promise((resolve8, reject) => {
-    const child = spawn3(process.versions.bun ? "node" : process.execPath, [join72(vitepressRoot, "bin/vitepress.js"), "build", root, "--outDir", outDir], { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn3(process.versions.bun ? "node" : process.execPath, [join73(vitepressRoot, "bin/vitepress.js"), "build", root, "--outDir", outDir], { stdio: ["ignore", "pipe", "pipe"] });
     let tail = "";
     const receive = (chunk) => {
       tail = (tail + chunk.toString()).slice(-16000);
@@ -89840,8 +89863,8 @@ async function writePackageSite(input) {
   const base = options.base ?? "/";
   const history = await readWorkspaceChangelog(projectRoot);
   const historyDate = history[0]?.date ?? null;
-  const root = join72(projectRoot, pkg.outDir);
-  const output = join72(projectRoot, packageSiteOutputDir(pkg));
+  const root = join73(projectRoot, pkg.outDir);
+  const output = join73(projectRoot, packageSiteOutputDir(pkg));
   try {
     await access5(output);
     throw new Error("Website output already exists; build through the staged package workflow.");
@@ -89849,9 +89872,9 @@ async function writePackageSite(input) {
     if (error.code !== "ENOENT")
       throw error;
   }
-  const temporaryRoot = join72(projectRoot, ".tmp");
+  const temporaryRoot = join73(projectRoot, ".tmp");
   await mkdir26(temporaryRoot, { recursive: true });
-  const temporary = await mkdtemp2(join72(temporaryRoot, "website-"));
+  const temporary = await mkdtemp2(join73(temporaryRoot, "website-"));
   try {
     const registry2 = await loadSourcesRegistry({ rootDir: projectRoot });
     const repositoryRemote = await optionalRepoGit(projectRoot, ["remote", "get-url", "origin"]);
@@ -89877,27 +89900,27 @@ async function writePackageSite(input) {
     }
     const sections = siteSections(mapping.entries);
     const resources = new Set(delivered.filter((file) => file.relPath.startsWith("others/assets/") || file.relPath.startsWith("skills/") && !file.relPath.endsWith(".md")).map((file) => file.relPath));
-    const configRoot = join72(temporary, ".vitepress");
-    await mkdir26(join72(configRoot, "theme"), { recursive: true });
-    await mkdir26(join72(temporary, "node_modules"), { recursive: true });
-    const vitepressRoot = dirname33(require2.resolve("vitepress/package.json"));
-    const vueRequire = createRequire5(join72(vitepressRoot, "package.json"));
+    const configRoot = join73(temporary, ".vitepress");
+    await mkdir26(join73(configRoot, "theme"), { recursive: true });
+    await mkdir26(join73(temporary, "node_modules"), { recursive: true });
+    const vitepressRoot = dirname34(require2.resolve("vitepress/package.json"));
+    const vueRequire = createRequire5(join73(vitepressRoot, "package.json"));
     for (const [name3, path2] of [
       ["vitepress", vitepressRoot],
-      ["vue", dirname33(vueRequire.resolve("vue/package.json"))],
-      ["@mermaid-js/layout-elk", dirname33(require2.resolve("@mermaid-js/layout-elk/package.json"))],
-      ["mermaid", dirname33(require2.resolve("mermaid/package.json"))]
+      ["vue", dirname34(vueRequire.resolve("vue/package.json"))],
+      ["@mermaid-js/layout-elk", dirname34(require2.resolve("@mermaid-js/layout-elk/package.json"))],
+      ["mermaid", dirname34(require2.resolve("mermaid/package.json"))]
     ]) {
-      await mkdir26(dirname33(join72(temporary, "node_modules", name3)), { recursive: true });
-      await symlink2(path2, join72(temporary, "node_modules", name3), "dir");
+      await mkdir26(dirname34(join73(temporary, "node_modules", name3)), { recursive: true });
+      await symlink2(path2, join73(temporary, "node_modules", name3), "dir");
     }
     const readers = siteReaderLocales(options, pkg.name);
     const marker = createLocaleMarker();
-    await writeFile22(join72(configRoot, "theme/index.js"), siteThemeScript);
-    await writeFile22(join72(configRoot, "theme/style.css"), siteThemeCss + siteLocaleCss(readers) + siteThemeVariables(await resolveSiteTheme(projectRoot, options.theme, true)));
+    await writeFile22(join73(configRoot, "theme/index.js"), siteThemeScript);
+    await writeFile22(join73(configRoot, "theme/style.css"), siteThemeCss + siteLocaleCss(readers) + siteThemeVariables(await resolveSiteTheme(projectRoot, options.theme, true)));
     await writeSiteExtensions(projectRoot, temporary, options.extensions);
     const localizer = await createSiteLocalizer({ projectRoot, readers, marker, selected, byPath, resources });
-    await mkdir26(join72(temporary, "pages"), { recursive: true });
+    await mkdir26(join73(temporary, "pages"), { recursive: true });
     const primaryBody = (page, packageContent) => {
       let content3 = packageContent;
       if (page.package_path === "wikis/index.md" && typeof pkg.repoContentPage !== "object") {
@@ -89927,9 +89950,9 @@ ${titles ? `contextTitles: ${JSON.stringify(titles)}
 `;
     };
     for (const page of byPath.values()) {
-      const content3 = await readFile64(join72(root, page.package_path), "utf8");
+      const content3 = await readFile64(join73(root, page.package_path), "utf8");
       const localized = await localizer.page(page, primaryBody(page, content3));
-      await writeFile22(join72(temporary, page.site_path.replace(/\.html$/u, ".md")), `${pageFrontmatter(page, content3, localized.titles)}
+      await writeFile22(join73(temporary, page.site_path.replace(/\.html$/u, ".md")), `${pageFrontmatter(page, content3, localized.titles)}
 ${localized.body}`);
     }
     const themeSections = sections.map((section) => ({
@@ -89988,7 +90011,7 @@ ${localized.body}`);
         contextLocales: { primary: readers.primary, tags: readers.tags, labels: readers.labels, titles: readers.titles, preferenceKey: readers.preferenceKey }
       }
     };
-    await writeFile22(join72(configRoot, "config.mjs"), `const contextLocaleMarker = ${JSON.stringify(readers.translated ? marker : null)};
+    await writeFile22(join73(configRoot, "config.mjs"), `const contextLocaleMarker = ${JSON.stringify(readers.translated ? marker : null)};
 ` + `export default { ...${JSON.stringify(config)}, markdown: { ${siteMarkdownConfig} },
 ` + `  transformHtml: html => html.replace(/<script id="check-dark-mode">[\\s\\S]*?<\\/script>/u, "") };
 `);
@@ -90004,20 +90027,28 @@ ${localized.body}`);
       menu(lines, entries2, 0, tag);
       lines.push("", "</div>", "");
     };
-    await mkdir26(join72(temporary, "sections"), { recursive: true });
+    await mkdir26(join73(temporary, "sections"), { recursive: true });
     for (const section of sections) {
-      await writeFile22(join72(temporary, section.href.slice(1).replace(/\.html$/u, ".md")), localizer.variants((tag) => {
+      await writeFile22(join73(temporary, section.href.slice(1).replace(/\.html$/u, ".md")), localizer.variants((tag) => {
         const lines = [`# ${mdLabel(localizer.entryTitle(tag, section.entry))}`, "", '<div class="context-section-grid">', ""];
-        const groups = section.entries.filter((entry) => entry.children.length > 0);
-        const articles = section.entries.filter((entry) => entry.children.length === 0);
-        for (const group of groups) {
-          card(lines, group.href ? `[${mdLabel(localizer.entryTitle(tag, group))}](${group.href})` : mdLabel(localizer.entryTitle(tag, group)), group.children, tag);
-        }
-        if (groups.length === 0)
-          for (const article of articles)
-            card(lines, undefined, [article], tag);
-        else if (articles.length)
-          card(lines, undefined, articles, tag);
+        const grouped = section.entries.some((entry) => entry.children.length > 0);
+        let articles = [];
+        const flush = () => {
+          if (articles.length)
+            card(lines, undefined, articles, tag);
+          articles = [];
+        };
+        for (const entry of section.entries) {
+          if (entry.children.length === 0) {
+            articles.push(entry);
+            if (!grouped)
+              flush();
+            continue;
+          }
+          flush();
+          card(lines, entry.href ? `[${mdLabel(localizer.entryTitle(tag, entry))}](${entry.href})` : mdLabel(localizer.entryTitle(tag, entry)), entry.children, tag);
+        }
+        flush();
         lines.push("</div>");
         return lines.join(`
 `) + `
@@ -90037,12 +90068,12 @@ ${localized.body}`);
 ` : "";
     const homeHero = options.extensions?.slots?.banner === undefined ? `hero: ${JSON.stringify(hero)}
 ${heroActions}` : "";
-    await writeFile22(join72(temporary, "index.md"), `---
+    await writeFile22(join73(temporary, "index.md"), `---
 layout: home
 title: ${JSON.stringify(options.home?.title ?? options.title ?? pkg.name)}
 ${homeHero}---
 `);
-    await writeFile22(join72(temporary, "changelog.md"), `---
+    await writeFile22(join73(temporary, "changelog.md"), `---
 title: Changelog
 contextHistory: ${JSON.stringify(Buffer.from(JSON.stringify(history)).toString("base64"))}
 ---
@@ -90055,19 +90086,19 @@ contextHistory: ${JSON.stringify(Buffer.from(JSON.stringify(history)).toString("
       assetsPrefix: "resources/",
       articles: await Promise.all(llmsArticles(pkg, selected).map(async (article) => ({
         ...article,
-        content: await readFile64(join72(root, article.path), "utf8")
+        content: await readFile64(join73(root, article.path), "utf8")
       }))),
       ...structure ? { map: structure } : {}
     });
-    await writeLlmsDocuments(join72(temporary, "public"), llms, { utf8Bom: true });
-    await mkdir26(join72(temporary, "llms"), { recursive: true });
+    await writeLlmsDocuments(join73(temporary, "public"), llms, { utf8Bom: true });
+    await mkdir26(join73(temporary, "llms"), { recursive: true });
     let landingNavigation = llms.navigationMarkdown;
     for (const link of markdownReaderLinks(landingNavigation).reverse()) {
       if (!link.target.startsWith(base))
         continue;
       landingNavigation = landingNavigation.slice(0, link.start) + `[${link.label}](</${link.target.slice(base.length)}>)` + landingNavigation.slice(link.end);
     }
-    await writeFile22(join72(temporary, "llms/index.md"), `---
+    await writeFile22(join73(temporary, "llms/index.md"), `---
 title: LLM Docs
 ---
 
@@ -90077,9 +90108,9 @@ title: LLM Docs
 
 ` + landingNavigation);
     for (const path2 of resources) {
-      const destination = join72(temporary, "public/resources", path2);
-      await mkdir26(dirname33(destination), { recursive: true });
-      await cp(join72(root, path2), destination);
+      const destination = join73(temporary, "public/resources", path2);
+      await mkdir26(dirname34(destination), { recursive: true });
+      await cp(join73(root, path2), destination);
     }
     await compileSite(temporary, output);
     const originLinks = [...navigation.nav, ...navigation.more].filter((item) => item.origin).map((item) => item.link);
@@ -90111,11 +90142,11 @@ title: LLM Docs
       warnings: mapping.warnings
     }, null, 2) + `
 `;
-    const packageSiteMap = join72(projectRoot, pkg.outDir, "context-site-map.json");
-    const distributedSiteMap = join72(projectRoot, pkg.outDir, packageDistributionMetadataPath("context-site-map.json"));
-    await mkdir26(dirname33(distributedSiteMap), { recursive: true });
+    const packageSiteMap = join73(projectRoot, pkg.outDir, "context-site-map.json");
+    const distributedSiteMap = join73(projectRoot, pkg.outDir, packageDistributionMetadataPath("context-site-map.json"));
+    await mkdir26(dirname34(distributedSiteMap), { recursive: true });
     await Promise.all([
-      writeFile22(join72(output, "context-site-map.json"), siteMapContent),
+      writeFile22(join73(output, "context-site-map.json"), siteMapContent),
       writeFile22(packageSiteMap, siteMapContent),
       writeFile22(distributedSiteMap, siteMapContent)
     ]);
@@ -90144,13 +90175,22 @@ var init_packageSite2 = __esm(() => {
   init_packageSiteBranding();
   init_packageSiteExtensions();
   init_packageDistributionMetadata();
+  init_packageVersion();
   init_packageSiteLocales();
-  PACKAGE_SITE_VERSION = `vitepress-site-v50-light-shared-preferences:${createHash22("sha256").update(JSON.stringify([siteThemeVariables.toString(), siteMarkdownConfig, siteThemeCss, siteThemeScript, siteThemeLabels("zh"), siteThemeLabels("en")])).digest("hex")}`;
+  PACKAGE_SITE_VERSION = `vitepress-site-v50-light-shared-preferences:${createHash22("sha256").update(JSON.stringify([
+    readPackageVersion(),
+    siteThemeVariables.toString(),
+    siteMarkdownConfig,
+    siteThemeCss,
+    siteThemeScript,
+    siteThemeLabels("zh"),
+    siteThemeLabels("en")
+  ])).digest("hex")}`;
   require2 = createRequire5(import.meta.url);
 });
 
 // src/project/workspaceBuildVersion.ts
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 import { mkdir as mkdir27, writeFile as writeFile23 } from "node:fs/promises";
 async function workspaceVersionFingerprint(root) {
   return { version: await workspaceVersion(root), changelog: await readWorkspaceChangelog(root) };
@@ -90162,8 +90202,8 @@ async function writePackageVersion(projectRoot, output) {
       throw new TypeError(`Package template uses reserved version output ${path2}; rename that template output.`);
   }
   await mkdir27(output, { recursive: true });
-  await writeFile23(join73(output, "CHANGELOG.md"), renderChangelog(info.changelog));
-  await writeFile23(join73(output, "context-version.json"), JSON.stringify({ version: info.version }) + `
+  await writeFile23(join74(output, "CHANGELOG.md"), renderChangelog(info.changelog));
+  await writeFile23(join74(output, "context-version.json"), JSON.stringify({ version: info.version }) + `
 `);
 }
 var init_workspaceBuildVersion = __esm(() => {
@@ -90172,40 +90212,40 @@ var init_workspaceBuildVersion = __esm(() => {
 
 // src/project/packageBuildStage.ts
 import { mkdir as mkdir28, mkdtemp as mkdtemp3, readFile as readFile65, rename as rename9, rm as rm14, rmdir } from "node:fs/promises";
-import { dirname as dirname34, join as join74, relative as relative24 } from "node:path";
+import { dirname as dirname35, join as join75, relative as relative24 } from "node:path";
 async function withStagedPackageOutput(projectRoot, pkg, render) {
-  const tempRoot = join74(projectRoot, ".tmp");
+  const tempRoot = join75(projectRoot, ".tmp");
   await mkdir28(tempRoot, { recursive: true });
-  const stage = await mkdtemp3(join74(tempRoot, "package-build-"));
-  const stagedPackage = { ...pkg, outDir: relative24(projectRoot, join74(stage, pkg.name)) };
+  const stage = await mkdtemp3(join75(tempRoot, "package-build-"));
+  const stagedPackage = { ...pkg, outDir: relative24(projectRoot, join75(stage, pkg.name)) };
   try {
-    await mkdir28(join74(projectRoot, stagedPackage.outDir), { recursive: true });
+    await mkdir28(join75(projectRoot, stagedPackage.outDir), { recursive: true });
     const value = await render(stagedPackage);
     await validatePackageIndexLinks({ projectRoot, pkg: stagedPackage });
     const destinations = packageOutputDirs(pkg);
     const staged = packageOutputDirs(stagedPackage);
     for (const [index2, destination] of destinations.entries()) {
-      const target = join74(projectRoot, destination);
+      const target = join75(projectRoot, destination);
       const previous2 = await walkPackageFiles(target);
-      const next = await walkPackageFiles(join74(projectRoot, staged[index2]));
+      const next = await walkPackageFiles(join75(projectRoot, staged[index2]));
       const desired = new Set(next.map((file) => file.relPath));
       for (const file of previous2) {
         if (desired.has(file.relPath))
           continue;
         await rm14(file.absPath);
-        let directory = dirname34(file.absPath);
+        let directory = dirname35(file.absPath);
         while (directory !== target) {
           try {
             await rmdir(directory);
           } catch {
             break;
           }
-          directory = dirname34(directory);
+          directory = dirname35(directory);
         }
       }
       for (let offset2 = 0;offset2 < next.length; offset2 += 8) {
         const results = await Promise.allSettled(next.slice(offset2, offset2 + 8).map(async (file) => {
-          const output = join74(target, file.relPath);
+          const output = join75(target, file.relPath);
           const bytes = await readFile65(file.absPath);
           const old = await readFile65(output).catch((error) => {
             if (error.code === "ENOENT")
@@ -90214,7 +90254,7 @@ async function withStagedPackageOutput(projectRoot, pkg, render) {
           });
           if (old?.equals(bytes))
             return;
-          await mkdir28(dirname34(output), { recursive: true });
+          await mkdir28(dirname35(output), { recursive: true });
           await rename9(file.absPath, output);
         }));
         for (const result of results)
@@ -90453,7 +90493,7 @@ var init_newKnowledgePage = __esm(() => {
 
 // src/project/repoContentLinks.ts
 import { lstat as lstat14, mkdir as mkdir29, readdir as readdir18, readlink, symlink as symlink3, unlink as unlink2 } from "node:fs/promises";
-import { dirname as dirname35, join as join75, relative as relative25 } from "node:path";
+import { dirname as dirname36, join as join76, relative as relative25 } from "node:path";
 function repoContentLinksNeedRepair(results) {
   return results.some((item) => item.status === "missing" || item.status === "mismatch");
 }
@@ -90477,12 +90517,12 @@ async function inspectRepoContentLinks(projectRoot, repair = false) {
     return [{
       type: "repo-content",
       name: "repo-content.yaml",
-      path: join75(projectRoot, "repo-content.yaml"),
+      path: join76(projectRoot, "repo-content.yaml"),
       status: "invalid",
       message: `${error instanceof Error ? error.message : String(error)}. Correct the registry before repairing the view; existing links are unchanged.`
     }];
   }
-  const view = join75(registry2?.projectRoot ?? projectRoot, "repo-content");
+  const view = join76(registry2?.projectRoot ?? projectRoot, "repo-content");
   const viewInfo = await info(view);
   if (viewInfo && !viewInfo.isDirectory())
     return [{
@@ -90500,7 +90540,7 @@ async function inspectRepoContentLinks(projectRoot, repair = false) {
       return;
     for (const file of await readdir18(directory, { withFileTypes: true })) {
       const mount = prefix + file.name;
-      const path2 = join75(directory, file.name);
+      const path2 = join76(directory, file.name);
       if (file.isSymbolicLink() && !expected.has(mount)) {
         if (repair && !disabled)
           await unlink2(path2);
@@ -90516,13 +90556,13 @@ async function inspectRepoContentLinks(projectRoot, repair = false) {
     }
   }
   for (const entry of registry2?.entries ?? []) {
-    const path2 = join75(view, entry.mountPath);
+    const path2 = join76(view, entry.mountPath);
     const base = { type: "repo-content", name: entry.id, path: path2 };
     if (!await repoContentTargetExists(entry)) {
       results.push({ ...base, status: "target-missing", message: `Check the registered path ${entry.path}, sparse checkout, or a possible move; no content was restored.` });
       continue;
     }
-    const parent = dirname35(path2);
+    const parent = dirname36(path2);
     const parentInfo = parent === view ? viewInfo : await info(parent);
     if (parentInfo && !parentInfo.isDirectory()) {
       results.push({ ...base, status: "conflict", message: "View parent is not an ordinary directory." });
@@ -90577,11 +90617,11 @@ __export(exports_knowledgeUpdate, {
   beginKnowledgeUpdate: () => beginKnowledgeUpdate
 });
 import { readFile as readFile66 } from "node:fs/promises";
-import { join as join76 } from "node:path";
+import { join as join77 } from "node:path";
 async function readKnowledgeUpdate(projectRoot) {
   let value;
   try {
-    value = JSON.parse(await readFile66(join76(projectRoot, await revisionStoragePath(projectRoot)), "utf8"));
+    value = JSON.parse(await readFile66(join77(projectRoot, await revisionStoragePath(projectRoot)), "utf8"));
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
       return;
@@ -90642,7 +90682,7 @@ async function beginKnowledgeUpdate(projectRoot, value) {
       ...input.changes === undefined ? {} : { changes: input.changes }
     };
     const request = updateSchema.parse({ ...payload, revision: indexerProtocolDigest(payload) });
-    await atomicWriteFile(join76(projectRoot, await revisionStoragePath(projectRoot)), `${JSON.stringify(request)}
+    await atomicWriteFile(join77(projectRoot, await revisionStoragePath(projectRoot)), `${JSON.stringify(request)}
 `);
     return {
       outcome: "update-prepared",
@@ -90727,7 +90767,7 @@ async function completeKnowledgeUpdate(input) {
     if (input.new_topics.length && !input.structure_approved) {
       const { revision: _revision, ...rest } = request;
       const payload = { ...rest, structure_proposal: { decisions: input.decisions, scope_summary: input.scope_summary, new_topics: input.new_topics } };
-      await atomicWriteFile(join76(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify({ ...payload, revision: indexerProtocolDigest(payload) })}
+      await atomicWriteFile(join77(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify({ ...payload, revision: indexerProtocolDigest(payload) })}
 `);
       return { outcome: "structure-review-required" };
     }
@@ -90764,7 +90804,7 @@ async function completeUpdateStructureReview(input) {
     const { revision: _revision, structure_proposal: _proposal, ...rest } = request;
     const payload = { ...rest, changes: `${rest.changes ?? ""}
 Structure feedback: ${input.feedback}` };
-    await atomicWriteFile(join76(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify({ ...payload, revision: indexerProtocolDigest(payload) })}
+    await atomicWriteFile(join77(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify({ ...payload, revision: indexerProtocolDigest(payload) })}
 `);
     return { outcome: "structure-adjustment-required" };
   });
@@ -90827,9 +90867,9 @@ __export(exports_packageBuilder, {
   buildProjectPackages: () => buildProjectPackages
 });
 import { createHash as createHash23 } from "node:crypto";
-import { existsSync as existsSync18 } from "node:fs";
+import { existsSync as existsSync19 } from "node:fs";
 import { mkdir as mkdir30, readdir as readdir19, readFile as readFile67, rm as rm15, writeFile as writeFile24 } from "node:fs/promises";
-import { dirname as dirname36, join as join77, resolve as resolve27 } from "node:path";
+import { dirname as dirname37, join as join78, resolve as resolve27 } from "node:path";
 function packageAssetDeliverySummary(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     return;
@@ -90851,7 +90891,7 @@ function assertPackageOutputDir(pkg) {
 }
 function packageFingerprintPath(projectRoot, pkg) {
   assertSafeRenderedPath(`${pkg.name}.json`, "package fingerprint path");
-  return join77(projectRoot, PACKAGE_FINGERPRINT_ROOT, `${pkg.name}.json`);
+  return join78(projectRoot, PACKAGE_FINGERPRINT_ROOT, `${pkg.name}.json`);
 }
 async function listApprovedKnowledge(projectRoot) {
   const metadata = await readApprovedKnowledgeMetadataIndex(projectRoot);
@@ -90882,7 +90922,7 @@ function isDeprecatedKnowledge(content3) {
 async function listTemplateFiles(projectRoot, templatePath) {
   assertSafeRenderedPath(templatePath, "package template path");
   const templateRoot = resolve27(projectRoot, templatePath);
-  if (!existsSync18(templateRoot)) {
+  if (!existsSync19(templateRoot)) {
     throw new ContextError(ExitCode.WorkspaceStateError, `package template path is missing: ${templatePath}`, {
       category: ErrorCategory.WorkspaceStateInvalid,
       path: templatePath,
@@ -90957,7 +90997,7 @@ async function packageInputFingerprint(input) {
 }
 async function readPackageManifest(projectRoot, pkg) {
   const filePath2 = packageFingerprintPath(projectRoot, pkg);
-  if (!existsSync18(filePath2))
+  if (!existsSync19(filePath2))
     return null;
   try {
     const parsed = JSON.parse(await readFile67(filePath2, "utf8"));
@@ -90991,7 +91031,7 @@ async function readPackageManifest(projectRoot, pkg) {
 }
 async function writePackageFingerprint(input) {
   const filePath2 = packageFingerprintPath(input.projectRoot, input.pkg);
-  await mkdir30(dirname36(filePath2), { recursive: true });
+  await mkdir30(dirname37(filePath2), { recursive: true });
   await writeFile24(filePath2, `${JSON.stringify({
     package: input.pkg.name,
     kind: packageKind(input.pkg),
@@ -91007,12 +91047,12 @@ async function writePackageFingerprint(input) {
 `, "utf8");
 }
 async function removeOrphanPackageDirs(projectRoot, packages) {
-  const distRoot = join77(projectRoot, "dist");
-  if (!existsSync18(distRoot))
+  const distRoot = join78(projectRoot, "dist");
+  if (!existsSync19(distRoot))
     return;
   const declaredNames = new Set(packages.flatMap((pkg) => packageOutputDirs(pkg).map((path2) => path2.slice("dist/".length))));
   const entries2 = await readdir19(distRoot, { withFileTypes: true });
-  await Promise.all(entries2.filter((entry) => entry.isDirectory() && !declaredNames.has(entry.name)).map((entry) => rm15(join77(distRoot, entry.name), { recursive: true, force: true, maxRetries: 3, retryDelay: 100 })));
+  await Promise.all(entries2.filter((entry) => entry.isDirectory() && !declaredNames.has(entry.name)).map((entry) => rm15(join78(distRoot, entry.name), { recursive: true, force: true, maxRetries: 3, retryDelay: 100 })));
 }
 async function collectPackageFreshness(projectRoot, packages) {
   assertDistinctPackageOutputs(packages);
@@ -91021,8 +91061,8 @@ async function collectPackageFreshness(projectRoot, packages) {
     assertPackageOutputDir(pkg);
     const selected = selectPackageKnowledge(approved, pkg);
     assertSafeRenderedPath(pkg.template.path, "package template path");
-    const templateRoot = join77(projectRoot, pkg.template.path);
-    const templateExists = existsSync18(templateRoot);
+    const templateRoot = join78(projectRoot, pkg.template.path);
+    const templateExists = existsSync19(templateRoot);
     if (!templateExists) {
       throw new ContextError(ExitCode.WorkspaceStateError, `package template path is missing: ${pkg.template.path}`, {
         category: ErrorCategory.WorkspaceStateInvalid,
@@ -91257,19 +91297,19 @@ async function buildProjectPackagesInternal(projectRoot, options) {
       if (stagedPkg.kind === "package.llms") {
         const articles = await Promise.all(llmsArticles(stagedPkg, selected).map(async (article) => ({
           ...article,
-          content: await readFile67(join77(projectRoot, stagedPkg.outDir, article.path), "utf8")
+          content: await readFile67(join78(projectRoot, stagedPkg.outDir, article.path), "utf8")
         })));
-        await writeLlmsDocuments(join77(projectRoot, stagedPkg.outDir), buildLlmsDocuments({
+        await writeLlmsDocuments(join78(projectRoot, stagedPkg.outDir), buildLlmsDocuments({
           title: stagedPkg.name,
           articles,
           ...reading ? { map: reading } : {}
         }), { preserveIndex: true });
       }
-      await writePackageVersion(projectRoot, join77(projectRoot, stagedPkg.outDir));
+      await writePackageVersion(projectRoot, join78(projectRoot, stagedPkg.outDir));
       await writePackageSite({ projectRoot, pkg: stagedPkg, selected, ...siteUrl ? { siteUrl } : {}, ...reading ? { structure: reading } : {} });
       const linkWarnings = [
         ...writtenKnowledge2.linkWarnings,
-        ...await inspectPackageMarkdownDirectory(join77(projectRoot, stagedPkg.outDir))
+        ...await inspectPackageMarkdownDirectory(join78(projectRoot, stagedPkg.outDir))
       ];
       return { ...writtenKnowledge2, linkWarnings };
     });
@@ -91407,7 +91447,7 @@ var init_packageBuilder = __esm(() => {
   init_siteTranslation();
   init_approvedKnowledgeMetadata();
   import_yaml41 = __toESM(require_dist(), 1);
-  PACKAGE_FINGERPRINT_ROOT = join77(".tmp", "context-runtime", "packages");
+  PACKAGE_FINGERPRINT_ROOT = join78(".tmp", "context-runtime", "packages");
 });
 
 // src/project/taskRollback.ts
@@ -91418,7 +91458,7 @@ __export(exports_taskRollback, {
   finishTaskRollback: () => finishTaskRollback
 });
 import { readFile as readFile68 } from "node:fs/promises";
-import { join as join78 } from "node:path";
+import { join as join79 } from "node:path";
 async function readTaskRollback(projectRoot) {
   const raw = await readJsonMaybe(projectRoot, await revisionStoragePath(projectRoot));
   if (!raw || typeof raw !== "object" || !("protocol" in raw) || raw.protocol !== "context.task-rollback/v1")
@@ -91427,7 +91467,7 @@ async function readTaskRollback(projectRoot) {
 }
 async function contents(projectRoot, path2) {
   try {
-    return await readFile68(join78(projectRoot, path2), "utf8");
+    return await readFile68(join79(projectRoot, path2), "utf8");
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
       return;
@@ -91595,9 +91635,9 @@ __export(exports_close, {
   approvedStructureInputHashFor: () => approvedStructureInputHashFor,
   approvedKnowledgeInputHash: () => approvedKnowledgeInputHash
 });
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 import { mkdir as mkdir31, writeFile as writeFile25 } from "node:fs/promises";
-import { dirname as dirname37, join as join79 } from "node:path";
+import { dirname as dirname38, join as join80 } from "node:path";
 function parseFrontmatter4(content3) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/u.exec(content3);
   if (match?.[1] === undefined)
@@ -91669,8 +91709,8 @@ async function deriveApprovedStructure(projectRoot) {
 }
 async function writeApprovedStructureProjection(projectRoot) {
   const { inputHash, structure, compactFiles } = await deriveApprovedStructure(projectRoot);
-  const outputPath = join79(projectRoot, STRUCTURE_PATH4);
-  await mkdir31(dirname37(outputPath), { recursive: true });
+  const outputPath = join80(projectRoot, STRUCTURE_PATH4);
+  await mkdir31(dirname38(outputPath), { recursive: true });
   await writeFile25(outputPath, import_yaml42.default.stringify(structure), "utf8");
   await Promise.all(compactFiles.map((file) => writeFile25(file.absPath, file.content, "utf8")));
   return { inputHash, articles: structure.articles.length, structure: STRUCTURE_PATH4 };
@@ -91680,11 +91720,11 @@ function referencesReceipt() {
 }
 async function readProjectCloseStatus(projectRoot) {
   const approved = await approvedKnowledgeFiles(projectRoot);
-  const structurePath = join79(projectRoot, STRUCTURE_PATH4);
-  if (approved.length === 0 && !existsSync19(structurePath))
+  const structurePath = join80(projectRoot, STRUCTURE_PATH4);
+  if (approved.length === 0 && !existsSync20(structurePath))
     return { state: "missing", diagnostics: [] };
   const inputHash = await approvedKnowledgeInputHash(projectRoot);
-  if (!existsSync19(structurePath))
+  if (!existsSync20(structurePath))
     return { state: "missing", inputHash, diagnostics: [`close structure is missing: ${STRUCTURE_PATH4}`] };
   try {
     const parsed = await readApprovedStructureValue(projectRoot);
@@ -91737,8 +91777,8 @@ async function closeProjectWorkspace(projectRoot) {
         next: "Fix context verify errors, then rerun context close --format json."
       });
     }
-    const outputPath = join79(projectRoot, STRUCTURE_PATH4);
-    await mkdir31(dirname37(outputPath), { recursive: true });
+    const outputPath = join80(projectRoot, STRUCTURE_PATH4);
+    await mkdir31(dirname38(outputPath), { recursive: true });
     await writeFile25(outputPath, `${import_yaml42.default.stringify(structure)}`, "utf8");
     await Promise.all(compactFiles.map((file) => writeFile25(file.absPath, file.content, "utf8")));
     const { readTaskRollback: readTaskRollback2 } = await Promise.resolve().then(() => (init_taskRollback(), exports_taskRollback));
@@ -91814,7 +91854,7 @@ var init_close = __esm(() => {
   init_knowledgeAssetRepair();
   init_approvedKnowledgeMetadata();
   import_yaml42 = __toESM(require_dist(), 1);
-  STRUCTURE_PATH4 = join79(KNOWLEDGE_ROOT, "structure.yaml");
+  STRUCTURE_PATH4 = join80(KNOWLEDGE_ROOT, "structure.yaml");
 });
 
 // src/project/processedScopeStorage.ts
@@ -91826,7 +91866,7 @@ __export(exports_processedScopeStorage, {
   captureProcessedScopes: () => captureProcessedScopes
 });
 import { readFile as readFile69 } from "node:fs/promises";
-import { join as join80 } from "node:path";
+import { join as join81 } from "node:path";
 async function currentScopeSourceVersion(projectRoot, sourceRef) {
   if (sourceRef.startsWith("repo-content:"))
     return repoContentWorkingVersion(projectRoot, sourceRef);
@@ -91845,7 +91885,7 @@ async function currentScopeSourceVersion(projectRoot, sourceRef) {
     const version3 = entries3[0].ref;
     if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/u.test(version3))
       throw new TypeError("Processing requires a fixed commit, not a moving ref");
-    await assertPinnedSource(join80(projectRoot, entries3[0].materializedAt), version3);
+    await assertPinnedSource(join81(projectRoot, entries3[0].materializedAt), version3);
     return version3;
   }
   const entries2 = (type === "file" ? sources.files : type === "lark" ? sources.larks : []).filter((entry2) => entry2.id === name3 || entry2.name === name3);
@@ -91853,7 +91893,7 @@ async function currentScopeSourceVersion(projectRoot, sourceRef) {
     throw new TypeError(`Source must identify one registered document: ${sourceRef}`);
   const entry = entries2[0];
   const manifest = entry.snapshot?.manifest ?? `${entry.materializedAt}/manifest.json`;
-  return parseDocumentSnapshotForSource(JSON.parse(await readFile69(join80(projectRoot, manifest), "utf8")), entry.name).snapshot_hash;
+  return parseDocumentSnapshotForSource(JSON.parse(await readFile69(join81(projectRoot, manifest), "utf8")), entry.name).snapshot_hash;
 }
 async function captureProcessedScopes(projectRoot, requested) {
   const scopes = processedScopesSchema.parse(requested);
@@ -91887,7 +91927,7 @@ async function commitProcessedScopes(projectRoot, scopes) {
   const { articles } = await inspectSettledReferences(projectRoot, repoContent, scopes.map((scope2) => scope2.source_ref), settled);
   const { approvedStructureInputHashFor: approvedStructureInputHashFor2 } = await Promise.resolve().then(() => (init_close(), exports_close));
   const input_hash = structure.parsed.input_hash === await approvedStructureInputHashFor2(projectRoot, previous2) ? await approvedStructureInputHashFor2(projectRoot, articles) : structure.parsed.input_hash;
-  await atomicWriteFile(join80(projectRoot, structure.path), import_yaml43.default.stringify({ ...structure.parsed, input_hash, articles, processed_scopes: processed }));
+  await atomicWriteFile(join81(projectRoot, structure.path), import_yaml43.default.stringify({ ...structure.parsed, input_hash, articles, processed_scopes: processed }));
 }
 async function invalidateChangedProcessedRequirements(projectRoot, previous2, current2) {
   const targets = new Map(current2.map((requirement2) => [requirement2.id, indexerProtocolDigest(requirement2)]));
@@ -91901,7 +91941,7 @@ async function invalidateChangedProcessedRequirements(projectRoot, previous2, cu
   const retained = scopes.filter((scope2) => !changed.has(scope2.requirement_ref));
   if (retained.length === scopes.length)
     return;
-  await atomicWriteFile(join80(projectRoot, structure.path), import_yaml43.default.stringify({ ...structure.parsed, processed_scopes: retained }));
+  await atomicWriteFile(join81(projectRoot, structure.path), import_yaml43.default.stringify({ ...structure.parsed, processed_scopes: retained }));
 }
 var import_yaml43;
 var init_processedScopeStorage = __esm(() => {
@@ -92042,7 +92082,7 @@ __export(exports_approvedRevisionPrograms, {
 });
 import { execFile as execFile9 } from "node:child_process";
 import { promisify as promisify9 } from "node:util";
-import { extname as extname11, join as join81 } from "node:path";
+import { extname as extname11, join as join82 } from "node:path";
 import { createRequire as createRequire6 } from "node:module";
 import { pathToFileURL } from "node:url";
 async function prepareRevisionProgramBlocks(root, sourceRefs, scopes, references) {
@@ -92058,7 +92098,7 @@ async function prepareRevisionProgramBlocks(root, sourceRefs, scopes, references
     if (entries2.length !== 1)
       throw new TypeError(`Regeneration requires one registered source: ${source2}`);
     const entry = entries2[0];
-    const directory = join81(root, entry.materializedAt);
+    const directory = join82(root, entry.materializedAt);
     const paths = [...new Set(references.filter((reference2) => reference2.source_ref === source2).map((reference2) => reference2.locator.path))];
     if (!paths.length)
       continue;
@@ -92378,14 +92418,14 @@ __export(exports_knowledgeMaintenance, {
   advanceKnowledgeMaintenance: () => advanceKnowledgeMaintenance
 });
 import { readFile as readFile70, readdir as readdir20, rm as rm16 } from "node:fs/promises";
-import { join as join82 } from "node:path";
+import { join as join83 } from "node:path";
 async function deliveryDigest(root) {
-  const directory = join82(root, ".tmp/context-runtime/packages");
+  const directory = join83(root, ".tmp/context-runtime/packages");
   try {
     const files = (await readdir20(directory)).filter((name3) => name3.endsWith(".json")).sort();
     if (!files.length)
       return indexerProtocolDigest(null);
-    return indexerProtocolDigest(await Promise.all(files.map((name3) => readFile70(join82(directory, name3), "utf8"))));
+    return indexerProtocolDigest(await Promise.all(files.map((name3) => readFile70(join83(directory, name3), "utf8"))));
   } catch (error) {
     if (error.code === "ENOENT")
       return indexerProtocolDigest(null);
@@ -92484,7 +92524,7 @@ async function observeKnowledgeMaintenance(root) {
 async function maintenanceRevision(root) {
   const observed = await observeKnowledgeMaintenance(root);
   const localInputs = observed.state.active ? {
-    revision: await readFile70(join82(root, MAINTENANCE_ROOT, "revision.json"), "utf8").catch((error) => {
+    revision: await readFile70(join83(root, MAINTENANCE_ROOT, "revision.json"), "utf8").catch((error) => {
       if (error.code === "ENOENT")
         return null;
       throw error;
@@ -92561,7 +92601,7 @@ async function finishMaintenanceRevision(root, outcome = "completed") {
   outcome = state.active.completion_outcome;
   state.active.phase = "finishing";
   await saveMaintenance(root, state);
-  await rm16(join82(root, MAINTENANCE_ROOT, "revision.json"), { force: true });
+  await rm16(join83(root, MAINTENANCE_ROOT, "revision.json"), { force: true });
   state.completed.push({ id: state.active.input.id, input_digest: indexerProtocolDigest(state.active.input), outcome });
   delete state.active;
   await saveMaintenance(root, state);
@@ -92595,8 +92635,8 @@ async function discardMaintenanceDraft(root) {
   const owned = new Set([...request?.batch_candidates ?? [], ...request?.candidate ? [request.candidate] : []].map((item) => item.candidate_id));
   if (candidates.some((item) => !owned.has(item.candidate_id)))
     throw new TypeError("Unrelated Candidates are present; no draft was discarded. Inspect the current review before retrying cancellation.");
-  await rm16(join82(root, CANDIDATE_LEDGER_FILE), { force: true });
-  await rm16(join82(root, MAINTENANCE_ROOT, "revision.json"), { force: true });
+  await rm16(join83(root, CANDIDATE_LEDGER_FILE), { force: true });
+  await rm16(join83(root, MAINTENANCE_ROOT, "revision.json"), { force: true });
   const { closeProjectWorkspace: closeProjectWorkspace2 } = await Promise.resolve().then(() => (init_close(), exports_close));
   const { buildProjectPackages: buildProjectPackages2 } = await Promise.resolve().then(() => (init_packageBuilder(), exports_packageBuilder));
   await closeProjectWorkspace2(root);
@@ -92635,7 +92675,7 @@ __export(exports_approvedRevision, {
   APPROVED_REVISION_PATH: () => APPROVED_REVISION_PATH
 });
 import { readFile as readFile71, realpath as realpath11, rm as rm17 } from "node:fs/promises";
-import { join as join83, relative as relative26, isAbsolute as isAbsolute15 } from "node:path";
+import { join as join84, relative as relative26, isAbsolute as isAbsolute15 } from "node:path";
 function requestDigest(input) {
   const scopes = input.processed_scopes?.filter((scope2) => input.target.source_refs.some((ref2) => repoContentScopeMatches(scope2.source_ref, ref2) || ref2.startsWith(`${scope2.source_ref}#`) || ref2.startsWith(`${scope2.source_ref}/`)));
   const ids = new Set(scopes?.map((scope2) => scope2.requirement_ref));
@@ -92673,7 +92713,7 @@ function revisionCandidateFingerprint(revision, markdown, sections) {
 }
 async function readApprovedRevision(projectRoot) {
   try {
-    return parseApprovedRevision(JSON.parse(await readFile71(join83(projectRoot, await revisionStoragePath(projectRoot)), "utf8")));
+    return parseApprovedRevision(JSON.parse(await readFile71(join84(projectRoot, await revisionStoragePath(projectRoot)), "utf8")));
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
       return;
@@ -92732,12 +92772,12 @@ async function resolveApprovedRevisionAuthor(projectRoot, request) {
 }
 async function targetBytes(projectRoot, path2) {
   const project = await realpath11(projectRoot);
-  const root = await realpath11(join83(projectRoot, "knowledge"));
+  const root = await realpath11(join84(projectRoot, "knowledge"));
   const rootRelative = relative26(project, root);
   if (isAbsolute15(rootRelative) || rootRelative === ".." || rootRelative.startsWith("../")) {
     throw new TypeError("Approved knowledge directory leaves the Context workspace");
   }
-  const target = await realpath11(join83(root, path2));
+  const target = await realpath11(join84(root, path2));
   const rel = relative26(root, target);
   if (isAbsolute15(rel) || rel === ".." || rel.startsWith("../"))
     throw new TypeError("Approved revision target leaves knowledge/");
@@ -92893,7 +92933,7 @@ ${import_yaml44.default.stringify({ ...import_yaml44.default.parse(fields), type
       revision: requestDigest(payload)
     });
     if (input.persist !== false)
-      await atomicWriteFile(join83(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify(request)}
+      await atomicWriteFile(join84(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify(request)}
 `);
     return {
       status: "author-reopened",
@@ -93004,17 +93044,17 @@ async function completeApprovedRevision(input) {
       const { prepareRevisionBatchContinuation: prepareRevisionBatchContinuation3 } = await Promise.resolve().then(() => (init_approvedRevisionBatch(), exports_approvedRevisionBatch));
       const next2 = await prepareRevisionBatchContinuation3(input.projectRoot, request, request.batch_candidates ?? []);
       if (next2 || request.batch_candidates?.length || request.build_pending) {
-        await atomicWriteFile(join83(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify(next2 ?? { ...request, review_ready: true })}
+        await atomicWriteFile(join84(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify(next2 ?? { ...request, review_ready: true })}
 `);
       } else {
         await advanceApprovedRevision(input.projectRoot, request);
       }
       return;
     }
-    const current2 = await readFile71(join83(input.projectRoot, await revisionStoragePath(input.projectRoot)), "utf8");
+    const current2 = await readFile71(join84(input.projectRoot, await revisionStoragePath(input.projectRoot)), "utf8");
     let previous2;
     try {
-      previous2 = await readFile71(join83(input.projectRoot, CANDIDATE_LEDGER_FILE), "utf8");
+      previous2 = await readFile71(join84(input.projectRoot, CANDIDATE_LEDGER_FILE), "utf8");
     } catch (error) {
       if (!(error && typeof error === "object" && ("code" in error) && error.code === "ENOENT"))
         throw error;
@@ -93096,7 +93136,7 @@ async function advanceApprovedRevision(projectRoot, request, buildPending = fals
     return;
   const { readProductionStage: readProductionStage2 } = await Promise.resolve().then(() => (init_productionStageStore(), exports_productionStageStore));
   if (await readProductionStage2(projectRoot)) {
-    await rm17(join83(projectRoot, await revisionStoragePath(projectRoot)), { force: true });
+    await rm17(join84(projectRoot, await revisionStoragePath(projectRoot)), { force: true });
     return;
   }
   const { clearCompletedLifecycle: clearCompletedLifecycle2 } = await Promise.resolve().then(() => (init_lifecycleCleanup(), exports_lifecycleCleanup));
@@ -93167,12 +93207,12 @@ async function reopenApprovedRevision(input) {
         }))
       } : {}
     } };
-    const current2 = await readFile71(join83(input.projectRoot, await revisionStoragePath(input.projectRoot)), "utf8");
+    const current2 = await readFile71(join84(input.projectRoot, await revisionStoragePath(input.projectRoot)), "utf8");
     const content3 = `${JSON.stringify({ ...payload, revision: requestDigest(payload) })}
 `;
     let ledger;
     try {
-      ledger = await readFile71(join83(input.projectRoot, CANDIDATE_LEDGER_FILE), "utf8");
+      ledger = await readFile71(join84(input.projectRoot, CANDIDATE_LEDGER_FILE), "utf8");
     } catch (error) {
       if (!(error && typeof error === "object" && ("code" in error) && error.code === "ENOENT"))
         throw error;
@@ -93285,7 +93325,7 @@ var init_sourceInputMutation = __esm(() => {
 // src/project/documentCapture.ts
 import { createHash as createHash24 } from "node:crypto";
 import { mkdir as mkdir32, readdir as readdir21, readFile as readFile72, rm as rm18, stat as stat11, writeFile as writeFile26 } from "node:fs/promises";
-import { basename as basename8, dirname as dirname38, extname as extname12, join as join84, relative as relative27, resolve as resolve28 } from "node:path";
+import { basename as basename8, dirname as dirname39, extname as extname12, join as join85, relative as relative27, resolve as resolve28 } from "node:path";
 function toPosixPath7(path2) {
   return path2.split(/[\\/]+/u).filter((part) => part.length > 0).join("/");
 }
@@ -93408,7 +93448,7 @@ async function walkMarkdownFiles(input) {
   const visit3 = async (dir) => {
     const entries2 = await readdir21(dir, { withFileTypes: true });
     for (const entry of entries2) {
-      const absolutePath = join84(dir, entry.name);
+      const absolutePath = join85(dir, entry.name);
       if (entry.isDirectory()) {
         await visit3(absolutePath);
         continue;
@@ -93433,11 +93473,11 @@ async function writeTextIfChanged(path2, content3) {
     if (await readFile72(path2, "utf8") === content3)
       return;
   } catch {}
-  await mkdir32(dirname38(path2), { recursive: true });
+  await mkdir32(dirname39(path2), { recursive: true });
   await writeFile26(path2, content3, "utf8");
 }
 function sourceManifestPath(entry) {
-  return entry.snapshot?.manifest ?? join84(entry.materializedAt, "manifest.json");
+  return entry.snapshot?.manifest ?? join85(entry.materializedAt, "manifest.json");
 }
 function runtimeError3(message, detail) {
   return new ContextError(ExitCode.UserError, message, {
@@ -93510,7 +93550,7 @@ async function removeEmptySnapshotDirs(root, dir = root) {
   for (const entry of entries2) {
     if (!entry.isDirectory() || entry.name === ".tmp" || entry.name === ".cache")
       continue;
-    await removeEmptySnapshotDirs(root, join84(dir, entry.name));
+    await removeEmptySnapshotDirs(root, join85(dir, entry.name));
   }
   if (dir === root)
     return;
@@ -93522,7 +93562,7 @@ async function removeEmptySnapshotDirs(root, dir = root) {
 async function cleanupStaleSnapshotFiles(input) {
   for (const path2 of input.previousPaths) {
     if (!input.currentPaths.has(path2)) {
-      await rm18(join84(input.materializedAtAbsPath, path2), { force: true });
+      await rm18(join85(input.materializedAtAbsPath, path2), { force: true });
     }
   }
   await removeEmptySnapshotDirs(input.materializedAtAbsPath);
@@ -93705,9 +93745,9 @@ async function runCaptureFilePhaseUnlocked(input) {
     documentSnapshot
   });
   const manifestPath = sourceManifestPath(entry);
-  const manifestAbsPath = join84(input.projectRoot, manifestPath);
+  const manifestAbsPath = join85(input.projectRoot, manifestPath);
   const materializedAt = entry.materializedAt;
-  const materializedAtAbsPath = join84(input.projectRoot, materializedAt);
+  const materializedAtAbsPath = join85(input.projectRoot, materializedAt);
   const manifestInput = {
     sourceType: "file",
     sourceName: resolved.sourceName,
@@ -93757,13 +93797,13 @@ async function runCaptureFilePhaseUnlocked(input) {
   }));
   try {
     for (const file of snapshotFiles) {
-      await writeTextIfChanged(join84(materializedAtAbsPath, file.path), String(file.bytes));
+      await writeTextIfChanged(join85(materializedAtAbsPath, file.path), String(file.bytes));
     }
     for (const file of files.metadata) {
-      await writeTextIfChanged(join84(materializedAtAbsPath, file.snapshotPath), routeMetadata.rawByPath.get(file.snapshotPath) ?? "");
+      await writeTextIfChanged(join85(materializedAtAbsPath, file.snapshotPath), routeMetadata.rawByPath.get(file.snapshotPath) ?? "");
     }
     for (const asset of linkedAssets) {
-      await writeCaptureAssetIfChanged(join84(materializedAtAbsPath, asset.snapshotPath), asset.bytes);
+      await writeCaptureAssetIfChanged(join85(materializedAtAbsPath, asset.snapshotPath), asset.bytes);
     }
     await writeTextIfChanged(manifestAbsPath, manifestContent);
     await cleanupStaleSnapshotFiles({
@@ -93940,8 +93980,8 @@ var init_larkCaptureReport = __esm(() => {
 });
 
 // src/project/documentSnapshotFidelity.ts
-import { readFileSync as readFileSync7 } from "node:fs";
-import { join as join85 } from "node:path";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { join as join86 } from "node:path";
 function readDocumentSnapshotCaptureReport(input) {
   const summary = input.manifest.metadata?.capture?.report;
   if (summary === undefined)
@@ -93950,7 +93990,7 @@ function readDocumentSnapshotCaptureReport(input) {
   if (asset === undefined || asset.role !== "audit" || asset.content_hash === undefined) {
     throw new TypeError(`snapshot capture report is not registered as a hashed audit asset: ${summary.path}`);
   }
-  const bytes = readFileSync7(join85(input.projectRoot, input.materializedAt, summary.path));
+  const bytes = readFileSync8(join86(input.projectRoot, input.materializedAt, summary.path));
   if (computeDocumentContentHash(bytes) !== asset.content_hash) {
     throw new TypeError(`snapshot capture report hash does not match manifest: ${summary.path}`);
   }
@@ -94046,9 +94086,9 @@ function larkSnapshotIdentityDiagnostic(source2, manifest) {
 }
 
 // src/project/repoSourceModules.ts
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 import { readFile as readFile73, readdir as readdir22 } from "node:fs/promises";
-import { join as join86, resolve as resolve29 } from "node:path";
+import { join as join87, resolve as resolve29 } from "node:path";
 async function rootNames(root) {
   try {
     return (await readdir22(root)).sort();
@@ -94057,8 +94097,8 @@ async function rootNames(root) {
   }
 }
 async function packageEntries(root) {
-  const path2 = join86(root, "package.json");
-  if (!existsSync20(path2))
+  const path2 = join87(root, "package.json");
+  if (!existsSync21(path2))
     return [];
   try {
     const value = JSON.parse(await readFile73(path2, "utf8"));
@@ -94069,9 +94109,9 @@ async function packageEntries(root) {
   }
 }
 async function planningEvidence(inspectPath, module) {
-  const root = module.path === "." ? inspectPath : join86(inspectPath, module.path);
+  const root = module.path === "." ? inspectPath : join87(inspectPath, module.path);
   const names = await rootNames(root);
-  const commonEntries = ["src/index.ts", "src/index.tsx", "src/main.ts", "src/main.tsx", "main.go"].filter((path2) => existsSync20(join86(root, path2)));
+  const commonEntries = ["src/index.ts", "src/index.tsx", "src/main.ts", "src/main.tsx", "main.go"].filter((path2) => existsSync21(join87(root, path2)));
   const protocolNames = names.filter((name3) => /(?:openapi|swagger|schema|protocol|idl)/iu.test(name3) || /\.(?:proto|thrift)$/iu.test(name3));
   const lifecycleNames = names.filter((name3) => /(?:generated|vendor|mirror|legacy|sync)/iu.test(name3));
   return {
@@ -94109,8 +94149,8 @@ function suggestedModuleName(module) {
   return slug || "module";
 }
 async function inspectRepoSourceModules(input) {
-  const inspectPath = input.scopedAbs !== null && existsSync20(input.scopedAbs) ? input.scopedAbs : join86(input.projectRoot, input.status.materializedAt);
-  const modules = existsSync20(inspectPath) ? await detectModuleBoundaries(inspectPath, input.status.head ?? input.status.ref, DEFAULT_PATH_FILTER) : [];
+  const inspectPath = input.scopedAbs !== null && existsSync21(input.scopedAbs) ? input.scopedAbs : join87(input.projectRoot, input.status.materializedAt);
+  const modules = existsSync21(inspectPath) ? await detectModuleBoundaries(inspectPath, input.status.head ?? input.status.ref, DEFAULT_PATH_FILTER) : [];
   const recommended_sources = modules.filter((module) => module.path !== "." || modules.length === 1).map((module) => {
     const local = sourceModuleLocalForDisplay({ source: input.source, status: input.status, module });
     return {
@@ -94148,8 +94188,8 @@ var init_repoSourceModules = __esm(() => {
 });
 
 // src/project/repoSourceRegistry.ts
-import { existsSync as existsSync21 } from "node:fs";
-import { join as join87 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
+import { join as join88 } from "node:path";
 function assertRepoModuleName(name3) {
   if (!SOURCE_NAME_PATTERN2.test(name3)) {
     throw new ContextError(ExitCode.UserError, `repo source name must be a lowercase path-safe slug: ${name3}`, {
@@ -94200,14 +94240,14 @@ function registryEntryToRecord(entry) {
   };
 }
 function registryPath(projectRoot) {
-  return join87(projectRoot, DEFAULT_REPO_SOURCES_REGISTRY_PATH);
+  return join88(projectRoot, DEFAULT_REPO_SOURCES_REGISTRY_PATH);
 }
 function defaultRepoMaterializedAt(source2) {
   return `sources/repo/${source2.namespace}/${source2.module}`;
 }
 async function readRepoRegistry(projectRoot) {
   const path2 = registryPath(projectRoot);
-  if (!existsSync21(path2))
+  if (!existsSync22(path2))
     return { repos: [] };
   const registry2 = await loadSourcesRegistry({ rootDir: projectRoot });
   return {
@@ -94258,11 +94298,11 @@ var init_repoSourceRegistry = __esm(() => {
 });
 
 // src/project/repoSources.ts
-import { existsSync as existsSync22 } from "node:fs";
+import { existsSync as existsSync23 } from "node:fs";
 import { lstat as lstat15, mkdir as mkdir33, readFile as readFile74, readlink as readlink2, realpath as realpath12, rm as rm19, symlink as symlink4 } from "node:fs/promises";
 import { execFile as execFile10 } from "node:child_process";
 import { promisify as promisify10 } from "node:util";
-import { dirname as dirname39, isAbsolute as isAbsolute16, join as join88, relative as relative28, resolve as resolve30 } from "node:path";
+import { dirname as dirname40, isAbsolute as isAbsolute16, join as join89, relative as relative28, resolve as resolve30 } from "node:path";
 function nonEmpty(value) {
   if (value == null)
     return null;
@@ -94320,11 +94360,11 @@ async function localPathForRegistry(input) {
 async function inferNamedLocalPath(projectRoot, module) {
   const candidates = [
     resolve30(projectRoot, module),
-    resolve30(dirname39(projectRoot), module)
+    resolve30(dirname40(projectRoot), module)
   ];
   const matches = new Map;
   for (const candidate of candidates) {
-    if (!existsSync22(candidate))
+    if (!existsSync23(candidate))
       continue;
     const canonical = await realpath12(candidate).catch(() => null);
     if (canonical === null)
@@ -94345,13 +94385,13 @@ async function gitOutput(cwd, args) {
   }
 }
 async function readGitOriginRemote(cwd) {
-  const directConfigPath = join88(cwd, ".git", "config");
+  const directConfigPath = join89(cwd, ".git", "config");
   let config = await readFile74(directConfigPath, "utf8").catch(() => "");
   if (config.length === 0) {
     const gitDir = await resolveGitDir(cwd);
     if (gitDir === null)
       return null;
-    config = await readFile74(join88(gitDir, "config"), "utf8").catch(() => "");
+    config = await readFile74(join89(gitDir, "config"), "utf8").catch(() => "");
   }
   let inOriginBlock = false;
   for (const line of config.split(/\r?\n/u)) {
@@ -94371,17 +94411,17 @@ async function readGitOriginRemote(cwd) {
 async function resolveGitRoot(cwd) {
   let current2 = resolve30(cwd);
   while (true) {
-    if (existsSync22(join88(current2, ".git")))
+    if (existsSync23(join89(current2, ".git")))
       return current2;
-    const parent = dirname39(current2);
+    const parent = dirname40(current2);
     if (parent === current2)
       return null;
     current2 = parent;
   }
 }
 async function resolveGitDir(cwd) {
-  const dotGit = join88(cwd, ".git");
-  if (!existsSync22(dotGit))
+  const dotGit = join89(cwd, ".git");
+  if (!existsSync23(dotGit))
     return null;
   const stats = await lstat15(dotGit);
   if (stats.isDirectory())
@@ -94398,17 +94438,17 @@ async function readGitHead(cwd) {
   const gitDir = await resolveGitDir(cwd);
   if (gitDir === null)
     return null;
-  const headRaw = (await readFile74(join88(gitDir, "HEAD"), "utf8").catch(() => "")).trim();
+  const headRaw = (await readFile74(join89(gitDir, "HEAD"), "utf8").catch(() => "")).trim();
   if (/^[a-f0-9]{40}$/iu.test(headRaw))
     return headRaw.toLowerCase();
   const match = /^ref:\s*(.+)\s*$/iu.exec(headRaw);
   const refPath = match?.[1];
   if (refPath === undefined)
     return null;
-  const looseRef = (await readFile74(join88(gitDir, refPath), "utf8").catch(() => "")).trim();
+  const looseRef = (await readFile74(join89(gitDir, refPath), "utf8").catch(() => "")).trim();
   if (/^[a-f0-9]{40}$/iu.test(looseRef))
     return looseRef.toLowerCase();
-  const packedRefs = await readFile74(join88(gitDir, "packed-refs"), "utf8").catch(() => "");
+  const packedRefs = await readFile74(join89(gitDir, "packed-refs"), "utf8").catch(() => "");
   for (const line of packedRefs.split(/\r?\n/u)) {
     if (line.startsWith("#") || line.startsWith("^"))
       continue;
@@ -94419,27 +94459,27 @@ async function readGitHead(cwd) {
   return null;
 }
 async function ensureMaterializedSymlink(input) {
-  const linkPath = join88(input.projectRoot, input.materializedAt);
-  await mkdir33(dirname39(linkPath), { recursive: true });
-  if (existsSync22(linkPath)) {
+  const linkPath = join89(input.projectRoot, input.materializedAt);
+  await mkdir33(dirname40(linkPath), { recursive: true });
+  if (existsSync23(linkPath)) {
     const stats = await lstat15(linkPath);
     if (!stats.isSymbolicLink()) {
       input.diagnostics.push(`materialized path exists and is not a symlink: ${input.materializedAt}`);
       return false;
     }
     const current2 = await readlink2(linkPath);
-    const currentAbs = resolve30(dirname39(linkPath), current2);
+    const currentAbs = resolve30(dirname40(linkPath), current2);
     if (currentAbs === input.localAbs)
       return true;
     await rm19(linkPath);
   }
-  const relTarget = relative28(dirname39(linkPath), input.localAbs) || ".";
+  const relTarget = relative28(dirname40(linkPath), input.localAbs) || ".";
   await symlink4(relTarget, linkPath);
   return true;
 }
 async function diagnoseMaterializedSymlink(input) {
-  const linkPath = join88(input.projectRoot, input.materializedAt);
-  if (!existsSync22(linkPath)) {
+  const linkPath = join89(input.projectRoot, input.materializedAt);
+  if (!existsSync23(linkPath)) {
     input.diagnostics.push(`materialized path is missing: ${input.materializedAt}`);
     input.agent_hints.push(`Run context source ensure ${input.sourceName} to materialize the local source link.`);
     return false;
@@ -94450,9 +94490,9 @@ async function diagnoseMaterializedSymlink(input) {
     return false;
   }
   const current2 = await readlink2(linkPath);
-  const currentAbs = resolve30(dirname39(linkPath), current2);
+  const currentAbs = resolve30(dirname40(linkPath), current2);
   if (currentAbs !== input.localAbs) {
-    input.diagnostics.push(`materialized path points to ${current2}, expected local checkout ${relative28(dirname39(linkPath), input.localAbs) || "."}`);
+    input.diagnostics.push(`materialized path points to ${current2}, expected local checkout ${relative28(dirname40(linkPath), input.localAbs) || "."}`);
     input.agent_hints.push(`Run context source ensure ${input.sourceName} to refresh the local source link.`);
     return false;
   }
@@ -94484,7 +94524,7 @@ async function normalizeInputRef(input) {
       next: "Pass --local <path> with a git checkout, or use a full 40-character commit sha."
     });
   }
-  if (!existsSync22(localAbs)) {
+  if (!existsSync23(localAbs)) {
     throw new ContextError(ExitCode.UserError, `short repo source ref cannot be resolved because local path is missing: ${input.local}`, {
       category: ErrorCategory.UserInputInvalid,
       sourceName: input.sourceName,
@@ -94541,7 +94581,7 @@ async function normalizeAddInput(input, existing) {
   let originalLocalAbs = null;
   if (originalLocal !== undefined) {
     originalLocalAbs = resolveLocalPath(input.projectRoot, originalLocal);
-    if (originalLocalAbs !== null && existsSync22(originalLocalAbs)) {
+    if (originalLocalAbs !== null && existsSync23(originalLocalAbs)) {
       gitRootAbs = await resolveGitRoot(originalLocalAbs);
       if (gitRootAbs !== null && localWasResolvedFromInput) {
         const detectedSubpath = normalizeSubpath2(relative28(gitRootAbs, originalLocalAbs));
@@ -94561,7 +94601,7 @@ async function normalizeAddInput(input, existing) {
     localScoped: localWasResolvedFromInput && gitRootAbs !== null
   });
   if (input.local !== undefined && (explicitRemote === null || explicitRef === null)) {
-    if (originalLocalAbs === null || !existsSync22(originalLocalAbs)) {
+    if (originalLocalAbs === null || !existsSync23(originalLocalAbs)) {
       throw new ContextError(ExitCode.UserError, `repo source local path does not exist: ${input.local}`, {
         category: ErrorCategory.UserInputInvalid,
         sourceName,
@@ -94663,11 +94703,11 @@ async function inspectRepoSource(input) {
   const diagnostics = [];
   const agent_hints = [];
   const localAbs = resolveLocalPath(input.projectRoot, source2.local);
-  const localExists = localAbs !== null && existsSync22(localAbs);
+  const localExists = localAbs !== null && existsSync23(localAbs);
   const subpath = normalizeSubpath2(source2.subpath);
   const scopedAbs = localAbs === null ? null : scopedLocalPath(localAbs, subpath);
-  const scopeExists = scopedAbs !== null && existsSync22(scopedAbs);
-  let materialized = existsSync22(join88(input.projectRoot, materializedAt));
+  const scopeExists = scopedAbs !== null && existsSync23(scopedAbs);
+  let materialized = existsSync23(join89(input.projectRoot, materializedAt));
   const checkout = await inspectRepoCheckout({
     source: source2,
     localAbs,
@@ -94853,7 +94893,7 @@ var init_entityId = __esm(() => {
 // src/project/reviewShared.ts
 import { createHash as createHash25 } from "node:crypto";
 import { mkdir as mkdir34, writeFile as writeFile27 } from "node:fs/promises";
-import { dirname as dirname40, join as join89 } from "node:path";
+import { dirname as dirname41, join as join90 } from "node:path";
 function isRecord14(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -94896,7 +94936,7 @@ async function buildApprovedArticleIndex(projectRoot) {
     if (!isApprovedKnowledgeMarkdownPath(rel))
       continue;
     const { absPath, content: content3 } = file;
-    const relPath = join89("knowledge", collection, rel);
+    const relPath = join90("knowledge", collection, rel);
     assetReferencesByRelPath.set(relPath, knowledgeAssetReferences({
       pageRelPath: relPath,
       content: content3
@@ -94909,7 +94949,7 @@ async function buildApprovedArticleIndex(projectRoot) {
       continue;
     const frontmatter2 = hydrateApprovedFrontmatter({
       frontmatter: parsed,
-      relPath: join89(collection, rel),
+      relPath: join90(collection, rel),
       metadata
     });
     const article = articlesByPath.get(`${collection}/${rel}`);
@@ -94964,9 +95004,9 @@ ${yaml3}
 }
 async function writeReviewActionLog(input) {
   const stamp = new Date().toISOString().replace(/[-:.TZ]/gu, "");
-  const relPath = join89(REVIEW_ACTION_ROOT2, `${stamp}-${input.action}-${input.id.replace(/[\\/]+/gu, "_")}.json`);
-  const path2 = join89(input.projectRoot, relPath);
-  await mkdir34(dirname40(path2), { recursive: true });
+  const relPath = join90(REVIEW_ACTION_ROOT2, `${stamp}-${input.action}-${input.id.replace(/[\\/]+/gu, "_")}.json`);
+  const path2 = join90(input.projectRoot, relPath);
+  await mkdir34(dirname41(path2), { recursive: true });
   await writeFile27(path2, `${JSON.stringify({
     action: input.action,
     id: input.id,
@@ -94998,7 +95038,7 @@ var init_reviewShared = __esm(() => {
   init_knowledgeAssets();
   init_entityId();
   import_yaml46 = __toESM(require_dist(), 1);
-  REVIEW_ACTION_ROOT2 = join89(".tmp", "context-runtime", "review-actions");
+  REVIEW_ACTION_ROOT2 = join90(".tmp", "context-runtime", "review-actions");
 });
 
 // src/project/managedDocumentStatus.ts
@@ -95073,17 +95113,17 @@ __export(exports_statusReaders, {
   loadStatusPhases: () => loadStatusPhases,
   countFiles: () => countFiles
 });
-import { existsSync as existsSync23, readFileSync as readFileSync8 } from "node:fs";
-import { join as join90 } from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync9 } from "node:fs";
+import { join as join91 } from "node:path";
 async function countFiles(root, predicate) {
-  if (!existsSync23(root))
+  if (!existsSync24(root))
     return 0;
   let count = 0;
   const visit3 = async (dir, prefix = "") => {
     const entries2 = await readCommandDirectory(dir);
     for (const entry of entries2) {
       const rel = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
-      const abs = join90(dir, entry.name);
+      const abs = join91(dir, entry.name);
       if (entry.isDirectory())
         await visit3(abs, rel);
       else if (entry.isFile() && predicate(rel))
@@ -95274,8 +95314,8 @@ async function documentSourceSiteHint(input) {
   });
 }
 function documentSnapshotReadiness(input) {
-  const manifestPath = join90(input.projectRoot, input.manifest);
-  if (!existsSync23(manifestPath)) {
+  const manifestPath = join91(input.projectRoot, input.manifest);
+  if (!existsSync24(manifestPath)) {
     return {
       ready: false,
       diagnostics: [`snapshot is missing: ${input.manifest}`],
@@ -95283,7 +95323,7 @@ function documentSnapshotReadiness(input) {
     };
   }
   try {
-    const manifest = findDocumentSnapshotForSource(JSON.parse(readFileSync8(manifestPath, "utf8")), input.sourceName);
+    const manifest = findDocumentSnapshotForSource(JSON.parse(readFileSync9(manifestPath, "utf8")), input.sourceName);
     if (manifest === null) {
       return {
         ready: false,
@@ -95344,7 +95384,7 @@ function documentSnapshotReadiness(input) {
     const missingFiles = [
       ...manifest.files.map((file) => file.path),
       ...(manifest.assets ?? []).filter((asset) => asset.content_hash !== undefined).map((asset) => asset.path)
-    ].filter((path2) => !existsSync23(join90(input.projectRoot, input.materializedAt, path2)));
+    ].filter((path2) => !existsSync24(join91(input.projectRoot, input.materializedAt, path2)));
     if (missingFiles.length > 0) {
       return {
         ready: false,
@@ -95764,11 +95804,11 @@ var init_workflowHostPlans = __esm(() => {
 });
 
 // src/project/workflow/workflowProvider.ts
-import { existsSync as existsSync24 } from "node:fs";
-import { dirname as dirname41, resolve as resolve31 } from "node:path";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { existsSync as existsSync25 } from "node:fs";
+import { dirname as dirname42, resolve as resolve31 } from "node:path";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 function providerCandidates() {
-  const moduleDir2 = dirname41(fileURLToPath6(import.meta.url));
+  const moduleDir2 = dirname42(fileURLToPath7(import.meta.url));
   return [
     ...process.env.C4A_CONTEXT_WORKFLOW_PROVIDER ? [resolve31(process.env.C4A_CONTEXT_WORKFLOW_PROVIDER)] : [],
     resolve31(moduleDir2, "providers", "context", "manifest.json"),
@@ -95776,7 +95816,7 @@ function providerCandidates() {
   ];
 }
 function contextWorkflowProviderPath() {
-  const candidate = providerCandidates().find((path2) => existsSync24(path2));
+  const candidate = providerCandidates().find((path2) => existsSync25(path2));
   if (candidate === undefined) {
     throw new Error("Context workflow Provider is missing. Rebuild @c4a/context-cli or reinstall the published package.");
   }
@@ -96136,7 +96176,7 @@ var init_workflowProvider = __esm(() => {
 
 // src/project/productionStageRefresh.ts
 import { readFile as readFile76 } from "node:fs/promises";
-import { join as join92 } from "node:path";
+import { join as join93 } from "node:path";
 async function refreshProductionStageSources(projectRoot, stage) {
   const active = activeProductionSources(stage);
   const affected = new Set(stage.gaps.filter((gap) => active.has(gap.scope)).map((gap) => gap.scope));
@@ -96181,8 +96221,8 @@ Restore the authorized source and retry preparation.
     tasks: stage.tasks.map((task) => !["accepted", "excluded", "replaced"].includes(task.status) && task.sources.some((source2) => affected.has(source2.scope)) ? { ...task, status: "blocked", reason: "Source material refreshed; investigate and explicitly replace this unfinished task." } : task)
   });
   const directory = productionStageDirectory(stage.id);
-  const contents2 = new Map([...sourceMaterials].map(([scope2, content3]) => [join92(directory, productionSourceFile(scope2)), content3]));
-  contents2.set(join92(directory, "manifest.json"), `${JSON.stringify(updated)}
+  const contents2 = new Map([...sourceMaterials].map(([scope2, content3]) => [join93(directory, productionSourceFile(scope2)), content3]));
+  contents2.set(join93(directory, "manifest.json"), `${JSON.stringify(updated)}
 `);
   const targets = [];
   for (const [path2, content3] of contents2) {
@@ -96313,7 +96353,7 @@ var init_productionReport = __esm(() => {
 });
 
 // src/project/productionPlanningRoute.ts
-import { join as join93 } from "node:path";
+import { join as join94 } from "node:path";
 async function productionPlanningRoute(input, stage) {
   const request = stage ? undefined : await productionPlanningRequest(input.projectRoot);
   const present = !!stage || !!request;
@@ -96351,7 +96391,7 @@ async function productionPlanningRoute(input, stage) {
           id: `production/${stage.id}/planning`,
           kind: "context-view",
           media_type: "text/markdown",
-          path: join93(input.projectRoot, productionStageDirectory(stage.id), "planning.md"),
+          path: join94(input.projectRoot, productionStageDirectory(stage.id), "planning.md"),
           read_state: "read-required"
         }] : []
       ],
@@ -96378,8 +96418,8 @@ var init_productionPlanningRoute = __esm(() => {
 });
 
 // src/project/productionWorkflowRoute.ts
-import { existsSync as existsSync25 } from "node:fs";
-import { join as join94 } from "node:path";
+import { existsSync as existsSync26 } from "node:fs";
+import { join as join95 } from "node:path";
 async function productionWorkflowRoute(input) {
   const stage = await readProductionStage(input.projectRoot);
   if (!stage || !stage.planning_complete)
@@ -96397,7 +96437,7 @@ async function productionWorkflowRoute(input) {
   const selected = new Set(dispatch.batches.flatMap((batch) => batch.tasks));
   const context = { workspace: input.projectRoot, authorities: [...input.authorities], facts: { production: {
     report_approved: stage.report_approved,
-    prepared: !dispatch.batches.length || existsSync25(join94(input.projectRoot, directory, "stage.md")) && stage.tasks.filter((task) => selected.has(task.id)).every((task) => task.status === "issued"),
+    prepared: !dispatch.batches.length || existsSync26(join95(input.projectRoot, directory, "stage.md")) && stage.tasks.filter((task) => selected.has(task.id)).every((task) => task.status === "issued"),
     writing_complete: dispatch.batches.length === 0,
     complete: dispatch.state === "ended",
     review_clear: rejected.length === 0,
@@ -96414,7 +96454,7 @@ async function productionWorkflowRoute(input) {
   const resolved = await resolveRoute(provider, "indexer", "production", primary.routeId, context, evaluated.evaluation.revision);
   const report = resolved.node === "confirm-production-report";
   if (report)
-    await writeProductionProjection(input.projectRoot, join94(directory, "plan.md"), productionPlanMarkdown(stage));
+    await writeProductionProjection(input.projectRoot, join95(directory, "plan.md"), productionPlanMarkdown(stage));
   const prepare = resolved.node === "prepare-production-stage";
   const writing = resolved.node === "work-production-stage";
   const repair = resolved.node === "repair-production-articles";
@@ -96429,7 +96469,7 @@ async function productionWorkflowRoute(input) {
     id: `production/${stage.id}/${report ? "plan" : "stage"}`,
     kind: "context-view",
     media_type: "text/markdown",
-    path: join94(input.projectRoot, directory, path3),
+    path: join95(input.projectRoot, directory, path3),
     read_state: "read-required"
   });
   if (report || writing)
@@ -96440,18 +96480,18 @@ async function productionWorkflowRoute(input) {
       id: `production/${stage.id}/planning`,
       kind: "context-view",
       media_type: "text/markdown",
-      path: join94(input.projectRoot, directory, "planning.md"),
+      path: join95(input.projectRoot, directory, "planning.md"),
       read_state: "read-required"
     });
   }
   if (repair) {
-    await writeProductionProjection(input.projectRoot, join94(directory, "repair.md"), [
+    await writeProductionProjection(input.projectRoot, join95(directory, "repair.md"), [
       "# Revise rejected articles",
       "",
       ...rejected.map((candidate) => `- ${candidate.path}: ${candidate.review.title}`),
       "",
       "Use the user's Review feedback to add revision tasks for these article paths. Rejection does not cancel their planned responsibilities. Ask for missing feedback instead of guessing the reason.",
-      `Submit the plan amendment to ${path2} using ${join94(directory, "planning.schema.json")}. Keep accepted task identities unchanged; the CLI assigns the revision tasks and preserves article identities.`,
+      `Submit the plan amendment to ${path2} using ${join95(directory, "planning.schema.json")}. Keep accepted task identities unchanged; the CLI assigns the revision tasks and preserves article identities.`,
       "Once issued, repair the affected sections through the existing edits submission. Unchanged sections and references do not need resubmission.",
       ""
     ].join(`
@@ -96460,7 +96500,7 @@ async function productionWorkflowRoute(input) {
       id: `production/${stage.id}/repair`,
       kind: "context-view",
       media_type: "text/markdown",
-      path: join94(input.projectRoot, directory, "repair.md"),
+      path: join95(input.projectRoot, directory, "repair.md"),
       read_state: "read-required"
     });
   }
@@ -101380,7 +101420,7 @@ var init_larkResourceCommand = __esm(() => {
 
 // src/lib/larkMediaDownload.ts
 import { readdir as readdir24, rm as rm21 } from "node:fs/promises";
-import { join as join104 } from "node:path";
+import { join as join105 } from "node:path";
 async function downloadLarkMedia(input) {
   const shared = ["--as", input.identity, "--token", input.token, "--output", "./resource", "--format", "json"];
   try {
@@ -101390,7 +101430,7 @@ async function downloadLarkMedia(input) {
     if (!input.allowPreview || !isLarkResourcePermissionDenied(error))
       throw error;
     for (const entry of await readdir24(input.cwd))
-      await rm21(join104(input.cwd, entry), { recursive: true, force: true });
+      await rm21(join105(input.cwd, entry), { recursive: true, force: true });
     await runLarkResourceCommand(input.runner, ["docs", "+media-preview", ...shared], { cwd: input.cwd });
     return "preview";
   }
@@ -101402,7 +101442,7 @@ var init_larkMediaDownload = __esm(() => {
 // src/lib/larkWhiteboardExport.ts
 import { mkdtemp as mkdtemp4, readFile as readFile84, rm as rm22 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join105 } from "node:path";
+import { join as join106 } from "node:path";
 function stableJson2(value) {
   if (value === undefined)
     return "null";
@@ -101432,7 +101472,7 @@ function canonicalWhiteboardPayload(value) {
   };
 }
 async function exportLarkWhiteboardRaw(runner2, identity2, token) {
-  const tempRoot = await mkdtemp4(join105(tmpdir(), "context-lark-whiteboard-"));
+  const tempRoot = await mkdtemp4(join106(tmpdir(), "context-lark-whiteboard-"));
   try {
     await runLarkResourceCommand(runner2, [
       "whiteboard",
@@ -101449,7 +101489,7 @@ async function exportLarkWhiteboardRaw(runner2, identity2, token) {
       "--format",
       "json"
     ], { cwd: tempRoot });
-    const rawPayload = JSON.parse(await readFile84(join105(tempRoot, "raw.json"), "utf8"));
+    const rawPayload = JSON.parse(await readFile84(join106(tempRoot, "raw.json"), "utf8"));
     return Buffer.from(`${stableJson2(canonicalWhiteboardPayload(rawPayload))}
 `, "utf8");
   } finally {
@@ -101489,7 +101529,7 @@ var init_larkImagePolicy = __esm(() => {
 // src/lib/larkResourceMaterialization.ts
 import { createHash as createHash31 } from "node:crypto";
 import { mkdtemp as mkdtemp5, readFile as readFile85, readdir as readdir25, rm as rm23 } from "node:fs/promises";
-import { extname as extname13, join as join106 } from "node:path";
+import { extname as extname13, join as join107 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 function countByKind(items, status) {
   const counts2 = new Map;
@@ -101597,14 +101637,14 @@ async function downloadedFile(input) {
     const bytes = await readFile85(input.localPath);
     return { path: input.localPath, bytes, mediaType: mediaTypeFor(input.localPath, bytes), representation: "original" };
   }
-  const tempRoot = await mkdtemp5(join106(tmpdir2(), "context-lark-resource-"));
+  const tempRoot = await mkdtemp5(join107(tmpdir2(), "context-lark-resource-"));
   try {
     const representation = await downloadLarkMedia({ ...input, cwd: tempRoot });
     const entries2 = (await readdir25(tempRoot, { withFileTypes: true })).filter((entry) => entry.isFile());
     if (entries2.length !== 1)
       throw new Error(`media download produced ${entries2.length} files, expected exactly one`);
     const path3 = entries2[0]?.name ?? "resource.bin";
-    const bytes = await readFile85(join106(tempRoot, path3));
+    const bytes = await readFile85(join107(tempRoot, path3));
     return { path: path3, bytes, mediaType: mediaTypeFor(path3, bytes), representation };
   } finally {
     await rm23(tempRoot, { recursive: true, force: true });
@@ -101676,9 +101716,9 @@ async function sheetMaterialization(resource, runner2, identity2) {
   const sheetId = resource.attributes["sheet-id"];
   if (token === undefined || sheetId === undefined)
     throw new Error("embedded Sheet requires token and sheet-id");
-  const tempRoot = await mkdtemp5(join106(tmpdir2(), "context-lark-sheet-"));
+  const tempRoot = await mkdtemp5(join107(tmpdir2(), "context-lark-sheet-"));
   try {
-    const outputPath = join106(tempRoot, "sheet.json");
+    const outputPath = join107(tempRoot, "sheet.json");
     const stdout = await runLarkResourceCommand(runner2, [
       "sheets",
       "+csv-get",
@@ -102814,7 +102854,7 @@ var init_sensitiveSourceLiteral = __esm(() => {
 // src/project/larkSnapshotBundle.ts
 import { createHash as createHash32 } from "node:crypto";
 import { lstat as lstat16, mkdir as mkdir37, readFile as readFile86, realpath as realpath13, rename as rename10, writeFile as writeFile29 } from "node:fs/promises";
-import { basename as basename10, dirname as dirname43, isAbsolute as isAbsolute19, join as join107, relative as relative29, resolve as resolve34, sep as sep10 } from "node:path";
+import { basename as basename10, dirname as dirname44, isAbsolute as isAbsolute19, join as join108, relative as relative29, resolve as resolve34, sep as sep10 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 function normalizedSnapshotResourcePolicy(policy) {
   return { ...policy, images: policy.images ?? "bundle", gifs: policy.gifs ?? "bundle" };
@@ -102855,7 +102895,7 @@ async function readFileEntry(root2, entry) {
   const parts = safePath(entry.path).split("/");
   let current2 = root2;
   for (const [index2, part] of parts.entries()) {
-    current2 = join107(current2, part);
+    current2 = join108(current2, part);
     const stat12 = await lstat16(current2);
     if (stat12.isSymbolicLink() || (index2 === parts.length - 1 ? !stat12.isFile() : !stat12.isDirectory())) {
       throw larkSnapshotError(`Snapshot entry is not a regular file: ${entry.path}`, "path-invalid");
@@ -102924,13 +102964,13 @@ async function writeLarkSnapshotBundle(input) {
   };
   schema2.parse(manifest);
   for (const [path3, bytes] of files) {
-    await mkdir37(dirname43(join107(root2, path3)), { recursive: true });
-    await writeFile29(join107(root2, path3), bytes, { flag: "wx", mode: 384 });
+    await mkdir37(dirname44(join108(root2, path3)), { recursive: true });
+    await writeFile29(join108(root2, path3), bytes, { flag: "wx", mode: 384 });
   }
   await validateBundle(root2, manifest);
-  await writeFile29(join107(root2, `${FILE2}.pending`), `${JSON.stringify(manifest, null, 2)}
+  await writeFile29(join108(root2, `${FILE2}.pending`), `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx", mode: 384 });
-  await rename10(join107(root2, `${FILE2}.pending`), join107(root2, FILE2));
+  await rename10(join108(root2, `${FILE2}.pending`), join108(root2, FILE2));
   return manifest;
 }
 async function validateBundle(root2, manifest) {
@@ -103003,7 +103043,7 @@ async function validateBundle(root2, manifest) {
 async function readLarkSnapshotBundle(directory, target) {
   try {
     const root2 = await assertSnapshotDirectory(directory);
-    const path3 = join107(root2, FILE2);
+    const path3 = join108(root2, FILE2);
     const stat12 = await lstat16(path3);
     if (stat12.isSymbolicLink() || !stat12.isFile())
       throw larkSnapshotError("Snapshot receipt must be a regular file", "path-invalid");
@@ -103018,7 +103058,7 @@ async function readLarkSnapshotBundle(directory, target) {
 }
 async function reserveSnapshotDirectory(directory, workspaceRoot) {
   const requested = resolve34(directory);
-  let ancestor = dirname43(requested);
+  let ancestor = dirname44(requested);
   const missing2 = [];
   while (true) {
     try {
@@ -103028,11 +103068,11 @@ async function reserveSnapshotDirectory(directory, workspaceRoot) {
       if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
         throw error;
       missing2.unshift(basename10(ancestor));
-      ancestor = dirname43(ancestor);
+      ancestor = dirname44(ancestor);
     }
   }
-  const parent = join107(ancestor, ...missing2);
-  const output = join107(parent, basename10(requested));
+  const parent = join108(ancestor, ...missing2);
+  const output = join108(parent, basename10(requested));
   const { findContextProjectRoot: findContextProjectRoot2 } = await Promise.resolve().then(() => (init_workspace(), exports_workspace));
   const owner = findContextProjectRoot2(parent)?.projectRoot ?? workspaceRoot;
   if (owner !== undefined) {
@@ -103106,7 +103146,7 @@ var init_larkSnapshotBundle = __esm(() => {
 
 // src/project/documentCaptureLark.ts
 import { readdir as readdir26, readFile as readFile87 } from "node:fs/promises";
-import { basename as basename11, extname as extname14, join as join108 } from "node:path";
+import { basename as basename11, extname as extname14, join as join109 } from "node:path";
 function titleFromMarkdown2(markdown, fallbackPath) {
   const heading2 = markdown.split(`
 `).find((line) => /^#\s+\S/u.test(line));
@@ -103133,7 +103173,7 @@ async function fileContentMatches(path3, content3) {
   }
 }
 function sourceManifestPath2(entry) {
-  return entry.snapshot?.manifest ?? join108(entry.materializedAt, "manifest.json");
+  return entry.snapshot?.manifest ?? join109(entry.materializedAt, "manifest.json");
 }
 function larkRuntimeError(message, detail) {
   return new ContextError(ExitCode.ExternalToolError, message, {
@@ -103260,7 +103300,7 @@ function assetManifestEntry(asset, assetRoot) {
   };
 }
 async function listSnapshotAssetFiles(root2, assetRoot) {
-  const assetsRoot = join108(root2, assetRoot);
+  const assetsRoot = join109(root2, assetRoot);
   const files = [];
   const visit4 = async (dir, prefix = assetRoot) => {
     let entries2;
@@ -103273,7 +103313,7 @@ async function listSnapshotAssetFiles(root2, assetRoot) {
     }
     for (const entry of entries2) {
       const relPath = `${prefix}/${entry.name}`;
-      const absolutePath = join108(dir, entry.name);
+      const absolutePath = join109(dir, entry.name);
       if (entry.isDirectory()) {
         await visit4(absolutePath, relPath);
         continue;
@@ -103288,7 +103328,7 @@ async function listSnapshotAssetFiles(root2, assetRoot) {
 }
 async function staleSnapshotAssetPaths(input) {
   const existingPaths = await listSnapshotAssetFiles(input.materializedAtAbsPath, input.assetRoot);
-  return existingPaths.filter((path3) => !input.currentPaths.has(path3)).map((path3) => join108(input.materializedAtAbsPath, path3));
+  return existingPaths.filter((path3) => !input.currentPaths.has(path3)).map((path3) => join109(input.materializedAtAbsPath, path3));
 }
 function normalizeLarkError(error, sourceName) {
   if (error instanceof ContextError)
@@ -103409,9 +103449,9 @@ async function runCaptureLarkPhaseUnlocked(input) {
     locator
   }];
   const manifestPath = sourceManifestPath2(entry);
-  const manifestAbsPath = join108(input.projectRoot, manifestPath);
+  const manifestAbsPath = join109(input.projectRoot, manifestPath);
   const materializedAt = entry.materializedAt;
-  const materializedAtAbsPath = join108(input.projectRoot, materializedAt);
+  const materializedAtAbsPath = join109(input.projectRoot, materializedAt);
   const manifest = createDocumentSnapshotManifest({
     sourceType: "lark",
     sourceName: resolved.sourceName,
@@ -103445,13 +103485,13 @@ async function runCaptureLarkPhaseUnlocked(input) {
   }));
   try {
     const requestedWrites = [{
-      path: join108(materializedAtAbsPath, documentPath),
+      path: join109(materializedAtAbsPath, documentPath),
       bytes: normalized
     }];
     for (const asset of assets) {
       if (asset.bytes !== undefined) {
         requestedWrites.push({
-          path: join108(materializedAtAbsPath, asset.entry.path),
+          path: join109(materializedAtAbsPath, asset.entry.path),
           bytes: asset.bytes
         });
       }
@@ -103468,7 +103508,7 @@ async function runCaptureLarkPhaseUnlocked(input) {
       currentPaths: new Set(assets.filter((asset) => asset.bytes !== undefined).map((asset) => asset.entry.path))
     });
     await applyAtomicFileBatch({
-      transactionRoot: join108(input.projectRoot, ".tmp", "context-runtime", "capture-transactions"),
+      transactionRoot: join109(input.projectRoot, ".tmp", "context-runtime", "capture-transactions"),
       writes,
       removals
     });
@@ -103575,7 +103615,7 @@ __export(exports_actionInputWorkspace, {
   assertActionInputWorkspace: () => assertActionInputWorkspace
 });
 import { realpathSync as realpathSync2 } from "node:fs";
-import { dirname as dirname45, resolve as resolve36 } from "node:path";
+import { dirname as dirname46, resolve as resolve36 } from "node:path";
 function assertActionInputWorkspace(cwd, inputPath) {
   if (inputPath === "-")
     return;
@@ -103588,7 +103628,7 @@ function assertActionInputWorkspace(cwd, inputPath) {
   } catch {
     return;
   }
-  const owner = findContextProjectRoot(dirname45(file));
+  const owner = findContextProjectRoot(dirname46(file));
   if (owner === null || realpathSync2(owner.projectRoot) === realpathSync2(current2.projectRoot))
     return;
   throw new ContextError(ExitCode.WorkspaceStateError, "The completion input belongs to a different Context workspace. Run the workflow CLI and read/write this task's .tmp files in the same intended workspace. No tasks were submitted.", {
@@ -103902,7 +103942,7 @@ __export(exports_writeLockRecovery, {
   inspectWriterLock: () => inspectWriterLock
 });
 import { lstat as lstat17, mkdir as mkdir39, readFile as readFile94, readdir as readdir28, rename as rename11, rmdir as rmdir2 } from "node:fs/promises";
-import { join as join113 } from "node:path";
+import { join as join114 } from "node:path";
 import { createHash as createHash34, randomUUID as randomUUID8 } from "node:crypto";
 async function inspectWriterLock(root2) {
   const path3 = await safeProjectTarget(root2, lockRelative);
@@ -103949,8 +103989,8 @@ async function recoverWriterLock(input) {
     };
   if (input.plan_digest !== before.digest)
     throw new Error("Writer lock changed; preview recovery again.");
-  const path3 = join113(input.projectRoot, lockRelative);
-  const guard = join113(path3, ".recovery");
+  const path3 = join114(input.projectRoot, lockRelative);
+  const guard = join114(path3, ".recovery");
   await mkdir39(guard);
   let archived = false;
   try {
@@ -103961,7 +104001,7 @@ async function recoverWriterLock(input) {
     if (names.some((name3) => name3 !== "owner.json" && name3 !== ".recovery"))
       throw new Error("Unexpected lock contents; preserve for diagnosis.");
     const archive = `.tmp/context-runtime/locks/recovered-write-${randomUUID8()}.lock`;
-    await rename11(path3, join113(input.projectRoot, archive));
+    await rename11(path3, join114(input.projectRoot, archive));
     archived = true;
     return { action: "writer-lock-recovered", archived_lock: archive, next: "context task recover --format json" };
   } finally {
@@ -103984,8 +104024,8 @@ __export(exports_taskRecovery, {
   TRANSACTIONS_PATH: () => TRANSACTIONS_PATH,
   RECOVERY_COMMAND: () => RECOVERY_COMMAND
 });
-import { existsSync as existsSync27 } from "node:fs";
-import { dirname as dirname46, join as join114 } from "node:path";
+import { existsSync as existsSync28 } from "node:fs";
+import { dirname as dirname47, join as join115 } from "node:path";
 import { lstat as lstat18, readdir as readdir29, readFile as readFile95 } from "node:fs/promises";
 async function recoveryText(root2, path3) {
   const target = await safeProjectTarget(root2, path3);
@@ -104003,7 +104043,7 @@ async function recoveryJournals(root2) {
     await safeProjectTarget(root2, path3);
     let stat12;
     try {
-      stat12 = await lstat18(join114(root2, path3));
+      stat12 = await lstat18(join115(root2, path3));
     } catch (error) {
       if (error.code === "ENOENT")
         return;
@@ -104014,7 +104054,7 @@ async function recoveryJournals(root2) {
     if (stat12.isDirectory()) {
       if (depth > 3)
         throw new TypeError("Unexpected transaction directory depth; preserve it for diagnosis.");
-      for (const name3 of (await readdir29(join114(root2, path3))).sort())
+      for (const name3 of (await readdir29(join115(root2, path3))).sort())
         await visit4(`${path3}/${name3}`, depth + 1);
     } else if (stat12.isFile())
       entries2.push({ path: path3, digest: indexerProtocolDigest(await recoveryText(root2, path3)) });
@@ -104024,12 +104064,12 @@ async function recoveryJournals(root2) {
 }
 function recoveryResources() {
   try {
-    const root2 = dirname46(contextWorkflowProviderPath());
+    const root2 = dirname47(contextWorkflowProviderPath());
     const resources = {
-      skill: join114(root2, "skills/recover-workspace/SKILL.md"),
-      issue_template: join114(root2, "resources/templates/recovery-issue.md")
+      skill: join115(root2, "skills/recover-workspace/SKILL.md"),
+      issue_template: join115(root2, "resources/templates/recovery-issue.md")
     };
-    if (!Object.values(resources).every((path3) => existsSync27(path3)))
+    if (!Object.values(resources).every((path3) => existsSync28(path3)))
       throw new Error("Recovery resources are absent from this Provider.");
     return resources;
   } catch {
@@ -104113,7 +104153,7 @@ __export(exports_taskLocalSourceAdjustment, {
   adjustLocalRevisionSources: () => adjustLocalRevisionSources
 });
 import { readFile as readFile96 } from "node:fs/promises";
-import { join as join115 } from "node:path";
+import { join as join116 } from "node:path";
 async function adjustLocalRevisionSources(root2, input) {
   const { readMaintenance: readMaintenance2 } = await Promise.resolve().then(() => (init_maintenanceStorage(), exports_maintenanceStorage));
   if ((await readMaintenance2(root2)).active && await readProductionStage(root2))
@@ -104156,7 +104196,7 @@ async function adjustLocalRevisionSources(root2, input) {
   if (input.refresh && (!current2.refresh_sources || indexerProtocolDigest([...current2.refresh_sources].sort()) !== indexerProtocolDigest([...selected].sort()))) {
     throw new TypeError("No matching acquisition adjustment exists. Run task adjust without refresh first.");
   }
-  const raw = await readFile96(join115(root2, await revisionStoragePath(root2)), "utf8");
+  const raw = await readFile96(join116(root2, await revisionStoragePath(root2)), "utf8");
   let next2;
   const discardIds = new Set;
   if (!input.refresh) {
@@ -104271,7 +104311,7 @@ ${input.instruction}` : revision.instruction
     content: content3
   }];
   if (discardIds.size > 0) {
-    const ledger = await readFile96(join115(root2, CANDIDATE_LEDGER_FILE), "utf8").catch((error) => {
+    const ledger = await readFile96(join116(root2, CANDIDATE_LEDGER_FILE), "utf8").catch((error) => {
       if (error.code === "ENOENT")
         return;
       throw error;
@@ -104768,7 +104808,7 @@ init_dist();
 init_cliFeedback();
 init_errors3();
 init_exitCode();
-import { join as join102 } from "node:path";
+import { join as join103 } from "node:path";
 
 // src/project/documentCaptureAvailability.ts
 init_atomicFileBatch();
@@ -104777,11 +104817,11 @@ init_documentRun();
 init_writeLock();
 import { createHash as createHash26 } from "node:crypto";
 import { readFile as readFile75, rm as rm20 } from "node:fs/promises";
-import { join as join91 } from "node:path";
+import { join as join92 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 function receiptPath(root, phaseId) {
   const key = createHash26("sha256").update(phaseId).digest("hex");
-  return join91(root, ".tmp/context-runtime/document-acquisition", `${key}.json`);
+  return join92(root, ".tmp/context-runtime/document-acquisition", `${key}.json`);
 }
 async function identity(root, phase) {
   const resolved = await resolveDocumentPhaseSource({ projectRoot: root, phase });
@@ -104813,7 +104853,7 @@ async function runDocumentCaptureWithAvailability(root, phase, capture2) {
         retry_command: `context run ${phase.id}`,
         message: source2.snapshotReady ? "Document refresh unavailable. Retain the validated registered snapshot; it is not confirmed current upstream." : "Document acquisition unavailable. Keep this source registered as a pending evidence gap; do not cite it or invent content. Unrelated work may continue."
       };
-      await applyAtomicFileBatch({ transactionRoot: join91(root, ".tmp/context-runtime/transactions"), writes: [{ path: path2, bytes: `${JSON.stringify({ configuration, warning }, null, 2)}
+      await applyAtomicFileBatch({ transactionRoot: join92(root, ".tmp/context-runtime/transactions"), writes: [{ path: path2, bytes: `${JSON.stringify({ configuration, warning }, null, 2)}
 ` }] });
       return {
         kind: "document.capture.warning",
@@ -104858,7 +104898,7 @@ init_workspacePreparation();
 init_siteTranslation();
 init_src2();
 init_statusReaders();
-import { join as join95 } from "node:path";
+import { join as join96 } from "node:path";
 
 // src/project/statusEvidence.ts
 function evidenceWarningState(issues) {
@@ -105298,7 +105338,7 @@ async function collectProjectStatusSnapshotInternal(projectRoot, options = {}) {
   const authoring = production && !production.delivery && (dispatchProductionStage(production, productionCapabilitiesSchema.parse({})).state !== "ended" || draftStatus.count > 0 && draftStatus.diagnostics.length === 0);
   const deferDeliveryChecks = !maintenance && !localRevision && !localUpdate && !localRollback && (taskPreparation === "cleared" && !production || !!authoring);
   const collectionsWithPages = new Set;
-  const approvedPages = await countFiles(join95(projectRoot, "knowledge"), (rel) => {
+  const approvedPages = await countFiles(join96(projectRoot, "knowledge"), (rel) => {
     if (!isApprovedKnowledgeMarkdownPath(rel) || rel.startsWith("assets/"))
       return false;
     collectionsWithPages.add(rel.split("/")[0]);
@@ -105306,7 +105346,7 @@ async function collectProjectStatusSnapshotInternal(projectRoot, options = {}) {
   });
   const approvedCollections = KNOWLEDGE_COLLECTIONS.filter((collection) => collectionsWithPages.has(collection));
   const closeStatus = deferDeliveryChecks ? { state: "not-checked", diagnostics: [] } : await readCloseStatus(projectRoot);
-  const distFiles = await countFiles(join95(projectRoot, "dist"), () => true);
+  const distFiles = await countFiles(join96(projectRoot, "dist"), () => true);
   const verifyStatus = !deferDeliveryChecks && draftStatus.diagnostics.length === 0 ? await readVerifyStatus(projectRoot) : { issues: [], diagnostics: [] };
   const revisionDocuments = localRevision ? documentSources.filter((source2) => localRevision.target.source_refs.some((ref2) => [source2.name, source2.id].filter(Boolean).some((name3) => ref2 === `${source2.type}:${name3}` || ref2 === `docs:${name3}` || ref2.startsWith(`${source2.type}:${name3}#`) || ref2.startsWith(`${source2.type}:${name3}/`)))) : documentSources;
   const pendingCapture = pendingDocumentCaptureCommands({
@@ -105684,7 +105724,7 @@ function bindWorkflowExecutionContext(result, context) {
 init_atomicWrite();
 import { Buffer as Buffer4 } from "node:buffer";
 import { createHash as createHash27 } from "node:crypto";
-import { join as join96 } from "node:path";
+import { join as join97 } from "node:path";
 var WORKFLOW_ROUTE_INLINE_BYTE_LIMIT = 8 * 1024;
 async function workflowRouteOutput(projectRoot, route, options = {}) {
   if (!route)
@@ -105692,7 +105732,7 @@ async function workflowRouteOutput(projectRoot, route, options = {}) {
   const body = `${JSON.stringify(route, null, 2)}
 `;
   const digest6 = createHash27("sha256").update(body).digest("hex");
-  const file = join96(projectRoot, ".tmp/context-runtime/routes", `${digest6}.json`);
+  const file = join97(projectRoot, ".tmp/context-runtime/routes", `${digest6}.json`);
   await atomicWriteFile(file, body);
   const routeBytes = Buffer4.byteLength(body);
   const inlineByteLimit = Math.max(0, Math.min(WORKFLOW_ROUTE_INLINE_BYTE_LIMIT, options.inlineByteLimit ?? WORKFLOW_ROUTE_INLINE_BYTE_LIMIT));
@@ -105714,7 +105754,7 @@ async function workflowRunResultFile(projectRoot, result) {
   const body = `${JSON.stringify(result, null, 2)}
 `;
   const digest6 = createHash27("sha256").update(body).digest("hex");
-  const file = join96(projectRoot, ".tmp/context-runtime/action-results", `${digest6}.run.json`);
+  const file = join97(projectRoot, ".tmp/context-runtime/action-results", `${digest6}.run.json`);
   await atomicWriteFile(file, body);
   return file;
 }
@@ -105862,8 +105902,8 @@ init_workflowTypes();
 init_candidateLedger();
 init_reviewShared();
 import { mkdir as mkdir35, readFile as readFile81, writeFile as writeFile28 } from "node:fs/promises";
-import { fileURLToPath as fileURLToPath7 } from "node:url";
-import { dirname as dirname42, isAbsolute as isAbsolute17, join as join100, resolve as resolve32 } from "node:path";
+import { fileURLToPath as fileURLToPath8 } from "node:url";
+import { dirname as dirname43, isAbsolute as isAbsolute17, join as join101, resolve as resolve32 } from "node:path";
 
 // src/project/reviewSiteModel.ts
 init_siteTheme2();
@@ -105872,7 +105912,7 @@ init_unified();
 init_remark_parse();
 var import_yaml48 = __toESM(require_dist(), 1);
 import { readFile as readFile79 } from "node:fs/promises";
-import { join as join98 } from "node:path";
+import { join as join99 } from "node:path";
 import { execFile as execFile11 } from "node:child_process";
 import { promisify as promisify11 } from "node:util";
 import { createHash as createHash28 } from "node:crypto";
@@ -108838,9 +108878,9 @@ init_workspace();
 
 // src/project/reviewFeedback.ts
 import { readdir as readdir23, readFile as readFile78 } from "node:fs/promises";
-import { join as join97 } from "node:path";
+import { join as join98 } from "node:path";
 async function readPendingReviewFeedback(root2, candidates) {
-  const directory = join97(root2, ".tmp/context-runtime/review-feedback");
+  const directory = join98(root2, ".tmp/context-runtime/review-feedback");
   let files;
   try {
     files = await readdir23(directory);
@@ -108853,7 +108893,7 @@ async function readPendingReviewFeedback(root2, candidates) {
   const results = new Map;
   const receipts = [];
   for (const file of files.filter((f) => /^[a-f0-9]+\.json$/u.test(f)).sort()) {
-    const receipt2 = JSON.parse(await readFile78(join97(directory, file), "utf8"));
+    const receipt2 = JSON.parse(await readFile78(join98(directory, file), "utf8"));
     receipts.push(receipt2);
   }
   for (const receipt2 of receipts.sort((a, b) => a.created_at.localeCompare(b.created_at))) {
@@ -108990,7 +109030,7 @@ async function reviewSiteBaselineHash(root2, reviewedPaths) {
   const displayed = new Set([...reviewedPaths, ...(metadata.structure?.articles ?? []).filter((a) => navigation.changedArticles.has(a.article_id)).map((a) => a.path)]);
   return hash4(JSON.stringify([
     navigation.baseline,
-    await optional2(join98(root2, "src/knowledge-map.yaml")) ?? null,
+    await optional2(join99(root2, "src/knowledge-map.yaml")) ?? null,
     files.map((f) => [f.relPath, displayed.has(f.relPath) ? hash4(f.content) : title(f.content, f.relPath)]).sort((a, b) => a[0].localeCompare(b[0]))
   ]));
 }
@@ -109100,9 +109140,9 @@ async function collectReviewSiteModel(root2, candidates) {
     for (const [i2, p] of unplaced.entries())
       nodes.push({ key: `review-page-${p.id}`, parent: "review-unplaced", title: p.title, order: i2, page: p.id, change: p.change });
   }
-  const pkgText = await optional2(join98(root2, "package.json"));
+  const pkgText = await optional2(join99(root2, "package.json"));
   const pkg = pkgText ? JSON.parse(pkgText) : {};
-  const project = await optional2(join98(root2, "src/index.ts")) === undefined ? undefined : await loadContextProjectModule(root2);
+  const project = await optional2(join99(root2, "src/index.ts")) === undefined ? undefined : await loadContextProjectModule(root2);
   const siteTitle = project?.project.packages.flatMap((p) => p.kind === "package.kb" && p.site?.title ? [p.site.title] : [])[0];
   const sitePackages = project?.project.packages.flatMap((p) => p.kind === "package.kb" && p.site ? [p.site] : []) ?? [];
   const themeCss = siteThemeVariables(await resolveSiteTheme(root2, sitePackages.length === 1 ? sitePackages[0]?.theme : undefined));
@@ -109117,8 +109157,8 @@ init_cliFeedback();
 init_exitCode();
 init_reviewShared();
 import { readFile as readFile80 } from "node:fs/promises";
-import { join as join99 } from "node:path";
-var scopePath = (root2, scope2) => join99(root2, ".tmp/context-runtime/review", `${scope2}.scope.json`);
+import { join as join100 } from "node:path";
+var scopePath = (root2, scope2) => join100(root2, ".tmp/context-runtime/review", `${scope2}.scope.json`);
 async function saveReviewReportScope(root2, scope2, candidates, baselineHash) {
   const ids = candidates.map((candidate) => candidate.record.candidate_id).sort();
   const value = {
@@ -109595,7 +109635,7 @@ button:focus-visible { outline: 2px solid var(--blue); outline-offset: 3px; }
 
 // src/project/reviewHtml.ts
 init_knowledgeMap2();
-var REVIEW_HTML_ROOT = join100(".tmp", "context-runtime", "review");
+var REVIEW_HTML_ROOT = join101(".tmp", "context-runtime", "review");
 async function collectReviewCandidates(projectRoot, collection) {
   const rows = await readCandidateRecords(projectRoot);
   const draftRows = rows.filter((row) => row.collection === collection && row.status === "draft");
@@ -109644,7 +109684,7 @@ ${diagramScript ? `<script>${diagramScript}</script>` : ""}<script>const DATA=${
 }
 function resolveOutputPath(projectRoot, outPath, reviewScope) {
   if (outPath === undefined)
-    return join100(projectRoot, REVIEW_HTML_ROOT, `${reviewScope}.html`);
+    return join101(projectRoot, REVIEW_HTML_ROOT, `${reviewScope}.html`);
   return isAbsolute17(outPath) ? outPath : resolve32(projectRoot, outPath);
 }
 async function writeReviewHtml(input) {
@@ -109654,13 +109694,13 @@ async function writeReviewHtml(input) {
   }
   const candidates = reviewScope === "all" ? await collectAllReviewCandidates(input.projectRoot) : await collectReviewCandidates(input.projectRoot, reviewScope);
   const outPath = resolveOutputPath(input.projectRoot, input.out, reviewScope);
-  await mkdir35(dirname42(outPath), { recursive: true });
+  await mkdir35(dirname43(outPath), { recursive: true });
   const model = await collectReviewSiteModel(input.projectRoot, candidates);
   let diagramScript = "";
   if (model.pages.some((page) => page.html.includes('class="language-mermaid"'))) {
-    const here = dirname42(fileURLToPath7(import.meta.url));
+    const here = dirname43(fileURLToPath8(import.meta.url));
     try {
-      diagramScript = await readFile81(join100(here, "browser/diagrams.js"), "utf8");
+      diagramScript = await readFile81(join101(here, "browser/diagrams.js"), "utf8");
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
@@ -109697,7 +109737,7 @@ init_dist();
 init_atomicWrite();
 init_reviewShared();
 import { mkdir as mkdir36, readFile as readFile82 } from "node:fs/promises";
-import { join as join101 } from "node:path";
+import { join as join102 } from "node:path";
 var REVIEW_BATCH_MAX_CANDIDATES = 6;
 var REVIEW_BATCH_MAX_BYTES = 512 * 1024;
 async function readerPurposes(projectRoot, sources) {
@@ -109777,11 +109817,11 @@ async function materializeCurrentReviewBatchSet(input) {
   const batches = buildCurrentReviewBatchDocuments(input.candidates);
   const setDigest = digestText(batches.map((batch) => `${batch.task_key}:${batch.digest}`).join(`
 `));
-  const root2 = join101(input.projectRoot, ".tmp", "context-runtime", "review", `current-${setDigest.slice("sha256:".length)}`);
+  const root2 = join102(input.projectRoot, ".tmp", "context-runtime", "review", `current-${setDigest.slice("sha256:".length)}`);
   await mkdir36(root2, { recursive: true });
   const entries2 = [];
   for (const batch of batches) {
-    const path4 = join101(input.projectRoot, ".tmp", "context-runtime", "review", `${batch.task_key}-${batch.digest.slice("sha256:".length)}.md`);
+    const path4 = join102(input.projectRoot, ".tmp", "context-runtime", "review", `${batch.task_key}-${batch.digest.slice("sha256:".length)}.md`);
     const existing = await readFile82(path4, "utf8").catch((error) => {
       if (error.code === "ENOENT")
         return;
@@ -109835,7 +109875,7 @@ async function materializeCurrentReviewBatchSet(input) {
   ].join(`
 `);
   const digest6 = digestText(content3);
-  const path3 = join101(root2, "index.md");
+  const path3 = join102(root2, "index.md");
   await atomicWriteFile(path3, `${content3}
 `);
   return {
@@ -109868,11 +109908,11 @@ function shellQuote6(value) {
 }
 function receiptSetPath(receipts) {
   const token = digestText(JSON.stringify(receipts)).slice("sha256:".length);
-  return join102(".tmp", "context-runtime", "workflow", "read-receipts", `${token}.json`);
+  return join103(".tmp", "context-runtime", "workflow", "read-receipts", `${token}.json`);
 }
 async function writeReceiptContinuation(input) {
   const path3 = receiptSetPath(input.receipts);
-  const absolutePath = join102(input.projectRoot, path3);
+  const absolutePath = join103(input.projectRoot, path3);
   await writeJsonAtomic(absolutePath, input.receipts);
   const contextCommand = input.managed ? [
     "context",
@@ -109967,7 +110007,7 @@ async function materializeContextWorkflowResource(input) {
   const resourceId = workflowResourceId(input.resourceId);
   const content3 = renderContextWorkflowResource(resourceId, status);
   const location = await materializeResource(await loadContextWorkflowProvider(), resourceId, {
-    cache: join102(found.projectRoot, ".tmp", "context-runtime", "workflow", "resources"),
+    cache: join103(found.projectRoot, ".tmp", "context-runtime", "workflow", "resources"),
     workspace: found.projectRoot,
     revision: input.revision,
     input: {
@@ -109999,7 +110039,7 @@ async function materializeContextWorkflowResource(input) {
     receipts: afterReadReceipts
   });
   const directResources = (status.workflow.current?.resources.required ?? []).filter((resource) => resource.read_state === "read-required" && resource.path !== undefined && resource.digest !== undefined);
-  const afterReadCommand = directResources.length === 0 ? continuation.command : `context resource acknowledge-current --revision ${shellQuote6(input.revision)}${authorityCommandOptions(authorities, "resource")} --resource-receipts ${shellQuote6(`@${join102(found.projectRoot, continuation.path)}`)} --format json`;
+  const afterReadCommand = directResources.length === 0 ? continuation.command : `context resource acknowledge-current --revision ${shellQuote6(input.revision)}${authorityCommandOptions(authorities, "resource")} --resource-receipts ${shellQuote6(`@${join103(found.projectRoot, continuation.path)}`)} --format json`;
   return {
     protocol: "context.workflow.resource.v1",
     id: resourceId,
@@ -110060,14 +110100,14 @@ async function acknowledgeCurrentWorkflowResources(input) {
   const reevaluated = await reevaluateProjectStatusWorkflow({
     snapshot,
     resourceReceipts: normalizedReceipts,
-    resourceReceiptsReference: `@${join102(found.projectRoot, continuation.path)}`
+    resourceReceiptsReference: `@${join103(found.projectRoot, continuation.path)}`
   });
   return {
     ...reevaluated,
     resourceAcknowledgement: {
       protocol: "context.workflow.resource-receipts.v1",
       acknowledged: directResources.length,
-      receiptReference: `@${join102(found.projectRoot, continuation.path)}`,
+      receiptReference: `@${join103(found.projectRoot, continuation.path)}`,
       message: "For workflow continuation, use the returned selected command with its revision and resource-receipt arguments. Receipts retain required-reading state for Route evaluation; they are not approval credentials or universal prerequisites for direct CLI primitives. Direct commands still enforce their own state, scope and confirmation checks. Do not pre-chain an earlier write command or replace this result with status without receipts. Acknowledgement does not necessarily change the revision; reread only changed or unavailable required content."
     }
   };
@@ -110115,8 +110155,8 @@ init_errors3();
 init_exitCode();
 init_workspace();
 import { readFile as readFile83 } from "node:fs/promises";
-import { isAbsolute as isAbsolute18, join as join103, sep as sep8, resolve as resolve33 } from "node:path";
-var RECEIPT_DIRECTORY = join103(".tmp", "context-runtime", "workflow", "read-receipts");
+import { isAbsolute as isAbsolute18, join as join104, sep as sep8, resolve as resolve33 } from "node:path";
+var RECEIPT_DIRECTORY = join104(".tmp", "context-runtime", "workflow", "read-receipts");
 function workflowResourceReceiptCwd(value, cwd) {
   if (value === undefined || !value.startsWith("@"))
     return cwd;
@@ -110235,7 +110275,7 @@ function registerContextWorkflowResourceCommands(program2) {
 }
 
 // src/commands/runProject.ts
-import { fileURLToPath as fileURLToPath8 } from "node:url";
+import { fileURLToPath as fileURLToPath9 } from "node:url";
 init_cliFeedback();
 init_errors3();
 
@@ -110394,15 +110434,15 @@ function compactJsonResult(result, verbose) {
 // src/project/runLog.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { mkdir as mkdir38, writeFile as writeFile30 } from "node:fs/promises";
-import { dirname as dirname44, join as join109 } from "node:path";
+import { dirname as dirname45, join as join110 } from "node:path";
 var createPhaseRunId = () => {
   const timestamp = new Date().toISOString().replace(/[-:.TZ]/gu, "");
   return `run_${timestamp}_${randomUUID6().slice(0, 8)}`;
 };
 async function writePhaseRunLog(input) {
-  const relPath = join109(".tmp", "context-runtime", "runs", `${input.runId}.json`);
-  const absPath = join109(input.projectRoot, relPath);
-  await mkdir38(dirname44(absPath), { recursive: true });
+  const relPath = join110(".tmp", "context-runtime", "runs", `${input.runId}.json`);
+  const absPath = join110(input.projectRoot, relPath);
+  await mkdir38(dirname45(absPath), { recursive: true });
   await writeFile30(absPath, `${JSON.stringify({
     run_id: input.runId,
     phase_id: input.phase.id,
@@ -111637,9 +111677,9 @@ init_reviewCandidateAuthority();
 init_durableMultiFileTransaction();
 init_durableSingleFileTransaction();
 init_reviewShared();
-import { existsSync as existsSync26 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { readFile as readFile88 } from "node:fs/promises";
-import { join as join110 } from "node:path";
+import { join as join111 } from "node:path";
 function existingTimestamp(markdown) {
   if (markdown === undefined)
     return;
@@ -111666,7 +111706,7 @@ async function prepareApprovedPage(input) {
       next: "Refresh the current production or article revision, then reopen Review before approval."
     });
   }
-  const relPath = join110("knowledge", input.record.path);
+  const relPath = join111("knowledge", input.record.path);
   const existingView = findApprovedPageForArticleId(input.record.indexer_candidate.artifact_ref, input.approvedPageIndex);
   const previousPath = input.record.approved_revision?.previous_path;
   if (previousPath !== undefined && (!isSafeKnowledgeTargetPath(previousPath.split("/")[0], previousPath) || previousPath.includes("\\")))
@@ -111681,13 +111721,13 @@ async function prepareApprovedPage(input) {
       next: "Resolve the approved page path migration explicitly before approving this candidate."
     });
   }
-  const absPath = join110(input.projectRoot, relPath);
-  const existing = existsSync26(absPath) ? await readFile88(absPath, "utf8") : undefined;
+  const absPath = join111(input.projectRoot, relPath);
+  const existing = existsSync27(absPath) ? await readFile88(absPath, "utf8") : undefined;
   let previous3;
   if (previousPath !== undefined) {
     if (existing !== undefined || existingView?.relPath !== `knowledge/${previousPath}`)
       throw new TypeError("Page move destination or original identity changed; refresh its revision.");
-    previous3 = { path: `knowledge/${previousPath}`, content: await readFile88(join110(input.projectRoot, "knowledge", previousPath), "utf8") };
+    previous3 = { path: `knowledge/${previousPath}`, content: await readFile88(join111(input.projectRoot, "knowledge", previousPath), "utf8") };
   }
   if (input.record.approved_revision !== undefined) {
     const base = previous3?.content ?? existing;
@@ -111734,7 +111774,7 @@ async function prepareApprovedPage(input) {
 }
 async function readProjectFileMaybe(projectRoot, relPath) {
   try {
-    return await readFile88(join110(projectRoot, relPath), "utf8");
+    return await readFile88(join111(projectRoot, relPath), "utf8");
   } catch (error) {
     if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT") {
       return;
@@ -111955,7 +111995,7 @@ async function applyReviewDecisions(input) {
           });
         }
         seenApprovedIds.set(approvedRef, row.candidate_id);
-        const approvedPath = join110("knowledge", row.path);
+        const approvedPath = join111("knowledge", row.path);
         const previousPathCandidate = seenApprovedPaths.get(knowledgeTargetPathKey(approvedPath));
         if (previousPathCandidate !== undefined) {
           throw new ContextError(ExitCode.UserError, `multiple approved review decisions target the same knowledge path: ${approvedPath}`, {
@@ -112005,7 +112045,7 @@ async function applyReviewDecisions(input) {
       for (const path3 of approvedPageIndex.byRelPath.keys()) {
         if (pagesToWrite.some((page) => page.relPath === path3 || page.previous?.path === path3))
           continue;
-        const before = await readFile88(join110(input.projectRoot, path3), "utf8");
+        const before = await readFile88(join111(input.projectRoot, path3), "utf8");
         const local = path3.replace(/^knowledge\//u, "");
         const after = moveKnowledgeLinkTargets2(before, local, local, moved);
         navigationTargets.push(reviewFileTarget({ path: path3, baseContent: before, targetContent: after }));
@@ -112089,12 +112129,12 @@ init_candidateLedger();
 
 // src/project/localHtmlReport.ts
 import { execFile as execFile12 } from "node:child_process";
-import { isAbsolute as isAbsolute20, join as join111 } from "node:path";
+import { isAbsolute as isAbsolute20, join as join112 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import { promisify as promisify12 } from "node:util";
 var execFileAsync5 = promisify12(execFile12);
 function htmlReportReference(input) {
-  const absolutePath = isAbsolute20(input.path) ? input.path : join111(input.projectRoot, input.path);
+  const absolutePath = isAbsolute20(input.path) ? input.path : join112(input.projectRoot, input.path);
   return {
     format: "html",
     path: input.path,
@@ -112898,7 +112938,7 @@ async function runProjectUntil(input) {
   const resourceReceipts = input.resourceReceiptsReference === undefined ? undefined : await parseWorkflowResourceReceipts(input.resourceReceiptsReference, found.projectRoot);
   const runtime = new WorkspaceExecutionRuntime({
     projectRoot: found.projectRoot,
-    cliEntryPath: fileURLToPath8(input.cliModuleUrl),
+    cliEntryPath: fileURLToPath9(input.cliModuleUrl),
     inProcess: createWorkflowInProcessExecutor()
   });
   let result;
@@ -113096,7 +113136,7 @@ init_maintenanceStorage();
 init_productionFeedback();
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { readFile as readFile91 } from "node:fs/promises";
-import { join as join112 } from "node:path";
+import { join as join113 } from "node:path";
 async function beginProductionRevision(input) {
   return withProductionFeedback({ operation: "revision" }, () => withProjectWriteLock(input.projectRoot, "production-revision", async () => {
     await recoverDurableMultiFileTransactions(input.projectRoot);
@@ -113135,7 +113175,7 @@ async function beginProductionRevision(input) {
       const formal = approved.byPath.get(path3);
       if (!prior && !formal)
         throw invalid2("Write the current task first; there is no article draft to revise yet.");
-      const markdown = prior?.body ?? await readFile91(await safeProjectTarget(input.projectRoot, join112("knowledge", path3)), "utf8");
+      const markdown = prior?.body ?? await readFile91(await safeProjectTarget(input.projectRoot, join113("knowledge", path3)), "utf8");
       const sections = prior?.indexer_candidate.sections.map((section) => ({ id: section.section_key, references: section.references })) ?? formal?.sections;
       const sources = [];
       for (const source2 of owner.sources) {
@@ -113701,7 +113741,7 @@ function registerVersionCommands(program2) {
 
 // src/commands/translateCommands.ts
 init_workspace();
-import { isAbsolute as isAbsolute22, join as join116 } from "node:path";
+import { isAbsolute as isAbsolute22, join as join117 } from "node:path";
 init_siteTranslation();
 function projectRoot() {
   const root2 = findContextProjectRoot(process.cwd())?.projectRoot;
@@ -113786,7 +113826,7 @@ function registerTranslateCommands(program2) {
       readFailureNext: "Check the input path",
       parseFailureNext: "Use valid YAML or JSON"
     }));
-    const saved = await submitSiteTranslation(root2, await projectPackages(root2), value, (file) => isAbsolute22(file) ? file : join116(root2, file));
+    const saved = await submitSiteTranslation(root2, await projectPackages(root2), value, (file) => isAbsolute22(file) ? file : join117(root2, file));
     write(await withWorkflow(root2, { outcome: "submitted", ...saved }));
   });
   command3.command("skip").description("Publish the current pending translations in the primary language").requiredOption("--digest <digest>", "expected_digest from context translate prepare").option("--format <format>", "json", "json").action(async (options) => {
@@ -113880,7 +113920,7 @@ init_atomicWrite();
 var import_yaml52 = __toESM(require_dist(), 1);
 import { Buffer as Buffer5 } from "node:buffer";
 import { createHash as createHash35 } from "node:crypto";
-import { join as join117 } from "node:path";
+import { join as join118 } from "node:path";
 var INLINE_LIMIT = 16 * 1024;
 function record4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
@@ -113906,8 +113946,8 @@ async function prepareActionCompletionOutput(input) {
   if (production && Buffer5.byteLength(full) <= INLINE_LIMIT)
     return input.result;
   const digest7 = createHash35("sha256").update(full).digest("hex");
-  const root2 = join117(input.projectRoot, ".tmp/context-runtime/action-results");
-  const resultFile = join117(root2, `${digest7}.json`);
+  const root2 = join118(input.projectRoot, ".tmp/context-runtime/action-results");
+  const resultFile = join118(root2, `${digest7}.json`);
   await atomicWriteFile(resultFile, full);
   if (production)
     return {
@@ -114336,10 +114376,10 @@ function registerProjectActionCommands(program2) {
 
 // src/commands/cleanClaudePluginCache.ts
 init_cliFeedback();
-import { existsSync as existsSync28 } from "node:fs";
+import { existsSync as existsSync29 } from "node:fs";
 import { readdir as readdir30, rm as rm24 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join as join118 } from "node:path";
+import { join as join119 } from "node:path";
 var ORPHAN_MARKER = ".orphaned_at";
 var CLAUDE_PLUGIN_CACHE_ROOT_ENV = "C4A_CLAUDE_PLUGIN_CACHE_ROOT";
 var CLAUDE_PLUGIN_CACHE_HOME_ENV = "C4A_CLAUDE_PLUGIN_CACHE_HOME";
@@ -114348,7 +114388,7 @@ async function cleanClaudePluginCache(opts = {}) {
   const lines = [];
   let removed = 0;
   let scanned = 0;
-  if (!existsSync28(cacheRoot)) {
+  if (!existsSync29(cacheRoot)) {
     lines.push("· claude plugin cache: missing — nothing to clean");
     return { lines, removed, scanned };
   }
@@ -114356,20 +114396,20 @@ async function cleanClaudePluginCache(opts = {}) {
   for (const mp of marketplaces) {
     if (!mp.isDirectory())
       continue;
-    const mpDir = join118(cacheRoot, mp.name);
+    const mpDir = join119(cacheRoot, mp.name);
     const plugins = await readdir30(mpDir, { withFileTypes: true });
     for (const pl of plugins) {
       if (!pl.isDirectory())
         continue;
-      const plDir = join118(mpDir, pl.name);
+      const plDir = join119(mpDir, pl.name);
       const versions = await readdir30(plDir, { withFileTypes: true });
       for (const ver of versions) {
         if (!ver.isDirectory())
           continue;
         scanned += 1;
-        const verDir = join118(plDir, ver.name);
-        const markerPath = join118(verDir, ORPHAN_MARKER);
-        if (!existsSync28(markerPath))
+        const verDir = join119(plDir, ver.name);
+        const markerPath = join119(verDir, ORPHAN_MARKER);
+        if (!existsSync29(markerPath))
           continue;
         const label2 = `${mp.name}/${pl.name}/${ver.name}`;
         if (opts.dryRun) {
@@ -114400,7 +114440,7 @@ function resolveClaudePluginCacheRoot(opts) {
   if (explicitRoot)
     return explicitRoot;
   const home = opts.home ?? process.env[CLAUDE_PLUGIN_CACHE_HOME_ENV] ?? homedir();
-  return join118(home, ".claude", "plugins", "cache");
+  return join119(home, ".claude", "plugins", "cache");
 }
 async function isEmptyDir(dir) {
   try {
@@ -114429,35 +114469,7 @@ async function runDoctorCleanClaudePluginCache(opts = {}) {
 init_errors3();
 init_cliFeedback();
 init_exitCode();
-
-// src/lib/packageVersion.ts
-import { existsSync as existsSync29, readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname47, join as join119 } from "node:path";
-import { fileURLToPath as fileURLToPath9 } from "node:url";
-function readPackageVersion() {
-  try {
-    let dir = dirname47(fileURLToPath9(import.meta.url));
-    for (let depth = 0;depth < 8; depth += 1) {
-      const packagePath = join119(dir, "package.json");
-      if (existsSync29(packagePath)) {
-        const parsed = JSON.parse(readFileSync9(packagePath, "utf8"));
-        if (typeof parsed.version === "string" && parsed.version.length > 0) {
-          return parsed.version;
-        }
-        break;
-      }
-      const parent = dirname47(dir);
-      if (parent === dir)
-        break;
-      dir = parent;
-    }
-  } catch (error) {
-    throw new TypeError("Context CLI package version cannot be read", {
-      cause: error
-    });
-  }
-  throw new TypeError("Context CLI package version is missing from package.json");
-}
+init_packageVersion();
 
 // src/project/sourceCommands.ts
 init_repoContentLinks();