@c4a/context-cli 0.7.13 → 0.7.14-beta.1

package/cli.js

@@ -70080,11 +70080,70 @@ var init_packageOutputPaths = __esm(() => {
   init_cliFeedback();
 });
 
+// src/project/packageSiteAddress.ts
+import { readFile as readFile42, writeFile as writeFile12, rename as rename5 } from "node:fs/promises";
+import { join as join50 } from "node:path";
+function normalizeSiteUrl(value) {
+  const url = new URL(value);
+  if (!["https:", "http:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+    throw new TypeError("Use an HTTP(S) site root without credentials, query or fragment");
+  }
+  url.pathname = `${url.pathname.replace(/\/+$/u, "")}/`;
+  return url.href;
+}
+async function readPackageSiteUrl(root, pkg) {
+  if (pkg.kind !== "package.kb" || !pkg.site)
+    return;
+  try {
+    const map2 = JSON.parse(await readFile42(join50(root, packageSiteOutputDir(pkg), SITE_MAP_FILE), "utf8"));
+    return typeof map2.site_url === "string" ? normalizeSiteUrl(map2.site_url) : undefined;
+  } catch (error) {
+    if (error.code === "ENOENT" || error instanceof SyntaxError || error instanceof TypeError)
+      return;
+    throw error;
+  }
+}
+async function recordPackageSiteUrl(root, packageName, value) {
+  const siteUrl = normalizeSiteUrl(value);
+  return withProjectWriteLock(root, "record-site-url", async () => {
+    const { loadContextProjectModule: loadContextProjectModule2 } = await Promise.resolve().then(() => (init_workspace(), exports_workspace));
+    const loaded = await loadContextProjectModule2(root);
+    const pkg = loaded.project.packages.find((candidate) => candidate.name === packageName);
+    if (!pkg || pkg.kind !== "package.kb" || !pkg.site) {
+      throw new TypeError("Select a declared knowledge package with a website");
+    }
+    const siteMap = join50(root, packageSiteOutputDir(pkg), SITE_MAP_FILE);
+    let map2;
+    try {
+      map2 = JSON.parse(await readFile42(siteMap, "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT")
+        throw new TypeError("Build the configured website before recording its deployment URL");
+      throw error;
+    }
+    if (map2.protocol !== "context.site-output/v1" || !Array.isArray(map2.pages)) {
+      throw new TypeError("Rebuild the website to restore a valid context-site-map.json");
+    }
+    const content3 = JSON.stringify({ ...map2, site_url: siteUrl }, null, 2) + `
+`;
+    for (const path2 of [siteMap, join50(root, pkg.outDir, SITE_MAP_FILE)]) {
+      await writeFile12(`${path2}.tmp`, content3);
+      await rename5(`${path2}.tmp`, path2);
+    }
+    return { package: pkg.name, site_url: siteUrl, network_checked: false };
+  });
+}
+var SITE_MAP_FILE = "context-site-map.json";
+var init_packageSiteAddress = __esm(() => {
+  init_packageOutputPaths();
+  init_writeLock();
+});
+
 // src/project/packageBuildReceipt.ts
 import { createHash as createHash13 } from "node:crypto";
 import { existsSync as existsSync15 } from "node:fs";
-import { readFile as readFile42 } from "node:fs/promises";
-import { join as join50, relative as relative15 } from "node:path";
+import { readFile as readFile43 } from "node:fs/promises";
+import { join as join51, relative as relative15 } from "node:path";
 function parsePackageLinkWarnings(value) {
   if (!Array.isArray(value))
     return [];
@@ -70099,7 +70158,7 @@ async function walkPackageFiles(root) {
     for (const entry of entries2) {
       if (IGNORED_PACKAGE_FS_ENTRIES.has(entry.name))
         continue;
-      const absPath = join50(dir, entry.name);
+      const absPath = join51(dir, entry.name);
       if (entry.isDirectory()) {
         await visit2(absPath);
         continue;
@@ -70130,17 +70189,27 @@ function classifyOutputFile(path2, knowledgeGroups) {
 }
 async function packageOutputSnapshot(projectRoot, pkg, knowledgeGroups, previousOutputs = []) {
   const previousByPath = new Map(previousOutputs.map((file) => [file.path, file]));
-  const files = (await Promise.all(packageOutputDirs(pkg).map(async (output) => (await walkPackageFiles(join50(projectRoot, output))).map((file) => ({
+  const files = (await Promise.all(packageOutputDirs(pkg).map(async (output) => (await walkPackageFiles(join51(projectRoot, output))).map((file) => ({
     ...file,
-    relPath: toPosixPath4(relative15(join50(projectRoot, pkg.outDir), file.absPath))
+    relPath: toPosixPath4(relative15(join51(projectRoot, pkg.outDir), file.absPath))
   }))))).flat();
   return Promise.all(files.map(async (file) => {
     const current = classifyOutputFile(file.relPath, knowledgeGroups);
     const previous2 = previousByPath.get(file.relPath);
     const classification = current.kind === "file" && previous2 !== undefined ? { path: file.relPath, kind: previous2.kind, ...previous2.group === undefined ? {} : { group: previous2.group } } : current;
+    let content3 = await readFile43(file.absPath);
+    if (file.absPath === join51(projectRoot, pkg.outDir, "context-site-map.json") || file.absPath === join51(projectRoot, packageSiteOutputDir(pkg), "context-site-map.json")) {
+      try {
+        const map2 = JSON.parse(content3.toString());
+        if (map2.protocol === "context.site-output/v1" && Array.isArray(map2.pages)) {
+          delete map2.site_url;
+          content3 = JSON.stringify(map2);
+        }
+      } catch {}
+    }
     return {
       ...classification,
-      sha256: createHash13("sha256").update(await readFile42(file.absPath)).digest("hex")
+      sha256: createHash13("sha256").update(content3).digest("hex")
     };
   }));
 }
@@ -70148,8 +70217,8 @@ async function packageOutputFingerprint(projectRoot, pkg, observed) {
   const snapshot = observed ?? await packageOutputSnapshot(projectRoot, pkg, new Map);
   return {
     fingerprint: createHash13("sha256").update(JSON.stringify({
-      outDirExists: existsSync15(join50(projectRoot, pkg.outDir)),
-      siteDirExists: pkg.kind === "package.kb" && pkg.site ? existsSync15(join50(projectRoot, packageSiteOutputDir(pkg))) : undefined,
+      outDirExists: existsSync15(join51(projectRoot, pkg.outDir)),
+      siteDirExists: pkg.kind === "package.kb" && pkg.site ? existsSync15(join51(projectRoot, packageSiteOutputDir(pkg))) : undefined,
       files: snapshot.map(({ path: path2, sha256 }) => ({ path: path2, sha256 }))
     })).digest("hex"),
     files: snapshot.length
@@ -70234,8 +70303,8 @@ var init_packageBuildReceipt = __esm(() => {
 });
 
 // src/project/knowledgeMapCoverage.ts
-import { readFile as readFile43 } from "node:fs/promises";
-import { join as join51 } from "node:path";
+import { readFile as readFile44 } from "node:fs/promises";
+import { join as join52 } from "node:path";
 function knowledgeMapArticleTargets(files) {
   return files.flatMap((file) => {
     const meta = parseKnowledgeFrontmatter(file.content);
@@ -70251,10 +70320,10 @@ function knowledgeMapArticleTargets(files) {
 async function approvedKnowledgeMapTargets(root) {
   const metadata = await readApprovedKnowledgeMetadataIndex(root);
   const articles = new Map(validateArticleStructureEntries(metadata.structure?.articles ?? []).map((article) => [article.path, article]));
-  const files = await walkPackageFiles(join51(root, "knowledge"));
+  const files = await walkPackageFiles(join52(root, "knowledge"));
   const content3 = await Promise.all(files.filter((file) => isApprovedKnowledgeMarkdownPath(file.relPath) && !file.relPath.startsWith("assets/")).map(async (file) => ({
     article: articles.get(file.relPath),
-    content: hydrateApprovedKnowledgeMarkdown({ content: await readFile43(file.absPath, "utf8"), relPath: file.relPath, metadata })
+    content: hydrateApprovedKnowledgeMarkdown({ content: await readFile44(file.absPath, "utf8"), relPath: file.relPath, metadata })
   })));
   return knowledgeMapArticleTargets(content3);
 }
@@ -70300,11 +70369,11 @@ var init_knowledgeMapCoverage = __esm(() => {
 });
 
 // src/project/knowledgeMap.ts
-import { readFile as readFile44 } from "node:fs/promises";
-import { join as join52 } from "node:path";
+import { readFile as readFile45 } from "node:fs/promises";
+import { join as join53 } from "node:path";
 async function optionalText(root, path2) {
   try {
-    return await readFile44(join52(root, path2), "utf8");
+    return await readFile45(join53(root, path2), "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -70357,8 +70426,8 @@ var init_knowledgeMap2 = __esm(() => {
 });
 
 // src/project/packageKnowledgeMap.ts
-import { readFile as readFile45, writeFile as writeFile12 } from "node:fs/promises";
-import { join as join53 } from "node:path";
+import { readFile as readFile46, writeFile as writeFile13 } from "node:fs/promises";
+import { join as join54 } from "node:path";
 function knowledgeMapSectionAnchor(key) {
   return `section-${encodeURIComponent(key)}`;
 }
@@ -70383,16 +70452,16 @@ async function writePackageKnowledgeMap(input) {
     return [];
   const projected = projectKnowledgeMap(input.structure, packageKnowledgeMapTargets(input.pkg, input.selected));
   projected.warnings = projected.warnings.filter((warning) => !warning.target.startsWith("site:"));
-  const root = join53(input.projectRoot, input.pkg.outDir);
-  const mapPath = join53(root, "context-knowledge-map.json");
+  const root = join54(input.projectRoot, input.pkg.outDir);
+  const mapPath = join54(root, "context-knowledge-map.json");
   try {
-    await readFile45(mapPath);
+    await readFile46(mapPath);
     throw new TypeError("package template uses reserved context-knowledge-map.json; rename that template output");
   } catch (error) {
     if (error.code !== "ENOENT")
       throw error;
   }
-  await writeFile12(mapPath, JSON.stringify({ protocol: "context.knowledge-map-output/v1", knowledge_map_revision: input.structure.revision, ...projected }, null, 2) + `
+  await writeFile13(mapPath, JSON.stringify({ protocol: "context.knowledge-map-output/v1", knowledge_map_revision: input.structure.revision, ...projected }, null, 2) + `
 `);
   const lines = [];
   const escape2 = (value) => value.replace(/[\\[\]<>]/gu, (char) => `\\${char}`).replace(/[\r\n]/gu, " ");
@@ -70405,15 +70474,15 @@ async function writePackageKnowledgeMap(input) {
   }
   render(projected.entries, 0);
   if (lines.length) {
-    const indexPath = join53(root, "index.md");
+    const indexPath = join54(root, "index.md");
     let existing = "";
     try {
-      existing = await readFile45(indexPath, "utf8");
+      existing = await readFile46(indexPath, "utf8");
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
     }
-    await writeFile12(indexPath, `${existing.trimEnd()}
+    await writeFile13(indexPath, `${existing.trimEnd()}
 
 ## Knowledge map
 
@@ -70431,8 +70500,8 @@ var init_packageKnowledgeMap = __esm(() => {
 
 // src/project/packageLlms.ts
 import { createHash as createHash14 } from "node:crypto";
-import { access as access4, mkdir as mkdir18, writeFile as writeFile13 } from "node:fs/promises";
-import { dirname as dirname22, join as join54, posix as posix5 } from "node:path";
+import { access as access4, mkdir as mkdir18, writeFile as writeFile14 } from "node:fs/promises";
+import { dirname as dirname22, join as join55, posix as posix5 } from "node:path";
 function llmsArticles(pkg, selected) {
   return selected.map((file) => {
     const meta = parseKnowledgeFrontmatter(file.content);
@@ -70532,7 +70601,7 @@ async function writeLlmsDocuments(root, documents, options = {}) {
   for (const [path2, content3] of documents.files) {
     let exists = false;
     try {
-      await access4(join54(root, path2));
+      await access4(join55(root, path2));
       exists = true;
     } catch (error) {
       if (error.code !== "ENOENT")
@@ -70542,8 +70611,8 @@ async function writeLlmsDocuments(root, documents, options = {}) {
       continue;
     if (exists)
       throw new Error(`Package template uses reserved LLMS output ${path2}; rename that template output.`);
-    await mkdir18(dirname22(join54(root, path2)), { recursive: true });
-    await writeFile13(join54(root, path2), options.utf8Bom ? "\uFEFF" + content3.replace(/^\uFEFF/u, "") : content3, "utf8");
+    await mkdir18(dirname22(join55(root, path2)), { recursive: true });
+    await writeFile14(join55(root, path2), options.utf8Bom ? "\uFEFF" + content3.replace(/^\uFEFF/u, "") : content3, "utf8");
   }
 }
 var PACKAGE_LLMS_VERSION = "knowledge-map-llms-v1", label = (text7) => text7.replace(/[\\[\]<>`*]/gu, "\\$&").replace(/[\r\n]/gu, " "), articlePath = (identity) => `llms/pages/${createHash14("sha256").update(identity).digest("hex").slice(0, 32)}.txt`;
@@ -71203,8 +71272,8 @@ var init_packageSiteBranding = __esm(() => {
 
 // src/project/packageSiteExtensions.ts
 import { createHash as createHash15 } from "node:crypto";
-import { lstat as lstat7, readdir as readdir14, readFile as readFile46, mkdir as mkdir19, writeFile as writeFile14, symlink } from "node:fs/promises";
-import { join as join55, dirname as dirname23, resolve as resolve19 } from "node:path";
+import { lstat as lstat7, readdir as readdir14, readFile as readFile47, mkdir as mkdir19, writeFile as writeFile15, symlink } from "node:fs/promises";
+import { join as join56, dirname as dirname23, resolve as resolve19 } from "node:path";
 function invalidSiteExtension(message) {
   throw new ContextError(ExitCode.UserError, `Site extensions: ${message}. Update site.extensions, its src files or the knowledge-map target, then retry the build.`, {
     reason_code: "invalid-site-extension"
@@ -71223,7 +71292,7 @@ async function readSiteExtensions(projectRoot, extensions) {
     invalid(`unsafe root ${root}`);
   let cursor = projectRoot;
   for (const part of root.split("/")) {
-    cursor = join55(cursor, part);
+    cursor = join56(cursor, part);
     const info = await lstat7(cursor).catch((error) => {
       if (error.code === "ENOENT")
         invalid(`missing directory ${root}`);
@@ -71243,9 +71312,9 @@ async function readSiteExtensions(projectRoot, extensions) {
       if (entry.isSymbolicLink())
         invalid(`symlink at ${path2}`);
       if (entry.isDirectory())
-        await walk(join55(directory, entry.name), path2 + "/");
+        await walk(join56(directory, entry.name), path2 + "/");
       else if (entry.isFile())
-        files.push({ path: path2, bytes: await readFile46(join55(directory, entry.name)) });
+        files.push({ path: path2, bytes: await readFile47(join56(directory, entry.name)) });
     }
   }
   await walk(cursor, "");
@@ -71265,7 +71334,7 @@ async function readSiteExtensions(projectRoot, extensions) {
     hash3.update(file.path + "\x00").update(file.bytes).update("\x00");
   for (const name2 of ["package.json", "bun.lock", "pnpm-lock.yaml", "package-lock.json"]) {
     try {
-      hash3.update(name2).update(await readFile46(join55(projectRoot, name2)));
+      hash3.update(name2).update(await readFile47(join56(projectRoot, name2)));
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
@@ -71278,18 +71347,18 @@ function siteExtensionTargets(site) {
 }
 async function writeSiteExtensions(projectRoot, temporary, extensions) {
   const { files } = await readSiteExtensions(projectRoot, extensions);
-  const root = join55(temporary, "_site");
+  const root = join56(temporary, "_site");
   for (const file of files) {
-    const path2 = join55(root, file.path);
+    const path2 = join56(root, file.path);
     await mkdir19(dirname23(path2), { recursive: true });
-    await writeFile14(path2, file.bytes);
+    await writeFile15(path2, file.bytes);
   }
   if (extensions) {
     try {
       const modules = resolve19(projectRoot, "node_modules");
       if ((await lstat7(modules)).isDirectory() || (await lstat7(modules)).isSymbolicLink()) {
         await mkdir19(root, { recursive: true });
-        await symlink(modules, join55(root, "node_modules"), "dir");
+        await symlink(modules, join56(root, "node_modules"), "dir");
       }
     } catch (error) {
       if (error.code !== "ENOENT")
@@ -71308,16 +71377,16 @@ async function writeSiteExtensions(projectRoot, temporary, extensions) {
     imports.push(`const ${name2} = defineAsyncComponent(() => import(${JSON.stringify(`../../_site/${path2}`)}));`);
     slots.push(`${JSON.stringify(name2)}: ${name2 === "floating" ? `() => h(resolveComponent('ClientOnly'), null, { default: () => h(${name2}) })` : `() => h(${name2})`}`);
   }
-  await writeFile14(join55(temporary, ".vitepress/theme/extensions.js"), imports.join(`
+  await writeFile15(join56(temporary, ".vitepress/theme/extensions.js"), imports.join(`
 `) + `
 export default {${slots.join(",")}};
 `);
   for (const [key, path2] of Object.entries(extensions?.pages ?? {})) {
-    await mkdir19(join55(temporary, "custom"), { recursive: true });
+    await mkdir19(join56(temporary, "custom"), { recursive: true });
     const content3 = files.find((file) => file.path === path2).bytes.toString("utf8");
     const metadata = parseKnowledgeFrontmatter(content3);
     const title = metadata.title ?? /^#\s+(.+)$/m.exec(content3)?.[1] ?? key;
-    await writeFile14(join55(temporary, "custom", `${key}.md`), `---
+    await writeFile15(join56(temporary, "custom", `${key}.md`), `---
 ${JSON.stringify({ layout: "page", ...metadata, title })}
 ---
 <script setup>
@@ -71339,9 +71408,9 @@ var init_packageSiteExtensions = __esm(() => {
 // src/project/packageSite.ts
 import { createHash as createHash16 } from "node:crypto";
 import { spawn as spawn3 } from "node:child_process";
-import { mkdir as mkdir20, mkdtemp, readFile as readFile47, writeFile as writeFile15, rm as rm11, symlink as symlink2, cp, access as access5, stat as stat6 } from "node:fs/promises";
+import { mkdir as mkdir20, mkdtemp, readFile as readFile48, writeFile as writeFile16, rm as rm11, symlink as symlink2, cp, access as access5, stat as stat6 } from "node:fs/promises";
 import { createRequire as createRequire5 } from "node:module";
-import { dirname as dirname24, join as join56, posix as posix6 } from "node:path";
+import { dirname as dirname24, join as join57, posix as posix6 } from "node:path";
 function sitePagePath(identity) {
   return `pages/${createHash16("sha256").update(identity).digest("hex").slice(0, 32)}.html`;
 }
@@ -71454,7 +71523,7 @@ function siteSections(entries2) {
 async function compileSite(root, outDir) {
   const vitepressRoot = dirname24(require2.resolve("vitepress/package.json"));
   await new Promise((resolve8, reject) => {
-    const child = spawn3(process.versions.bun ? "node" : process.execPath, [join56(vitepressRoot, "bin/vitepress.js"), "build", root, "--outDir", outDir], { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn3(process.versions.bun ? "node" : process.execPath, [join57(vitepressRoot, "bin/vitepress.js"), "build", root, "--outDir", outDir], { stdio: ["ignore", "pipe", "pipe"] });
     let tail = "";
     const receive = (chunk) => {
       tail = (tail + chunk.toString()).slice(-16000);
@@ -71485,8 +71554,8 @@ async function writePackageSite(input) {
   const base = options.base ?? "/";
   const history = await readWorkspaceChangelog(projectRoot);
   const historyDate = history[0]?.date ?? null;
-  const root = join56(projectRoot, pkg.outDir);
-  const output = join56(projectRoot, packageSiteOutputDir(pkg));
+  const root = join57(projectRoot, pkg.outDir);
+  const output = join57(projectRoot, packageSiteOutputDir(pkg));
   try {
     await access5(output);
     throw new Error("Website output already exists; build through the staged package workflow.");
@@ -71494,9 +71563,9 @@ async function writePackageSite(input) {
     if (error.code !== "ENOENT")
       throw error;
   }
-  const temporaryRoot = join56(projectRoot, ".tmp");
+  const temporaryRoot = join57(projectRoot, ".tmp");
   await mkdir20(temporaryRoot, { recursive: true });
-  const temporary = await mkdtemp(join56(temporaryRoot, "website-"));
+  const temporary = await mkdtemp(join57(temporaryRoot, "website-"));
   try {
     const registry2 = await loadSourcesRegistry({ rootDir: projectRoot });
     const sourceContent = new Map(selected.map((file) => [packageKnowledgeOutputPath(pkg, file.relPath), file]));
@@ -71506,7 +71575,7 @@ async function writePackageSite(input) {
     for (const file of delivered) {
       if (!/^(?:skills|wikis|guides|rules|feats)\/.*\.md$/u.test(file.relPath) || byPath.has(file.relPath))
         continue;
-      const content3 = await readFile47(file.absPath, "utf8");
+      const content3 = await readFile48(file.absPath, "utf8");
       const meta = parseKnowledgeFrontmatter(content3);
       const page = {
         package_path: file.relPath,
@@ -71517,20 +71586,20 @@ 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 = join56(temporary, ".vitepress");
-    await mkdir20(join56(configRoot, "theme"), { recursive: true });
-    await mkdir20(join56(temporary, "node_modules"), { recursive: true });
+    const configRoot = join57(temporary, ".vitepress");
+    await mkdir20(join57(configRoot, "theme"), { recursive: true });
+    await mkdir20(join57(temporary, "node_modules"), { recursive: true });
     const vitepressRoot = dirname24(require2.resolve("vitepress/package.json"));
-    const vueRequire = createRequire5(join56(vitepressRoot, "package.json"));
+    const vueRequire = createRequire5(join57(vitepressRoot, "package.json"));
     for (const [name2, path2] of [
       ["vitepress", vitepressRoot],
       ["vue", dirname24(vueRequire.resolve("vue/package.json"))],
       ["mermaid", dirname24(require2.resolve("mermaid/package.json"))]
     ]) {
-      await symlink2(path2, join56(temporary, "node_modules", name2), "dir");
+      await symlink2(path2, join57(temporary, "node_modules", name2), "dir");
     }
-    await writeFile15(join56(configRoot, "theme/index.js"), siteThemeScript);
-    await writeFile15(join56(configRoot, "theme/style.css"), siteThemeCss);
+    await writeFile16(join57(configRoot, "theme/index.js"), siteThemeScript);
+    await writeFile16(join57(configRoot, "theme/style.css"), siteThemeCss);
     await writeSiteExtensions(projectRoot, temporary, options.extensions);
     const config = {
       title: options.title ?? pkg.name,
@@ -71556,11 +71625,11 @@ async function writePackageSite(input) {
         nav: [...sections.map((section) => ({ text: section.title, link: section.href })), { text: "更多", items: [{ text: "LLM Docs", link: "/llms/index.html" }, { text: "Changelog", link: "/changelog.html" }] }]
       }
     };
-    await writeFile15(join56(configRoot, "config.mjs"), `export default { ...${JSON.stringify(config)}, markdown: { ${siteMarkdownConfig} } };
+    await writeFile16(join57(configRoot, "config.mjs"), `export default { ...${JSON.stringify(config)}, markdown: { ${siteMarkdownConfig} } };
 `);
-    await mkdir20(join56(temporary, "pages"), { recursive: true });
+    await mkdir20(join57(temporary, "pages"), { recursive: true });
     for (const page of byPath.values()) {
-      const content3 = await readFile47(join56(root, page.package_path), "utf8");
+      const content3 = await readFile48(join57(root, page.package_path), "utf8");
       const original = sourceContent.get(page.package_path);
       const provenance = articleProvenanceMarkdown(original?.article, registry2);
       const pageContent = provenance && content3.endsWith(provenance) ? content3.slice(0, -provenance.length) : content3;
@@ -71568,7 +71637,7 @@ async function writePackageSite(input) {
       const sources = siteArticleSources(original?.article, registry2);
       const timestamp = parseKnowledgeFrontmatter(original?.content ?? content3).timestamp;
       const updated = typeof timestamp === "string" && Number.isFinite(Date.parse(timestamp)) ? new Date(timestamp).toISOString() : null;
-      await writeFile15(join56(temporary, page.site_path.replace(/\.html$/u, ".md")), `---
+      await writeFile16(join57(temporary, page.site_path.replace(/\.html$/u, ".md")), `---
 title: ${JSON.stringify(page.title)}
 contextSources: ${JSON.stringify(sources)}
 contextUpdated: ${JSON.stringify(updated)}
@@ -71580,11 +71649,11 @@ ${body}`);
       lines.push(`${"  ".repeat(level)}- ${entry.href ? `[${mdLabel(entry.title)}](${entry.href})` : mdLabel(entry.title)}`);
       menu(lines, entry.children, level + 1);
     });
-    await mkdir20(join56(temporary, "sections"), { recursive: true });
+    await mkdir20(join57(temporary, "sections"), { recursive: true });
     for (const section of sections) {
       const lines = [`# ${mdLabel(section.title)}`, ""];
       menu(lines, section.entries, 0);
-      await writeFile15(join56(temporary, section.href.slice(1).replace(/\.html$/u, ".md")), lines.join(`
+      await writeFile16(join57(temporary, section.href.slice(1).replace(/\.html$/u, ".md")), lines.join(`
 `) + `
 `);
     }
@@ -71603,12 +71672,12 @@ ${body}`);
     };
     const homeHero = options.extensions?.slots?.banner === undefined ? `hero: ${JSON.stringify(hero)}
 ` : "";
-    await writeFile15(join56(temporary, "index.md"), `---
+    await writeFile16(join57(temporary, "index.md"), `---
 layout: home
 title: ${JSON.stringify(options.home?.title ?? options.title ?? pkg.name)}
 ${homeHero}---
 `);
-    await writeFile15(join56(temporary, "changelog.md"), `---
+    await writeFile16(join57(temporary, "changelog.md"), `---
 title: Changelog
 contextHistory: ${JSON.stringify(Buffer.from(JSON.stringify(history)).toString("base64"))}
 ---
@@ -71621,19 +71690,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 readFile47(join56(root, article.path), "utf8")
+        content: await readFile48(join57(root, article.path), "utf8")
       }))),
       ...structure ? { map: structure } : {}
     });
-    await writeLlmsDocuments(join56(temporary, "public"), llms, { utf8Bom: true });
-    await mkdir20(join56(temporary, "llms"), { recursive: true });
+    await writeLlmsDocuments(join57(temporary, "public"), llms, { utf8Bom: true });
+    await mkdir20(join57(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 writeFile15(join56(temporary, "llms/index.md"), `---
+    await writeFile16(join57(temporary, "llms/index.md"), `---
 title: LLM Docs
 ---
 
@@ -71643,9 +71712,9 @@ title: LLM Docs
 
 ` + landingNavigation);
     for (const path2 of resources) {
-      const destination = join56(temporary, "public/resources", path2);
+      const destination = join57(temporary, "public/resources", path2);
       await mkdir20(dirname24(destination), { recursive: true });
-      await cp(join56(root, path2), destination);
+      await cp(join57(root, path2), destination);
     }
     await compileSite(temporary, output);
     for (const file of await walkPackageFiles(output)) {
@@ -71654,10 +71723,11 @@ title: LLM Docs
 ` : [".html", ".htm"].includes(extension2) ? `<!-- Intentionally empty. -->
 ` : null;
       if (placeholder !== null && (await stat6(file.absPath)).size === 0) {
-        await writeFile15(file.absPath, placeholder);
+        await writeFile16(file.absPath, placeholder);
       }
     }
-    await writeFile15(join56(output, "context-site-map.json"), JSON.stringify({
+    const siteMapContent = JSON.stringify({
+      ...input.siteUrl ? { site_url: input.siteUrl } : {},
       protocol: "context.site-output/v1",
       knowledge_map_revision: structure?.revision ?? null,
       base,
@@ -71667,7 +71737,9 @@ title: LLM Docs
       sections: sections.map(({ key, title, href, pages, items }) => ({ key, title, href, pages, items })),
       warnings: mapping.warnings
     }, null, 2) + `
-`);
+`;
+    await writeFile16(join57(output, "context-site-map.json"), siteMapContent);
+    await writeFile16(join57(projectRoot, pkg.outDir, "context-site-map.json"), siteMapContent);
     return mapping;
   } finally {
     await rm11(temporary, { recursive: true, force: true });
@@ -71687,13 +71759,13 @@ var init_packageSite2 = __esm(() => {
   init_packageSiteTheme();
   init_packageSiteBranding();
   init_packageSiteExtensions();
-  PACKAGE_SITE_VERSION = `vitepress-site-v43-page-extensions:${createHash16("sha256").update(JSON.stringify([siteMarkdownConfig, siteThemeCss, siteThemeScript, siteThemeLabels("zh"), siteThemeLabels("en")])).digest("hex")}`;
+  PACKAGE_SITE_VERSION = `vitepress-site-v44-site-address:${createHash16("sha256").update(JSON.stringify([siteMarkdownConfig, siteThemeCss, siteThemeScript, siteThemeLabels("zh"), siteThemeLabels("en")])).digest("hex")}`;
   require2 = createRequire5(import.meta.url);
 });
 
 // src/project/workspaceBuildVersion.ts
-import { join as join57 } from "node:path";
-import { mkdir as mkdir21, writeFile as writeFile16 } from "node:fs/promises";
+import { join as join58 } from "node:path";
+import { mkdir as mkdir21, writeFile as writeFile17 } from "node:fs/promises";
 async function workspaceVersionFingerprint(root) {
   return { version: await workspaceVersion(root), changelog: await readWorkspaceChangelog(root) };
 }
@@ -71704,8 +71776,8 @@ async function writePackageVersion(projectRoot, output) {
       throw new TypeError(`Package template uses reserved version output ${path2}; rename that template output.`);
   }
   await mkdir21(output, { recursive: true });
-  await writeFile16(join57(output, "CHANGELOG.md"), renderChangelog(info.changelog));
-  await writeFile16(join57(output, "context-version.json"), JSON.stringify({ version: info.version }) + `
+  await writeFile17(join58(output, "CHANGELOG.md"), renderChangelog(info.changelog));
+  await writeFile17(join58(output, "context-version.json"), JSON.stringify({ version: info.version }) + `
 `);
 }
 var init_workspaceBuildVersion = __esm(() => {
@@ -71714,14 +71786,14 @@ var init_workspaceBuildVersion = __esm(() => {
 
 // src/project/packageRenderCache.ts
 import { createHash as createHash17 } from "node:crypto";
-import { readFile as readFile48 } from "node:fs/promises";
-import { join as join58 } from "node:path";
+import { readFile as readFile49 } from "node:fs/promises";
+import { join as join59 } from "node:path";
 async function cachedPackageKnowledgeMarkdown(input) {
   const fingerprint = digest3(`${PACKAGE_READER_MARKDOWN_VERSION}
 ${input.content}`);
-  const path2 = join58(input.projectRoot, ".tmp/context-runtime/package-render", `${digest3(input.key)}.json`);
+  const path2 = join59(input.projectRoot, ".tmp/context-runtime/package-render", `${digest3(input.key)}.json`);
   try {
-    const cached = JSON.parse(await readFile48(path2, "utf8"));
+    const cached = JSON.parse(await readFile49(path2, "utf8"));
     if (cached !== null && typeof cached === "object" && "fingerprint" in cached && cached.fingerprint === fingerprint && "markdown" in cached && typeof cached.markdown === "string") {
       return cached.markdown;
     }
@@ -71760,7 +71832,7 @@ var init_packageKnowledgeAdvisories = __esm(() => {
 
 // src/project/packageMarkdownAnchors.ts
 import { posix as posix7 } from "node:path";
-import { readFile as readFile49 } from "node:fs/promises";
+import { readFile as readFile50 } from "node:fs/promises";
 function packageMarkdownAnchors(markdown) {
   const anchors = new Set;
   const used = new Set;
@@ -71823,7 +71895,7 @@ async function inspectPackageMarkdownDirectory(root) {
   const files = (await walkPackageFiles(root)).filter((file) => /\.md$/iu.test(file.relPath));
   const pages = new Map;
   for (let offset = 0;offset < files.length; offset += 16) {
-    const batch = await Promise.allSettled(files.slice(offset, offset + 16).map(async (file) => [file.relPath, await readFile49(file.absPath, "utf8")]));
+    const batch = await Promise.allSettled(files.slice(offset, offset + 16).map(async (file) => [file.relPath, await readFile50(file.absPath, "utf8")]));
     for (const result of batch) {
       if (result.status === "rejected")
         throw result.reason;
@@ -71840,23 +71912,23 @@ var init_packageMarkdownAnchors = __esm(() => {
 });
 
 // src/project/packageBuildStage.ts
-import { mkdir as mkdir22, mkdtemp as mkdtemp2, readFile as readFile50, rename as rename5, rm as rm12, rmdir } from "node:fs/promises";
-import { dirname as dirname25, join as join59, relative as relative16 } from "node:path";
+import { mkdir as mkdir22, mkdtemp as mkdtemp2, readFile as readFile51, rename as rename6, rm as rm12, rmdir } from "node:fs/promises";
+import { dirname as dirname25, join as join60, relative as relative16 } from "node:path";
 async function withStagedPackageOutput(projectRoot, pkg, render) {
-  const tempRoot = join59(projectRoot, ".tmp");
+  const tempRoot = join60(projectRoot, ".tmp");
   await mkdir22(tempRoot, { recursive: true });
-  const stage = await mkdtemp2(join59(tempRoot, "package-build-"));
-  const stagedPackage = { ...pkg, outDir: relative16(projectRoot, join59(stage, pkg.name)) };
+  const stage = await mkdtemp2(join60(tempRoot, "package-build-"));
+  const stagedPackage = { ...pkg, outDir: relative16(projectRoot, join60(stage, pkg.name)) };
   try {
-    await mkdir22(join59(projectRoot, stagedPackage.outDir), { recursive: true });
+    await mkdir22(join60(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 = join59(projectRoot, destination);
+      const target = join60(projectRoot, destination);
       const previous2 = await walkPackageFiles(target);
-      const next = await walkPackageFiles(join59(projectRoot, staged[index2]));
+      const next = await walkPackageFiles(join60(projectRoot, staged[index2]));
       const desired = new Set(next.map((file) => file.relPath));
       for (const file of previous2) {
         if (desired.has(file.relPath))
@@ -71874,9 +71946,9 @@ async function withStagedPackageOutput(projectRoot, pkg, render) {
       }
       for (let offset = 0;offset < next.length; offset += 8) {
         const results = await Promise.allSettled(next.slice(offset, offset + 8).map(async (file) => {
-          const output = join59(target, file.relPath);
-          const bytes = await readFile50(file.absPath);
-          const old = await readFile50(output).catch((error) => {
+          const output = join60(target, file.relPath);
+          const bytes = await readFile51(file.absPath);
+          const old = await readFile51(output).catch((error) => {
             if (error.code === "ENOENT")
               return;
             throw error;
@@ -71884,7 +71956,7 @@ async function withStagedPackageOutput(projectRoot, pkg, render) {
           if (old?.equals(bytes))
             return;
           await mkdir22(dirname25(output), { recursive: true });
-          await rename5(file.absPath, output);
+          await rename6(file.absPath, output);
         }));
         for (const result of results)
           if (result.status === "rejected")
@@ -71947,7 +72019,7 @@ var init_packageArticleLinks = __esm(() => {
 });
 
 // src/project/packageAssets.ts
-import { readFile as readFile51 } from "node:fs/promises";
+import { readFile as readFile52 } from "node:fs/promises";
 import { dirname as dirname26, relative as relative17, sep as sep4 } from "node:path";
 function posixPath2(value) {
   return value.split(sep4).join("/");
@@ -71986,7 +72058,7 @@ async function projectPackageKnowledgeAssets(input) {
     const paths = packageAssetPath(input.projectRoot, absolute);
     let bytes;
     try {
-      bytes = await readFile51(absolute);
+      bytes = await readFile52(absolute);
     } catch {
       throw new ContextError(ExitCode.WorkspaceStateError, `knowledge resource is missing: ${paths.knowledgeRelPath}`, {
         category: ErrorCategory.WorkspaceStateInvalid,
@@ -72260,7 +72332,7 @@ var init_packageAssetOptimization = __esm(() => {
 // src/project/packageAssetDelivery.ts
 import { execFile as execFile8 } from "node:child_process";
 import { realpath as realpath7 } from "node:fs/promises";
-import { join as join60, relative as relative18, sep as sep5 } from "node:path";
+import { join as join61, relative as relative18, sep as sep5 } from "node:path";
 import { promisify as promisify8 } from "node:util";
 async function git(projectRoot, args) {
   try {
@@ -72280,7 +72352,7 @@ async function git(projectRoot, args) {
   }
 }
 function repositoryPath(repoRoot, projectRoot, asset) {
-  const path2 = relative18(repoRoot, join60(projectRoot, asset.knowledgeRelPath)).split(sep5).join("/");
+  const path2 = relative18(repoRoot, join61(projectRoot, asset.knowledgeRelPath)).split(sep5).join("/");
   if (path2 === ".." || path2.startsWith("../") || path2.startsWith("/")) {
     throw new ContextError(ExitCode.WorkspaceStateError, "knowledge asset is outside the current Git repository", {
       category: ErrorCategory.WorkspaceStateInvalid,
@@ -72459,8 +72531,8 @@ var init_packageAssetDelivery = __esm(() => {
 
 // src/project/packageBuildContent.ts
 import { existsSync as existsSync16 } from "node:fs";
-import { mkdir as mkdir23, readFile as readFile52, writeFile as writeFile17 } from "node:fs/promises";
-import { dirname as dirname28, join as join61 } from "node:path";
+import { mkdir as mkdir23, readFile as readFile53, writeFile as writeFile18 } from "node:fs/promises";
+import { dirname as dirname28, join as join62 } from "node:path";
 function globToRegExp(pattern) {
   const normalized = toPosixPath4(pattern);
   if (normalized.endsWith("/**")) {
@@ -72601,9 +72673,9 @@ async function writeRenderedPackageTemplate(input) {
       templateRelPath: renderedRelPath,
       logicalTemplateRelPath: renderedLogicalRelPath
     });
-    const outputPath = join61(input.projectRoot, input.pkg.outDir, renderedRelPath);
+    const outputPath = join62(input.projectRoot, input.pkg.outDir, renderedRelPath);
     await mkdir23(dirname28(outputPath), { recursive: true });
-    await writeFile17(outputPath, renderTemplateText(file.content, contentVars), "utf8");
+    await writeFile18(outputPath, renderTemplateText(file.content, contentVars), "utf8");
     written++;
   }
   return { files: written, consumesKnowledge };
@@ -72634,7 +72706,7 @@ async function writeSelectedPackageKnowledge(input) {
   for (let offset = 0;offset < projectedPages.length; offset += 8) {
     const results = await Promise.allSettled(projectedPages.slice(offset, offset + 8).map(async (projected) => {
       assertSafeRenderedPath2(projected.pageOutputPath, "knowledge path");
-      const outputPath = join61(input.projectRoot, input.pkg.outDir, projected.pageOutputPath);
+      const outputPath = join62(input.projectRoot, input.pkg.outDir, projected.pageOutputPath);
       const rewritten = replaceMarkdownInlineLinkTargets(projected.content, (link) => {
         for (const [inputPath, outputPath2] of delivered.targetByOriginal) {
           if (link.target === packageMarkdownTarget(projected.pageOutputPath, inputPath)) {
@@ -72651,7 +72723,7 @@ async function writeSelectedPackageKnowledge(input) {
         content: links.markdown
       });
       const file = byPath.get(approvedByOutput.get(projected.pageOutputPath));
-      await writeFile17(outputPath, markdown + articleProvenanceMarkdown(file?.article, registry2), "utf8");
+      await writeFile18(outputPath, markdown + articleProvenanceMarkdown(file?.article, registry2), "utf8");
       return links.warnings;
     }));
     for (const result of results) {
@@ -72663,9 +72735,9 @@ async function writeSelectedPackageKnowledge(input) {
   const deliveredAssets = new Map(delivered.assets.map((asset) => [asset.packageRelPath, asset]));
   for (const asset of deliveredAssets.values()) {
     assertSafeRenderedPath2(asset.packageRelPath, "package resource path");
-    const outputPath = join61(input.projectRoot, input.pkg.outDir, asset.packageRelPath);
+    const outputPath = join62(input.projectRoot, input.pkg.outDir, asset.packageRelPath);
     await mkdir23(dirname28(outputPath), { recursive: true });
-    await writeFile17(outputPath, asset.bytes);
+    await writeFile18(outputPath, asset.bytes);
   }
   return {
     pages: projectedPages.length,
@@ -72678,9 +72750,9 @@ async function writeSelectedPackageKnowledge(input) {
 async function appendLlmsKnowledge(input) {
   if (packageKind2(input.pkg) !== "llms" || input.templateConsumesKnowledge || input.knowledgeCount === 0)
     return 0;
-  const outputPath = join61(input.projectRoot, input.pkg.outDir, "llms.txt");
+  const outputPath = join62(input.projectRoot, input.pkg.outDir, "llms.txt");
   const existed = existsSync16(outputPath);
-  const existing = existed ? await readFile52(outputPath, "utf8") : "";
+  const existing = existed ? await readFile53(outputPath, "utf8") : "";
   const content3 = existing.trim().length > 0 ? `${existing.trimEnd()}
 
 ---
@@ -72689,7 +72761,7 @@ ${input.bundle}
 ` : `${input.bundle}
 `;
   await mkdir23(dirname28(outputPath), { recursive: true });
-  await writeFile17(outputPath, content3, "utf8");
+  await writeFile18(outputPath, content3, "utf8");
   return existed ? 0 : 1;
 }
 var init_packageBuildContent = __esm(() => {
@@ -72904,8 +72976,8 @@ __export(exports_packageBuilder, {
 });
 import { createHash as createHash19 } from "node:crypto";
 import { existsSync as existsSync17 } from "node:fs";
-import { mkdir as mkdir24, readdir as readdir15, readFile as readFile53, rm as rm13, writeFile as writeFile18 } from "node:fs/promises";
-import { dirname as dirname29, join as join62, resolve as resolve20 } from "node:path";
+import { mkdir as mkdir24, readdir as readdir15, readFile as readFile54, rm as rm13, writeFile as writeFile19 } from "node:fs/promises";
+import { dirname as dirname29, join as join63, resolve as resolve20 } from "node:path";
 function packageAssetDeliverySummary(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     return;
@@ -72927,7 +72999,7 @@ function assertPackageOutputDir(pkg) {
 }
 function packageFingerprintPath(projectRoot, pkg) {
   assertSafeRenderedPath2(`${pkg.name}.json`, "package fingerprint path");
-  return join62(projectRoot, PACKAGE_FINGERPRINT_ROOT, `${pkg.name}.json`);
+  return join63(projectRoot, PACKAGE_FINGERPRINT_ROOT, `${pkg.name}.json`);
 }
 async function listApprovedKnowledge(projectRoot) {
   const metadata = await readApprovedKnowledgeMetadataIndex(projectRoot);
@@ -72968,7 +73040,7 @@ async function listTemplateFiles(projectRoot, templatePath) {
   const files = await walkPackageFiles(templateRoot);
   return Promise.all(files.filter((file) => file.relPath.split("/").at(-1) !== PACKAGE_TEMPLATE_REVIEW_FILE).map(async (file) => ({
     ...file,
-    content: await readFile53(file.absPath, "utf8")
+    content: await readFile54(file.absPath, "utf8")
   })));
 }
 function stableHash2(value) {
@@ -73031,7 +73103,7 @@ async function readPackageManifest(projectRoot, pkg) {
   if (!existsSync17(filePath2))
     return null;
   try {
-    const parsed = JSON.parse(await readFile53(filePath2, "utf8"));
+    const parsed = JSON.parse(await readFile54(filePath2, "utf8"));
     if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
       const candidate = parsed;
       if (typeof candidate.builder_protocol === "string" && typeof candidate.fingerprint === "string" && typeof candidate.output_fingerprint === "string" && typeof candidate.output_files === "number" && Array.isArray(candidate.outputs)) {
@@ -73063,7 +73135,7 @@ async function readPackageManifest(projectRoot, pkg) {
 async function writePackageFingerprint(input) {
   const filePath2 = packageFingerprintPath(input.projectRoot, input.pkg);
   await mkdir24(dirname29(filePath2), { recursive: true });
-  await writeFile18(filePath2, `${JSON.stringify({
+  await writeFile19(filePath2, `${JSON.stringify({
     package: input.pkg.name,
     kind: packageKind2(input.pkg),
     builder_protocol: PACKAGE_BUILDER_PROTOCOL_VERSION,
@@ -73078,12 +73150,12 @@ async function writePackageFingerprint(input) {
 `, "utf8");
 }
 async function removeOrphanPackageDirs(projectRoot, packages) {
-  const distRoot = join62(projectRoot, "dist");
+  const distRoot = join63(projectRoot, "dist");
   if (!existsSync17(distRoot))
     return;
   const declaredNames = new Set(packages.flatMap((pkg) => packageOutputDirs(pkg).map((path2) => path2.slice("dist/".length))));
   const entries2 = await readdir15(distRoot, { withFileTypes: true });
-  await Promise.all(entries2.filter((entry) => entry.isDirectory() && !declaredNames.has(entry.name)).map((entry) => rm13(join62(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) => rm13(join63(distRoot, entry.name), { recursive: true, force: true, maxRetries: 3, retryDelay: 100 })));
 }
 async function collectPackageFreshness(projectRoot, packages) {
   assertDistinctPackageOutputs(packages);
@@ -73092,7 +73164,7 @@ async function collectPackageFreshness(projectRoot, packages) {
     assertPackageOutputDir(pkg);
     const selected = selectPackageKnowledge(approved, pkg);
     assertSafeRenderedPath2(pkg.template.path, "package template path");
-    const templateRoot = join62(projectRoot, pkg.template.path);
+    const templateRoot = join63(projectRoot, pkg.template.path);
     const templateExists = existsSync17(templateRoot);
     if (!templateExists) {
       throw new ContextError(ExitCode.WorkspaceStateError, `package template path is missing: ${pkg.template.path}`, {
@@ -73283,6 +73355,7 @@ async function buildProjectPackagesInternal(projectRoot, options) {
       files: selected,
       ...assetProcessor === undefined ? {} : { assetProcessor }
     });
+    const siteUrl = await readPackageSiteUrl(projectRoot, pkg);
     const writtenKnowledge = await withStagedPackageOutput(projectRoot, pkg, async (stagedPkg) => {
       const rendered = await writeRenderedPackageTemplate({
         projectRoot,
@@ -73320,19 +73393,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 readFile53(join62(projectRoot, stagedPkg.outDir, article.path), "utf8")
+          content: await readFile54(join63(projectRoot, stagedPkg.outDir, article.path), "utf8")
         })));
-        await writeLlmsDocuments(join62(projectRoot, stagedPkg.outDir), buildLlmsDocuments({
+        await writeLlmsDocuments(join63(projectRoot, stagedPkg.outDir), buildLlmsDocuments({
           title: stagedPkg.name,
           articles,
           ...reading ? { map: reading } : {}
         }), { preserveIndex: true });
       }
-      await writePackageVersion(projectRoot, join62(projectRoot, stagedPkg.outDir));
-      await writePackageSite({ projectRoot, pkg: stagedPkg, selected, ...reading ? { structure: reading } : {} });
+      await writePackageVersion(projectRoot, join63(projectRoot, stagedPkg.outDir));
+      await writePackageSite({ projectRoot, pkg: stagedPkg, selected, ...siteUrl ? { siteUrl } : {}, ...reading ? { structure: reading } : {} });
       const linkWarnings = [
         ...writtenKnowledge2.linkWarnings,
-        ...await inspectPackageMarkdownDirectory(join62(projectRoot, stagedPkg.outDir))
+        ...await inspectPackageMarkdownDirectory(join63(projectRoot, stagedPkg.outDir))
       ];
       return { ...writtenKnowledge2, linkWarnings };
     });
@@ -73483,6 +73556,7 @@ async function runProjectBuildCommand(input) {
 }
 var import_yaml35, PACKAGE_FINGERPRINT_ROOT, PACKAGE_BUILDER_PROTOCOL_VERSION = "v23-sibling-site-output";
 var init_packageBuilder = __esm(() => {
+  init_packageSiteAddress();
   init_knowledgeMap2();
   init_approvedFileRead();
   init_productionStageStore();
@@ -73520,7 +73594,7 @@ var init_packageBuilder = __esm(() => {
   init_packageTemplateReview();
   init_approvedKnowledgeMetadata();
   import_yaml35 = __toESM(require_dist(), 1);
-  PACKAGE_FINGERPRINT_ROOT = join62(".tmp", "context-runtime", "packages");
+  PACKAGE_FINGERPRINT_ROOT = join63(".tmp", "context-runtime", "packages");
 });
 
 // src/project/taskRollback.ts
@@ -73530,8 +73604,8 @@ __export(exports_taskRollback, {
   readTaskRollback: () => readTaskRollback,
   finishTaskRollback: () => finishTaskRollback
 });
-import { readFile as readFile54 } from "node:fs/promises";
-import { join as join63 } from "node:path";
+import { readFile as readFile55 } from "node:fs/promises";
+import { join as join64 } 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")
@@ -73540,7 +73614,7 @@ async function readTaskRollback(projectRoot) {
 }
 async function contents(projectRoot, path2) {
   try {
-    return await readFile54(join63(projectRoot, path2), "utf8");
+    return await readFile55(join64(projectRoot, path2), "utf8");
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
       return;
@@ -73707,12 +73781,12 @@ __export(exports_knowledgeUpdate, {
   completeKnowledgeUpdate: () => completeKnowledgeUpdate,
   beginKnowledgeUpdate: () => beginKnowledgeUpdate
 });
-import { readFile as readFile55 } from "node:fs/promises";
-import { join as join64 } from "node:path";
+import { readFile as readFile56 } from "node:fs/promises";
+import { join as join65 } from "node:path";
 async function readKnowledgeUpdate(projectRoot) {
   let value;
   try {
-    value = JSON.parse(await readFile55(join64(projectRoot, await revisionStoragePath(projectRoot)), "utf8"));
+    value = JSON.parse(await readFile56(join65(projectRoot, await revisionStoragePath(projectRoot)), "utf8"));
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
       return;
@@ -73763,7 +73837,7 @@ async function beginKnowledgeUpdate(projectRoot, value) {
       ...input.changes === undefined ? {} : { changes: input.changes }
     };
     const request = updateSchema.parse({ ...payload, revision: indexerProtocolDigest(payload) });
-    await atomicWriteFile(join64(projectRoot, await revisionStoragePath(projectRoot)), `${JSON.stringify(request)}
+    await atomicWriteFile(join65(projectRoot, await revisionStoragePath(projectRoot)), `${JSON.stringify(request)}
 `);
     return {
       outcome: "update-prepared",
@@ -73808,7 +73882,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(join64(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify({ ...payload, revision: indexerProtocolDigest(payload) })}
+      await atomicWriteFile(join65(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify({ ...payload, revision: indexerProtocolDigest(payload) })}
 `);
       return { outcome: "structure-review-required" };
     }
@@ -73845,7 +73919,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(join64(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify({ ...payload, revision: indexerProtocolDigest(payload) })}
+    await atomicWriteFile(join65(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify({ ...payload, revision: indexerProtocolDigest(payload) })}
 `);
     return { outcome: "structure-adjustment-required" };
   });
@@ -74018,15 +74092,15 @@ __export(exports_knowledgeMaintenance, {
   cancelKnowledgeMaintenance: () => cancelKnowledgeMaintenance,
   advanceKnowledgeMaintenance: () => advanceKnowledgeMaintenance
 });
-import { readFile as readFile56, readdir as readdir16, rm as rm14 } from "node:fs/promises";
-import { join as join65 } from "node:path";
+import { readFile as readFile57, readdir as readdir16, rm as rm14 } from "node:fs/promises";
+import { join as join66 } from "node:path";
 async function deliveryDigest(root) {
-  const directory = join65(root, ".tmp/context-runtime/packages");
+  const directory = join66(root, ".tmp/context-runtime/packages");
   try {
     const files = (await readdir16(directory)).filter((name2) => name2.endsWith(".json")).sort();
     if (!files.length)
       return indexerProtocolDigest(null);
-    return indexerProtocolDigest(await Promise.all(files.map((name2) => readFile56(join65(directory, name2), "utf8"))));
+    return indexerProtocolDigest(await Promise.all(files.map((name2) => readFile57(join66(directory, name2), "utf8"))));
   } catch (error) {
     if (error.code === "ENOENT")
       return indexerProtocolDigest(null);
@@ -74125,7 +74199,7 @@ async function observeKnowledgeMaintenance(root) {
 async function maintenanceRevision(root) {
   const observed = await observeKnowledgeMaintenance(root);
   const localInputs = observed.state.active ? {
-    revision: await readFile56(join65(root, MAINTENANCE_ROOT, "revision.json"), "utf8").catch((error) => {
+    revision: await readFile57(join66(root, MAINTENANCE_ROOT, "revision.json"), "utf8").catch((error) => {
       if (error.code === "ENOENT")
         return null;
       throw error;
@@ -74202,7 +74276,7 @@ async function finishMaintenanceRevision(root, outcome = "completed") {
   outcome = state.active.completion_outcome;
   state.active.phase = "finishing";
   await saveMaintenance(root, state);
-  await rm14(join65(root, MAINTENANCE_ROOT, "revision.json"), { force: true });
+  await rm14(join66(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);
@@ -74236,8 +74310,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 rm14(join65(root, CANDIDATE_LEDGER_FILE), { force: true });
-  await rm14(join65(root, MAINTENANCE_ROOT, "revision.json"), { force: true });
+  await rm14(join66(root, CANDIDATE_LEDGER_FILE), { force: true });
+  await rm14(join66(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);
@@ -74275,8 +74349,8 @@ __export(exports_approvedRevision, {
   assertApprovedRevisionBase: () => assertApprovedRevisionBase,
   APPROVED_REVISION_PATH: () => APPROVED_REVISION_PATH
 });
-import { readFile as readFile57, realpath as realpath8, rm as rm15 } from "node:fs/promises";
-import { join as join66, relative as relative19, isAbsolute as isAbsolute12 } from "node:path";
+import { readFile as readFile58, realpath as realpath8, rm as rm15 } from "node:fs/promises";
+import { join as join67, relative as relative19, isAbsolute as isAbsolute12 } from "node:path";
 function requestDigest(input) {
   const scopes = input.processed_scopes?.filter((scope2) => input.target.source_refs.some((ref) => ref === scope2.source_ref || ref.startsWith(`${scope2.source_ref}#`) || ref.startsWith(`${scope2.source_ref}/`)));
   const ids = new Set(scopes?.map((scope2) => scope2.requirement_ref));
@@ -74314,7 +74388,7 @@ function revisionCandidateFingerprint(revision, markdown, sections) {
 }
 async function readApprovedRevision(projectRoot) {
   try {
-    return parseApprovedRevision(JSON.parse(await readFile57(join66(projectRoot, await revisionStoragePath(projectRoot)), "utf8")));
+    return parseApprovedRevision(JSON.parse(await readFile58(join67(projectRoot, await revisionStoragePath(projectRoot)), "utf8")));
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
       return;
@@ -74373,16 +74447,16 @@ async function resolveApprovedRevisionAuthor(projectRoot, request) {
 }
 async function targetBytes(projectRoot, path2) {
   const project = await realpath8(projectRoot);
-  const root = await realpath8(join66(projectRoot, "knowledge"));
+  const root = await realpath8(join67(projectRoot, "knowledge"));
   const rootRelative = relative19(project, root);
   if (isAbsolute12(rootRelative) || rootRelative === ".." || rootRelative.startsWith("../")) {
     throw new TypeError("Approved knowledge directory leaves the Context workspace");
   }
-  const target = await realpath8(join66(root, path2));
+  const target = await realpath8(join67(root, path2));
   const rel = relative19(root, target);
   if (isAbsolute12(rel) || rel === ".." || rel.startsWith("../"))
     throw new TypeError("Approved revision target leaves knowledge/");
-  return readFile57(target, "utf8");
+  return readFile58(target, "utf8");
 }
 async function assertApprovedRevisionBase(projectRoot, request) {
   let current;
@@ -74534,7 +74608,7 @@ ${import_yaml36.default.stringify({ ...import_yaml36.default.parse(fields), type
       revision: requestDigest(payload)
     });
     if (input.persist !== false)
-      await atomicWriteFile(join66(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify(request)}
+      await atomicWriteFile(join67(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify(request)}
 `);
     return {
       status: "author-reopened",
@@ -74645,17 +74719,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(join66(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify(next2 ?? { ...request, review_ready: true })}
+        await atomicWriteFile(join67(input.projectRoot, await revisionStoragePath(input.projectRoot)), `${JSON.stringify(next2 ?? { ...request, review_ready: true })}
 `);
       } else {
         await advanceApprovedRevision(input.projectRoot, request);
       }
       return;
     }
-    const current = await readFile57(join66(input.projectRoot, await revisionStoragePath(input.projectRoot)), "utf8");
+    const current = await readFile58(join67(input.projectRoot, await revisionStoragePath(input.projectRoot)), "utf8");
     let previous2;
     try {
-      previous2 = await readFile57(join66(input.projectRoot, CANDIDATE_LEDGER_FILE), "utf8");
+      previous2 = await readFile58(join67(input.projectRoot, CANDIDATE_LEDGER_FILE), "utf8");
     } catch (error) {
       if (!(error && typeof error === "object" && ("code" in error) && error.code === "ENOENT"))
         throw error;
@@ -74737,7 +74811,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 rm15(join66(projectRoot, await revisionStoragePath(projectRoot)), { force: true });
+    await rm15(join67(projectRoot, await revisionStoragePath(projectRoot)), { force: true });
     return;
   }
   const { clearCompletedLifecycle: clearCompletedLifecycle2 } = await Promise.resolve().then(() => (init_lifecycleCleanup(), exports_lifecycleCleanup));
@@ -74808,12 +74882,12 @@ async function reopenApprovedRevision(input) {
         }))
       } : {}
     } };
-    const current = await readFile57(join66(input.projectRoot, await revisionStoragePath(input.projectRoot)), "utf8");
+    const current = await readFile58(join67(input.projectRoot, await revisionStoragePath(input.projectRoot)), "utf8");
     const content3 = `${JSON.stringify({ ...payload, revision: requestDigest(payload) })}
 `;
     let ledger;
     try {
-      ledger = await readFile57(join66(input.projectRoot, CANDIDATE_LEDGER_FILE), "utf8");
+      ledger = await readFile58(join67(input.projectRoot, CANDIDATE_LEDGER_FILE), "utf8");
     } catch (error) {
       if (!(error && typeof error === "object" && ("code" in error) && error.code === "ENOENT"))
         throw error;
@@ -80856,7 +80930,7 @@ var require_acorn_jsx = __commonJS((exports, module) => {
 
 // src/project/documentRun.ts
 import { existsSync as existsSync18 } from "node:fs";
-import { join as join69 } from "node:path";
+import { join as join70 } from "node:path";
 function isDocumentPhase(phase) {
   return phase.kind === "phase.capture.file" || phase.kind === "phase.capture.lark";
 }
@@ -81038,7 +81112,7 @@ async function previewDocumentPhase(input) {
     },
     snapshot: {
       manifest,
-      exists: existsSync18(join69(input.projectRoot, manifest))
+      exists: existsSync18(join70(input.projectRoot, manifest))
     },
     sourceRefExamples: [
       `${sourceRefBase}/<doc-locator>#span:<heading-hint> L<start>-<end>@<hash>`
@@ -81057,8 +81131,8 @@ var init_documentRun = __esm(() => {
 });
 
 // src/lib/atomicFileBatch.ts
-import { lstat as lstat8, mkdir as mkdir26, mkdtemp as mkdtemp3, rename as rename6, rm as rm16, writeFile as writeFile20 } from "node:fs/promises";
-import { dirname as dirname32, join as join70, resolve as resolve23 } from "node:path";
+import { lstat as lstat8, mkdir as mkdir26, mkdtemp as mkdtemp3, rename as rename7, rm as rm16, writeFile as writeFile21 } from "node:fs/promises";
+import { dirname as dirname32, join as join71, resolve as resolve23 } from "node:path";
 async function existingFileKind(path2) {
   try {
     const stats = await lstat8(path2);
@@ -81088,9 +81162,9 @@ async function applyAtomicFileBatch(input) {
   for (const path2 of writesByPath.keys())
     removalPaths.delete(path2);
   await mkdir26(input.transactionRoot, { recursive: true });
-  const transactionDir = await mkdtemp3(join70(input.transactionRoot, "batch-"));
-  const stagedRoot = join70(transactionDir, "staged");
-  const backupRoot = join70(transactionDir, "backup");
+  const transactionDir = await mkdtemp3(join71(input.transactionRoot, "batch-"));
+  const stagedRoot = join71(transactionDir, "staged");
+  const backupRoot = join71(transactionDir, "backup");
   const writes = [...writesByPath.values()].sort((left, right) => left.path.localeCompare(right.path));
   const affectedPaths = [...new Set([...writesByPath.keys(), ...removalPaths])].sort();
   const staged = new Map;
@@ -81100,21 +81174,21 @@ async function applyAtomicFileBatch(input) {
   try {
     await mkdir26(stagedRoot, { recursive: true });
     for (const [index2, write] of writes.entries()) {
-      const path2 = join70(stagedRoot, String(index2));
-      await writeFile20(path2, write.bytes);
+      const path2 = join71(stagedRoot, String(index2));
+      await writeFile21(path2, write.bytes);
       staged.set(write.path, path2);
     }
     for (const [index2, path2] of affectedPaths.entries()) {
       if (await existingFileKind(path2) === "missing")
         continue;
-      const backupPath = join70(backupRoot, String(index2));
+      const backupPath = join71(backupRoot, String(index2));
       await mkdir26(dirname32(backupPath), { recursive: true });
-      await rename6(path2, backupPath);
+      await rename7(path2, backupPath);
       backups.set(path2, backupPath);
     }
     for (const write of writes) {
       await mkdir26(dirname32(write.path), { recursive: true });
-      await rename6(staged.get(write.path), write.path);
+      await rename7(staged.get(write.path), write.path);
       installed.push(write.path);
     }
   } catch (error) {
@@ -81126,7 +81200,7 @@ async function applyAtomicFileBatch(input) {
     }
     for (const [path2, backupPath] of [...backups.entries()].reverse()) {
       await mkdir26(dirname32(path2), { recursive: true });
-      await rename6(backupPath, path2).catch((rollbackError) => {
+      await rename7(backupPath, path2).catch((rollbackError) => {
         rollbackFailures.push(`restore ${path2}: ${String(rollbackError)}`);
       });
     }
@@ -81144,8 +81218,8 @@ var init_atomicFileBatch = () => {};
 
 // src/project/documentManifestRecovery.ts
 import { createHash as createHash20 } from "node:crypto";
-import { readFile as readFile60 } from "node:fs/promises";
-import { join as join71 } from "node:path";
+import { readFile as readFile61 } from "node:fs/promises";
+import { join as join72 } from "node:path";
 function recoverBatchEntries(value, sourceType, sourceName) {
   const [batch, module, ...rest] = sourceName.split("/");
   if (batch === undefined || module === undefined || rest.length > 0 || !/^\d{8}$/u.test(batch))
@@ -81168,7 +81242,7 @@ function recoverBatchEntries(value, sourceType, sourceName) {
 async function readDocumentManifestForCapture(input) {
   let bytes;
   try {
-    bytes = await readFile60(join71(input.projectRoot, input.manifestPath));
+    bytes = await readFile61(join72(input.projectRoot, input.manifestPath));
   } catch (error) {
     if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
       return { current: null, previous: null };
@@ -81185,10 +81259,10 @@ async function readDocumentManifestForCapture(input) {
     return { current: current2, previous: previous2 };
   } catch (error) {
     const digest6 = createHash20("sha256").update(bytes).digest("hex");
-    const backup = join71(".tmp", "context-runtime", "recovery", "document-manifests", `${digest6}.json`);
+    const backup = join72(".tmp", "context-runtime", "recovery", "document-manifests", `${digest6}.json`);
     await applyAtomicFileBatch({
-      transactionRoot: join71(input.projectRoot, ".tmp", "context-runtime", "recovery", "manifest-transactions"),
-      writes: [{ path: join71(input.projectRoot, backup), bytes }]
+      transactionRoot: join72(input.projectRoot, ".tmp", "context-runtime", "recovery", "manifest-transactions"),
+      writes: [{ path: join72(input.projectRoot, backup), bytes }]
     });
     const recovered = recoverBatchEntries(current2, input.sourceType, input.sourceName);
     return {
@@ -82181,8 +82255,8 @@ var init_workflowProvider = __esm(() => {
 });
 
 // src/project/productionStageRefresh.ts
-import { readFile as readFile64 } from "node:fs/promises";
-import { join as join79 } from "node:path";
+import { readFile as readFile65 } from "node:fs/promises";
+import { join as join80 } from "node:path";
 async function refreshProductionStageSources(projectRoot, stage) {
   const affected = new Set(stage.gaps.map((gap) => gap.scope));
   const unavailable = new Map;
@@ -82222,14 +82296,14 @@ 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]) => [join79(directory, productionSourceFile(scope2)), content3]));
-  contents2.set(join79(directory, "manifest.json"), `${JSON.stringify(updated)}
+  const contents2 = new Map([...sourceMaterials].map(([scope2, content3]) => [join80(directory, productionSourceFile(scope2)), content3]));
+  contents2.set(join80(directory, "manifest.json"), `${JSON.stringify(updated)}
 `);
   const targets = [];
   for (const [path2, content3] of contents2) {
     let previous2;
     try {
-      previous2 = await readFile64(await safeProjectTarget(projectRoot, path2), "utf8");
+      previous2 = await readFile65(await safeProjectTarget(projectRoot, path2), "utf8");
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
@@ -82353,7 +82427,7 @@ var init_productionReport = __esm(() => {
 });
 
 // src/project/productionPlanningRoute.ts
-import { join as join80 } from "node:path";
+import { join as join81 } from "node:path";
 async function productionPlanningRoute(input, stage) {
   const request = stage ? undefined : await productionPlanningRequest(input.projectRoot);
   const present = !!stage || !!request;
@@ -82391,7 +82465,7 @@ async function productionPlanningRoute(input, stage) {
           id: `production/${stage.id}/planning`,
           kind: "context-view",
           media_type: "text/markdown",
-          path: join80(input.projectRoot, productionStageDirectory(stage.id), "planning.md"),
+          path: join81(input.projectRoot, productionStageDirectory(stage.id), "planning.md"),
           read_state: "read-required"
         }] : []
       ],
@@ -82410,7 +82484,7 @@ var init_productionPlanningRoute = __esm(() => {
 
 // src/project/productionWorkflowRoute.ts
 import { existsSync as existsSync24 } from "node:fs";
-import { join as join81 } from "node:path";
+import { join as join82 } from "node:path";
 async function productionWorkflowRoute(input) {
   const stage = await readProductionStage(input.projectRoot);
   if (!stage || !stage.planning_complete)
@@ -82428,7 +82502,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 || existsSync24(join81(input.projectRoot, directory, "stage.md")) && stage.tasks.filter((task) => selected.has(task.id)).every((task) => task.status === "issued"),
+    prepared: !dispatch.batches.length || existsSync24(join82(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,
@@ -82445,7 +82519,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, join81(directory, "plan.md"), productionPlanMarkdown(stage));
+    await writeProductionProjection(input.projectRoot, join82(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";
@@ -82460,7 +82534,7 @@ async function productionWorkflowRoute(input) {
     id: `production/${stage.id}/${report ? "plan" : "stage"}`,
     kind: "context-view",
     media_type: "text/markdown",
-    path: join81(input.projectRoot, directory, path3),
+    path: join82(input.projectRoot, directory, path3),
     read_state: "read-required"
   });
   if (report || writing)
@@ -82471,18 +82545,18 @@ async function productionWorkflowRoute(input) {
       id: `production/${stage.id}/planning`,
       kind: "context-view",
       media_type: "text/markdown",
-      path: join81(input.projectRoot, directory, "planning.md"),
+      path: join82(input.projectRoot, directory, "planning.md"),
       read_state: "read-required"
     });
   }
   if (repair) {
-    await writeProductionProjection(input.projectRoot, join81(directory, "repair.md"), [
+    await writeProductionProjection(input.projectRoot, join82(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 ${join81(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 ${join82(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(`
@@ -82491,7 +82565,7 @@ async function productionWorkflowRoute(input) {
       id: `production/${stage.id}/repair`,
       kind: "context-view",
       media_type: "text/markdown",
-      path: join81(input.projectRoot, directory, "repair.md"),
+      path: join82(input.projectRoot, directory, "repair.md"),
       read_state: "read-required"
     });
   }
@@ -82582,7 +82656,7 @@ var init_knowledgeMaintenanceRoute = __esm(() => {
 });
 
 // src/project/approvedRevisionContext.ts
-import { readFile as readFile65 } from "node:fs/promises";
+import { readFile as readFile66 } from "node:fs/promises";
 async function approvedRevisionContext(root, target) {
   const registry2 = await readProductionRequirements(root);
   const requirements = registry2.requirements.filter((requirement2) => requirement2.target_scope.targets.some((source2) => target.source_refs.some((ref2) => ref2 === source2.source_ref || ref2.startsWith(`${source2.source_ref}#`) || ref2.startsWith(`${source2.source_ref}/`))));
@@ -82593,7 +82667,7 @@ async function approvedRevisionContext(root, target) {
     const type = source_ref.slice(0, separator);
     const name3 = source_ref.slice(separator + 1);
     const path2 = await assertManagedDocumentPath(root, type, name3);
-    const markdown = await readFile65(path2, "utf8");
+    const markdown = await readFile66(path2, "utf8");
     const changes = type === "sessions" ? readSessionChanges(markdown) : undefined;
     return {
       source_ref,
@@ -87248,8 +87322,8 @@ var init_larkResourceCommand = __esm(() => {
 
 // src/lib/larkResourceMaterialization.ts
 import { createHash as createHash26 } from "node:crypto";
-import { mkdtemp as mkdtemp4, readFile as readFile68, readdir as readdir20, rm as rm19 } from "node:fs/promises";
-import { extname as extname13, join as join88 } from "node:path";
+import { mkdtemp as mkdtemp4, readFile as readFile69, readdir as readdir20, rm as rm19 } from "node:fs/promises";
+import { extname as extname13, join as join89 } from "node:path";
 import { tmpdir } from "node:os";
 function countByKind(items, status) {
   const counts2 = new Map;
@@ -87354,10 +87428,10 @@ function findBooleanField(value, name3) {
 }
 async function downloadedFile(input) {
   if (input.localPath !== undefined) {
-    const bytes = await readFile68(input.localPath);
+    const bytes = await readFile69(input.localPath);
     return { path: input.localPath, bytes, mediaType: mediaTypeFor(input.localPath, bytes) };
   }
-  const tempRoot = await mkdtemp4(join88(tmpdir(), "context-lark-resource-"));
+  const tempRoot = await mkdtemp4(join89(tmpdir(), "context-lark-resource-"));
   try {
     await runLarkResourceCommand(input.runner, [
       "docs",
@@ -87378,7 +87452,7 @@ async function downloadedFile(input) {
     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 readFile68(join88(tempRoot, path3));
+    const bytes = await readFile69(join89(tempRoot, path3));
     return { path: path3, bytes, mediaType: mediaTypeFor(path3, bytes) };
   } finally {
     await rm19(tempRoot, { recursive: true, force: true });
@@ -87469,9 +87543,9 @@ async function sheetMaterialization(resource, runner2, identity) {
   const sheetId = resource.attributes["sheet-id"];
   if (token === undefined || sheetId === undefined)
     throw new Error("embedded Sheet requires token and sheet-id");
-  const tempRoot = await mkdtemp4(join88(tmpdir(), "context-lark-sheet-"));
+  const tempRoot = await mkdtemp4(join89(tmpdir(), "context-lark-sheet-"));
   try {
-    const outputPath = join88(tempRoot, "sheet.json");
+    const outputPath = join89(tempRoot, "sheet.json");
     const stdout = await runLarkResourceCommand(runner2, [
       "sheets",
       "+csv-get",
@@ -87491,7 +87565,7 @@ async function sheetMaterialization(resource, runner2, identity) {
     if (findBooleanField(receipt2, "truncated") === true || findBooleanField(receipt2, "complete") === false) {
       throw new Error("embedded Sheet read was truncated");
     }
-    const payload = JSON.parse(await readFile68(outputPath, "utf8"));
+    const payload = JSON.parse(await readFile69(outputPath, "utf8"));
     const csv = findStringField(payload, new Set(["annotated_csv", "csv", "content", "text"]));
     if (csv === undefined)
       throw new Error("embedded Sheet response has no CSV payload");
@@ -87627,7 +87701,7 @@ async function whiteboardMaterialization(resource, runner2, identity) {
   if (token === undefined)
     throw new Error(`${resource.kind} has no whiteboard token`);
   const preview = await downloadedFile({ runner: runner2, identity, token, type: "whiteboard" });
-  const tempRoot = await mkdtemp4(join88(tmpdir(), "context-lark-whiteboard-"));
+  const tempRoot = await mkdtemp4(join89(tmpdir(), "context-lark-whiteboard-"));
   let rawPayload;
   try {
     await runLarkResourceCommand(runner2, [
@@ -87645,7 +87719,7 @@ async function whiteboardMaterialization(resource, runner2, identity) {
       "--format",
       "json"
     ], { cwd: tempRoot });
-    rawPayload = JSON.parse(await readFile68(join88(tempRoot, "raw.json"), "utf8"));
+    rawPayload = JSON.parse(await readFile69(join89(tempRoot, "raw.json"), "utf8"));
   } finally {
     await rm19(tempRoot, { recursive: true, force: true });
   }
@@ -88490,8 +88564,8 @@ var init_sensitiveSourceLiteral = __esm(() => {
 var LARK_DOCUMENT_NORMALIZER_VERSION = "lark-document-normalizer.v1";
 
 // src/project/documentCaptureLark.ts
-import { readdir as readdir21, readFile as readFile69 } from "node:fs/promises";
-import { basename as basename10, extname as extname14, join as join89 } from "node:path";
+import { readdir as readdir21, readFile as readFile70 } from "node:fs/promises";
+import { basename as basename10, extname as extname14, join as join90 } from "node:path";
 function titleFromMarkdown2(markdown, fallbackPath) {
   const heading2 = markdown.split(`
 `).find((line) => /^#\s+\S/u.test(line));
@@ -88510,7 +88584,7 @@ function countLines3(markdown) {
 }
 async function fileContentMatches(path3, content3) {
   try {
-    const current2 = await readFile69(path3);
+    const current2 = await readFile70(path3);
     const expected = typeof content3 === "string" ? Buffer.from(content3, "utf8") : Buffer.from(content3);
     return current2.equals(expected);
   } catch {
@@ -88518,7 +88592,7 @@ async function fileContentMatches(path3, content3) {
   }
 }
 function sourceManifestPath2(entry) {
-  return entry.snapshot?.manifest ?? join89(entry.materializedAt, "manifest.json");
+  return entry.snapshot?.manifest ?? join90(entry.materializedAt, "manifest.json");
 }
 function larkRuntimeError(message, detail) {
   return new ContextError(ExitCode.ExternalToolError, message, {
@@ -88644,7 +88718,7 @@ function assetManifestEntry(asset, assetRoot) {
   };
 }
 async function listSnapshotAssetFiles(root2, assetRoot) {
-  const assetsRoot = join89(root2, assetRoot);
+  const assetsRoot = join90(root2, assetRoot);
   const files = [];
   const visit4 = async (dir, prefix = assetRoot) => {
     let entries2;
@@ -88657,7 +88731,7 @@ async function listSnapshotAssetFiles(root2, assetRoot) {
     }
     for (const entry of entries2) {
       const relPath = `${prefix}/${entry.name}`;
-      const absolutePath = join89(dir, entry.name);
+      const absolutePath = join90(dir, entry.name);
       if (entry.isDirectory()) {
         await visit4(absolutePath, relPath);
         continue;
@@ -88672,7 +88746,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) => join89(input.materializedAtAbsPath, path3));
+  return existingPaths.filter((path3) => !input.currentPaths.has(path3)).map((path3) => join90(input.materializedAtAbsPath, path3));
 }
 function normalizeLarkError(error, sourceName) {
   if (error instanceof ContextError)
@@ -88780,9 +88854,9 @@ async function runCaptureLarkPhaseUnlocked(input) {
     locator
   }];
   const manifestPath = sourceManifestPath2(entry);
-  const manifestAbsPath = join89(input.projectRoot, manifestPath);
+  const manifestAbsPath = join90(input.projectRoot, manifestPath);
   const materializedAt = entry.materializedAt;
-  const materializedAtAbsPath = join89(input.projectRoot, materializedAt);
+  const materializedAtAbsPath = join90(input.projectRoot, materializedAt);
   const manifest = createDocumentSnapshotManifest({
     sourceType: "lark",
     sourceName: resolved.sourceName,
@@ -88816,13 +88890,13 @@ async function runCaptureLarkPhaseUnlocked(input) {
   }));
   try {
     const requestedWrites = [{
-      path: join89(materializedAtAbsPath, documentPath),
+      path: join90(materializedAtAbsPath, documentPath),
       bytes: normalized
     }];
     for (const asset of assets) {
       if (asset.bytes !== undefined) {
         requestedWrites.push({
-          path: join89(materializedAtAbsPath, asset.entry.path),
+          path: join90(materializedAtAbsPath, asset.entry.path),
           bytes: asset.bytes
         });
       }
@@ -88839,7 +88913,7 @@ async function runCaptureLarkPhaseUnlocked(input) {
       currentPaths: new Set(assets.filter((asset) => asset.bytes !== undefined).map((asset) => asset.entry.path))
     });
     await applyAtomicFileBatch({
-      transactionRoot: join89(input.projectRoot, ".tmp", "context-runtime", "capture-transactions"),
+      transactionRoot: join90(input.projectRoot, ".tmp", "context-runtime", "capture-transactions"),
       writes,
       removals
     });
@@ -88985,7 +89059,7 @@ __export(exports_articleRetirement, {
   retireArticles: () => retireArticles,
   articleRetirementSchema: () => articleRetirementSchema
 });
-import { readFile as readFile75, readdir as readdir22 } from "node:fs/promises";
+import { readFile as readFile76, readdir as readdir22 } from "node:fs/promises";
 import { posix as posix10 } from "node:path";
 function rebuildInput(revision) {
   return JSON.stringify({ id: `retirement-${revision.slice(7)}`, operation: "rebuild", timing: "priority", targets: [] });
@@ -89006,7 +89080,7 @@ function invalid2(reason, message, details = {}) {
 }
 async function text9(root2, path3) {
   try {
-    return await readFile75(await safeProjectTarget(root2, path3), "utf8");
+    return await readFile76(await safeProjectTarget(root2, path3), "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -89268,8 +89342,8 @@ __export(exports_writeLockRecovery, {
   recoverWriterLock: () => recoverWriterLock,
   inspectWriterLock: () => inspectWriterLock
 });
-import { lstat as lstat10, mkdir as mkdir33, readFile as readFile76, readdir as readdir23, rename as rename7, rmdir as rmdir2 } from "node:fs/promises";
-import { join as join94 } from "node:path";
+import { lstat as lstat10, mkdir as mkdir33, readFile as readFile77, readdir as readdir23, rename as rename8, rmdir as rmdir2 } from "node:fs/promises";
+import { join as join95 } from "node:path";
 import { createHash as createHash28, randomUUID as randomUUID7 } from "node:crypto";
 async function inspectWriterLock(root2) {
   const path3 = await safeProjectTarget(root2, lockRelative);
@@ -89284,7 +89358,7 @@ async function inspectWriterLock(root2) {
   if (!stat10.isDirectory() || stat10.isSymbolicLink())
     throw new Error("Writer lock must be a real directory.");
   const ownerPath = await safeProjectTarget(root2, `${lockRelative}/owner.json`);
-  const bytes = await readFile76(ownerPath, "utf8");
+  const bytes = await readFile77(ownerPath, "utf8");
   const owner = JSON.parse(bytes);
   if (owner.protocol !== "context.project-write-lock.v1" || !Number.isSafeInteger(owner.pid) || owner.pid <= 0) {
     throw new Error("Writer lock owner is invalid; preserve the lock for diagnosis.");
@@ -89316,8 +89390,8 @@ async function recoverWriterLock(input) {
     };
   if (input.plan_digest !== before.digest)
     throw new Error("Writer lock changed; preview recovery again.");
-  const path3 = join94(input.projectRoot, lockRelative);
-  const guard = join94(path3, ".recovery");
+  const path3 = join95(input.projectRoot, lockRelative);
+  const guard = join95(path3, ".recovery");
   await mkdir33(guard);
   let archived = false;
   try {
@@ -89328,7 +89402,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-${randomUUID7()}.lock`;
-    await rename7(path3, join94(input.projectRoot, archive));
+    await rename8(path3, join95(input.projectRoot, archive));
     archived = true;
     return { action: "writer-lock-recovered", archived_lock: archive, next: "context task recover --format json" };
   } finally {
@@ -89352,12 +89426,12 @@ __export(exports_taskRecovery, {
   RECOVERY_COMMAND: () => RECOVERY_COMMAND
 });
 import { existsSync as existsSync26 } from "node:fs";
-import { dirname as dirname41, join as join95 } from "node:path";
-import { lstat as lstat11, readdir as readdir24, readFile as readFile77 } from "node:fs/promises";
+import { dirname as dirname41, join as join96 } from "node:path";
+import { lstat as lstat11, readdir as readdir24, readFile as readFile78 } from "node:fs/promises";
 async function recoveryText(root2, path3) {
   const target = await safeProjectTarget(root2, path3);
   try {
-    return await readFile77(target, "utf8");
+    return await readFile78(target, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -89370,7 +89444,7 @@ async function recoveryJournals(root2) {
     await safeProjectTarget(root2, path3);
     let stat10;
     try {
-      stat10 = await lstat11(join95(root2, path3));
+      stat10 = await lstat11(join96(root2, path3));
     } catch (error) {
       if (error.code === "ENOENT")
         return;
@@ -89381,7 +89455,7 @@ async function recoveryJournals(root2) {
     if (stat10.isDirectory()) {
       if (depth > 3)
         throw new TypeError("Unexpected transaction directory depth; preserve it for diagnosis.");
-      for (const name3 of (await readdir24(join95(root2, path3))).sort())
+      for (const name3 of (await readdir24(join96(root2, path3))).sort())
         await visit4(`${path3}/${name3}`, depth + 1);
     } else if (stat10.isFile())
       entries2.push({ path: path3, digest: indexerProtocolDigest(await recoveryText(root2, path3)) });
@@ -89393,8 +89467,8 @@ function recoveryResources() {
   try {
     const root2 = dirname41(contextWorkflowProviderPath());
     const resources = {
-      skill: join95(root2, "skills/recover-workspace/SKILL.md"),
-      issue_template: join95(root2, "resources/templates/recovery-issue.md")
+      skill: join96(root2, "skills/recover-workspace/SKILL.md"),
+      issue_template: join96(root2, "resources/templates/recovery-issue.md")
     };
     if (!Object.values(resources).every((path3) => existsSync26(path3)))
       throw new Error("Recovery resources are absent from this Provider.");
@@ -89479,8 +89553,8 @@ var exports_taskLocalSourceAdjustment = {};
 __export(exports_taskLocalSourceAdjustment, {
   adjustLocalRevisionSources: () => adjustLocalRevisionSources
 });
-import { readFile as readFile78 } from "node:fs/promises";
-import { join as join96 } from "node:path";
+import { readFile as readFile79 } from "node:fs/promises";
+import { join as join97 } 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))
@@ -89504,7 +89578,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 readFile78(join96(root2, await revisionStoragePath(root2)), "utf8");
+  const raw = await readFile79(join97(root2, await revisionStoragePath(root2)), "utf8");
   let next2;
   const discardIds = new Set;
   if (!input.refresh) {
@@ -89607,7 +89681,7 @@ ${input.instruction}` : revision.instruction
     content: content3
   }];
   if (discardIds.size > 0) {
-    const ledger = await readFile78(join96(root2, CANDIDATE_LEDGER_FILE), "utf8").catch((error) => {
+    const ledger = await readFile79(join97(root2, CANDIDATE_LEDGER_FILE), "utf8").catch((error) => {
       if (error.code === "ENOENT")
         return;
       throw error;
@@ -89729,7 +89803,7 @@ var init_taskSourceAdjustment = __esm(() => {
 });
 
 // src/project/managedDocumentImport.ts
-import { readFile as readFile84 } from "node:fs/promises";
+import { readFile as readFile85 } from "node:fs/promises";
 async function importManagedDocument(projectRoot, value) {
   const input = inputSchema.parse(value);
   if (input.type !== "sessions" && input.changes !== undefined)
@@ -89738,7 +89812,7 @@ async function importManagedDocument(projectRoot, value) {
     const path3 = await assertManagedDocumentPath(projectRoot, input.type, input.name);
     let previous3;
     try {
-      previous3 = await readFile84(path3, "utf8");
+      previous3 = await readFile85(path3, "utf8");
     } catch (error) {
       if (!(error && typeof error === "object" && ("code" in error) && error.code === "ENOENT"))
         throw error;
@@ -89785,14 +89859,14 @@ var init_managedDocumentImport = __esm(() => {
 });
 
 // src/project/larkDocumentImport.ts
-import { readFile as readFile85 } from "node:fs/promises";
+import { readFile as readFile86 } from "node:fs/promises";
 async function importLarkDocument(projectRoot, value) {
   const input = schema3.parse(value);
   const responsePages = [];
   for (const path3 of input.response_files) {
     assertActionInputWorkspace(projectRoot, path3);
     const { resolve: resolve8 } = await import("node:path");
-    responsePages.push(await readFile85(resolve8(projectRoot, path3), "utf8"));
+    responsePages.push(await readFile86(resolve8(projectRoot, path3), "utf8"));
   }
   const mediaFiles = {};
   for (const [token, path3] of Object.entries(input.media_files ?? {})) {
@@ -89860,11 +89934,11 @@ var exports_managedDocumentRename = {};
 __export(exports_managedDocumentRename, {
   renameManagedDocument: () => renameManagedDocument
 });
-import { readFile as readFile86 } from "node:fs/promises";
-import { join as join104, posix as posix11 } from "node:path";
+import { readFile as readFile87 } from "node:fs/promises";
+import { join as join105, posix as posix11 } from "node:path";
 async function optionalText2(path3) {
   try {
-    return await readFile86(path3, "utf8");
+    return await readFile87(path3, "utf8");
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
       return;
@@ -89948,7 +90022,7 @@ async function renameManagedDocument(input) {
       if (path3.split("/").includes("..") || path3.startsWith("/"))
         throw new TypeError("Source references contain an unsafe knowledge path; repair it before renaming.");
       await safeProjectTarget(input.projectRoot, path3);
-      const before = await optionalText2(join104(input.projectRoot, path3));
+      const before = await optionalText2(join105(input.projectRoot, path3));
       if (before === undefined)
         continue;
       let after;
@@ -90037,7 +90111,7 @@ var init_managedDocumentRename = __esm(() => {
 
 // src/cli.ts
 import { existsSync as existsSync36, realpathSync as realpathSync3 } from "node:fs";
-import { dirname as dirname48, join as join108 } from "node:path";
+import { dirname as dirname48, join as join109 } from "node:path";
 import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL3 } from "node:url";
 
 // ../../node_modules/.bun/commander@11.1.0/node_modules/commander/esm.mjs
@@ -90092,7 +90166,7 @@ init_dist();
 init_cliFeedback();
 init_errors3();
 init_exitCode();
-import { join as join86 } from "node:path";
+import { join as join87 } from "node:path";
 
 // src/project/status.ts
 init_productionPlanning();
@@ -90103,13 +90177,13 @@ init_approvedRevisionBatch();
 init_revisionDelivery();
 init_workspacePreparation();
 init_src2();
-import { join as join82 } from "node:path";
+import { join as join83 } from "node:path";
 
 // src/project/statusReaders.ts
 init_commandReadCache();
 init_errors3();
 import { existsSync as existsSync22, readFileSync as readFileSync8 } from "node:fs";
-import { join as join78 } from "node:path";
+import { join as join79 } from "node:path";
 
 // src/project/documentCapture.ts
 init_src3();
@@ -90117,8 +90191,8 @@ init_cliFeedback();
 init_errors3();
 init_exitCode();
 import { createHash as createHash21 } from "node:crypto";
-import { mkdir as mkdir27, readdir as readdir18, readFile as readFile61, rm as rm17, stat as stat9, writeFile as writeFile21 } from "node:fs/promises";
-import { basename as basename8, dirname as dirname33, extname as extname12, join as join72, relative as relative22, resolve as resolve24 } from "node:path";
+import { mkdir as mkdir27, readdir as readdir18, readFile as readFile62, rm as rm17, stat as stat9, writeFile as writeFile22 } from "node:fs/promises";
+import { basename as basename8, dirname as dirname33, extname as extname12, join as join73, relative as relative22, resolve as resolve24 } from "node:path";
 
 // src/project/documentCaptureAssets.ts
 init_src3();
@@ -90127,8 +90201,8 @@ init_errors3();
 init_exitCode();
 init_markdownLinks();
 import { readFileSync as readFileSync6 } from "node:fs";
-import { mkdir as mkdir25, readFile as readFile58, stat as stat7, writeFile as writeFile19 } from "node:fs/promises";
-import { dirname as dirname30, isAbsolute as isAbsolute13, join as join67, relative as relative20, resolve as resolve21 } from "node:path";
+import { mkdir as mkdir25, readFile as readFile59, stat as stat7, writeFile as writeFile20 } from "node:fs/promises";
+import { dirname as dirname30, isAbsolute as isAbsolute13, join as join68, relative as relative20, resolve as resolve21 } from "node:path";
 function runtimeError(message, detail) {
   return new ContextError(ExitCode.UserError, message, {
     category: ErrorCategory.UserInputInvalid,
@@ -90153,26 +90227,26 @@ function linkedAssetSnapshotPath(documentPath, target) {
   const decoded = decodedAssetTarget(target);
   if (/^[a-z][a-z0-9+.-]*:/iu.test(decoded) || decoded.startsWith("#") || decoded.startsWith("/"))
     return;
-  const candidate = toPosixPath5(join67(dirname30(documentPath), decoded));
+  const candidate = toPosixPath5(join68(dirname30(documentPath), decoded));
   if (candidate !== "assets" && !candidate.startsWith("assets/"))
     return;
   return normalizeSnapshotRelativePath(candidate);
 }
 async function writeCaptureAssetIfChanged(path2, content3) {
   try {
-    const current = await readFile58(path2);
+    const current = await readFile59(path2);
     if (current.byteLength === content3.byteLength && current.equals(content3))
       return;
   } catch {}
   await mkdir25(dirname30(path2), { recursive: true });
-  await writeFile19(path2, content3);
+  await writeFile20(path2, content3);
 }
 async function readLinkedCaptureAssets(input) {
   const rootStat = await stat7(input.localRoot);
   const boundaryRoot = rootStat.isFile() ? dirname30(input.localRoot) : input.localRoot;
   const bySnapshotPath = new Map;
   for (const file of input.files) {
-    const markdown = await readFile58(file.absolutePath, "utf8");
+    const markdown = await readFile59(file.absolutePath, "utf8");
     for (const link of markdownInlineLinks(markdown)) {
       const snapshotPath2 = linkedAssetSnapshotPath(file.snapshotPath, link.target);
       if (snapshotPath2 === undefined)
@@ -90190,7 +90264,7 @@ async function readLinkedCaptureAssets(input) {
         const assetStat = await stat7(absolutePath);
         if (!assetStat.isFile())
           throw new TypeError("asset target is not a file");
-        bytes = await readFile58(absolutePath);
+        bytes = await readFile59(absolutePath);
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         throw runtimeError(`file source ${input.sourceName} linked asset is unreadable: ${link.target}: ${message}`, {
@@ -90218,7 +90292,7 @@ function fileSnapshotLinkedAssetMismatchDiagnostic(input) {
   for (const file of input.manifest.files) {
     let markdown;
     try {
-      markdown = readFileSync6(join67(input.projectRoot, input.materializedAt, file.path), "utf8");
+      markdown = readFileSync6(join68(input.projectRoot, input.materializedAt, file.path), "utf8");
     } catch {
       continue;
     }
@@ -97835,7 +97909,7 @@ init_src3();
 init_cliFeedback();
 init_errors3();
 init_exitCode();
-import { readFile as readFile59 } from "node:fs/promises";
+import { readFile as readFile60 } from "node:fs/promises";
 import { dirname as dirname31, extname as extname10 } from "node:path";
 var ROUTE_EVIDENCE_DOCUMENT_PATH = "__context_route_metadata.md";
 function countLines(markdown) {
@@ -97930,7 +98004,7 @@ async function readRouteMetadataFiles(input) {
   for (const file of input.files) {
     let raw;
     try {
-      raw = await readFile59(file.absolutePath, "utf8");
+      raw = await readFile60(file.absolutePath, "utf8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw runtimeError2(`file source ${input.sourceName} metadata read failed: ${file.snapshotPath}: ${message}`, {
@@ -97982,7 +98056,7 @@ async function readRouteMetadataFiles(input) {
 
 // src/project/documentSiteDetection.ts
 import { readdir as readdir17, stat as stat8 } from "node:fs/promises";
-import { basename as basename7, extname as extname11, join as join68, relative as relative21, resolve as resolve22 } from "node:path";
+import { basename as basename7, extname as extname11, join as join69, relative as relative21, resolve as resolve22 } from "node:path";
 var SKIPPED_DIRS = new Set([
   ".cache",
   ".git",
@@ -98065,7 +98139,7 @@ async function detectDocumentSiteFiles(input) {
         return;
       }
       result.scannedEntryCount += 1;
-      const absolutePath = join68(dir, entry.name);
+      const absolutePath = join69(dir, entry.name);
       if (entry.isDirectory()) {
         const lower = entry.name.toLowerCase();
         if (SKIPPED_DIRS.has(lower))
@@ -98255,7 +98329,7 @@ async function walkMarkdownFiles(input) {
   const visit3 = async (dir) => {
     const entries2 = await readdir18(dir, { withFileTypes: true });
     for (const entry of entries2) {
-      const absolutePath = join72(dir, entry.name);
+      const absolutePath = join73(dir, entry.name);
       if (entry.isDirectory()) {
         await visit3(absolutePath);
         continue;
@@ -98277,14 +98351,14 @@ async function walkMarkdownFiles(input) {
 }
 async function writeTextIfChanged(path2, content3) {
   try {
-    if (await readFile61(path2, "utf8") === content3)
+    if (await readFile62(path2, "utf8") === content3)
       return;
   } catch {}
   await mkdir27(dirname33(path2), { recursive: true });
-  await writeFile21(path2, content3, "utf8");
+  await writeFile22(path2, content3, "utf8");
 }
 function sourceManifestPath(entry) {
-  return entry.snapshot?.manifest ?? join72(entry.materializedAt, "manifest.json");
+  return entry.snapshot?.manifest ?? join73(entry.materializedAt, "manifest.json");
 }
 function runtimeError3(message, detail) {
   return new ContextError(ExitCode.UserError, message, {
@@ -98357,7 +98431,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, join72(dir, entry.name));
+    await removeEmptySnapshotDirs(root, join73(dir, entry.name));
   }
   if (dir === root)
     return;
@@ -98369,7 +98443,7 @@ async function removeEmptySnapshotDirs(root, dir = root) {
 async function cleanupStaleSnapshotFiles(input) {
   for (const path2 of input.previousPaths) {
     if (!input.currentPaths.has(path2)) {
-      await rm17(join72(input.materializedAtAbsPath, path2), { force: true });
+      await rm17(join73(input.materializedAtAbsPath, path2), { force: true });
     }
   }
   await removeEmptySnapshotDirs(input.materializedAtAbsPath);
@@ -98381,7 +98455,7 @@ async function readDocumentFiles(input) {
   for (const file of input.files) {
     let raw;
     try {
-      raw = await readFile61(file.absolutePath, "utf8");
+      raw = await readFile62(file.absolutePath, "utf8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw runtimeError3(`file source ${input.sourceName} document read failed: ${file.snapshotPath}: ${message}`, {
@@ -98550,9 +98624,9 @@ async function runCaptureFilePhaseUnlocked(input) {
     documentSnapshot
   });
   const manifestPath = sourceManifestPath(entry);
-  const manifestAbsPath = join72(input.projectRoot, manifestPath);
+  const manifestAbsPath = join73(input.projectRoot, manifestPath);
   const materializedAt = entry.materializedAt;
-  const materializedAtAbsPath = join72(input.projectRoot, materializedAt);
+  const materializedAtAbsPath = join73(input.projectRoot, materializedAt);
   const manifestInput = {
     sourceType: "file",
     sourceName: resolved.sourceName,
@@ -98602,13 +98676,13 @@ async function runCaptureFilePhaseUnlocked(input) {
   }));
   try {
     for (const file of snapshotFiles) {
-      await writeTextIfChanged(join72(materializedAtAbsPath, file.path), String(file.bytes));
+      await writeTextIfChanged(join73(materializedAtAbsPath, file.path), String(file.bytes));
     }
     for (const file of files.metadata) {
-      await writeTextIfChanged(join72(materializedAtAbsPath, file.snapshotPath), routeMetadata.rawByPath.get(file.snapshotPath) ?? "");
+      await writeTextIfChanged(join73(materializedAtAbsPath, file.snapshotPath), routeMetadata.rawByPath.get(file.snapshotPath) ?? "");
     }
     for (const asset of linkedAssets) {
-      await writeCaptureAssetIfChanged(join72(materializedAtAbsPath, asset.snapshotPath), asset.bytes);
+      await writeCaptureAssetIfChanged(join73(materializedAtAbsPath, asset.snapshotPath), asset.bytes);
     }
     await writeTextIfChanged(manifestAbsPath, manifestContent);
     await cleanupStaleSnapshotFiles({
@@ -98662,7 +98736,7 @@ async function runCaptureFilePhase(input) {
 init_src3();
 init_larkCaptureReport();
 import { readFileSync as readFileSync7 } from "node:fs";
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 function readDocumentSnapshotCaptureReport(input) {
   const summary = input.manifest.metadata?.capture?.report;
   if (summary === undefined)
@@ -98671,7 +98745,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(join73(input.projectRoot, input.materializedAt, summary.path));
+  const bytes = readFileSync7(join74(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}`);
   }
@@ -98742,17 +98816,17 @@ init_cliFeedback();
 init_errors3();
 init_exitCode();
 import { existsSync as existsSync21 } from "node:fs";
-import { lstat as lstat9, mkdir as mkdir28, readFile as readFile63, readlink, realpath as realpath9, rm as rm18, symlink as symlink3 } from "node:fs/promises";
+import { lstat as lstat9, mkdir as mkdir28, readFile as readFile64, readlink, realpath as realpath9, rm as rm18, symlink as symlink3 } from "node:fs/promises";
 import { execFile as execFile9 } from "node:child_process";
 import { promisify as promisify9 } from "node:util";
-import { dirname as dirname34, isAbsolute as isAbsolute14, join as join76, relative as relative23, resolve as resolve26 } from "node:path";
+import { dirname as dirname34, isAbsolute as isAbsolute14, join as join77, relative as relative23, resolve as resolve26 } from "node:path";
 
 // src/project/repoSourceModules.ts
 init_src();
 init_src3();
 import { existsSync as existsSync19 } from "node:fs";
-import { readFile as readFile62, readdir as readdir19 } from "node:fs/promises";
-import { join as join74, resolve as resolve25 } from "node:path";
+import { readFile as readFile63, readdir as readdir19 } from "node:fs/promises";
+import { join as join75, resolve as resolve25 } from "node:path";
 async function rootNames(root) {
   try {
     return (await readdir19(root)).sort();
@@ -98761,11 +98835,11 @@ async function rootNames(root) {
   }
 }
 async function packageEntries(root) {
-  const path2 = join74(root, "package.json");
+  const path2 = join75(root, "package.json");
   if (!existsSync19(path2))
     return [];
   try {
-    const value = JSON.parse(await readFile62(path2, "utf8"));
+    const value = JSON.parse(await readFile63(path2, "utf8"));
     const entries2 = [value.exports, value.main, value.module, value.bin].flatMap((item) => typeof item === "string" ? [item] : item !== null && typeof item === "object" ? Object.values(item).filter((entry) => typeof entry === "string") : []);
     return [...new Set(entries2.map((entry) => entry.replace(/^\.\//u, "")))].sort();
   } catch {
@@ -98773,9 +98847,9 @@ async function packageEntries(root) {
   }
 }
 async function planningEvidence(inspectPath, module) {
-  const root = module.path === "." ? inspectPath : join74(inspectPath, module.path);
+  const root = module.path === "." ? inspectPath : join75(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) => existsSync19(join74(root, path2)));
+  const commonEntries = ["src/index.ts", "src/index.tsx", "src/main.ts", "src/main.tsx", "main.go"].filter((path2) => existsSync19(join75(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 {
@@ -98813,7 +98887,7 @@ function suggestedModuleName(module) {
   return slug || "module";
 }
 async function inspectRepoSourceModules(input) {
-  const inspectPath = input.scopedAbs !== null && existsSync19(input.scopedAbs) ? input.scopedAbs : join74(input.projectRoot, input.status.materializedAt);
+  const inspectPath = input.scopedAbs !== null && existsSync19(input.scopedAbs) ? input.scopedAbs : join75(input.projectRoot, input.status.materializedAt);
   const modules = existsSync19(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 });
@@ -98855,7 +98929,7 @@ init_exitCode();
 init_atomicWrite();
 var import_yaml37 = __toESM(require_dist(), 1);
 import { existsSync as existsSync20 } from "node:fs";
-import { join as join75 } from "node:path";
+import { join as join76 } from "node:path";
 var SOURCE_NAME_PATTERN2 = /^[a-z0-9][a-z0-9._-]*$/u;
 var REPO_DATE_NAMESPACE_PATTERN2 = /^\d{8}$/u;
 function assertRepoModuleName(name3) {
@@ -98908,7 +98982,7 @@ function registryEntryToRecord(entry) {
   };
 }
 function registryPath(projectRoot) {
-  return join75(projectRoot, DEFAULT_REPO_SOURCES_REGISTRY_PATH);
+  return join76(projectRoot, DEFAULT_REPO_SOURCES_REGISTRY_PATH);
 }
 function defaultRepoMaterializedAt(source2) {
   return `sources/repo/${source2.namespace}/${source2.module}`;
@@ -99010,13 +99084,13 @@ async function gitOutput(cwd, args) {
   }
 }
 async function readGitOriginRemote(cwd) {
-  const directConfigPath = join76(cwd, ".git", "config");
-  let config = await readFile63(directConfigPath, "utf8").catch(() => "");
+  const directConfigPath = join77(cwd, ".git", "config");
+  let config = await readFile64(directConfigPath, "utf8").catch(() => "");
   if (config.length === 0) {
     const gitDir = await resolveGitDir(cwd);
     if (gitDir === null)
       return null;
-    config = await readFile63(join76(gitDir, "config"), "utf8").catch(() => "");
+    config = await readFile64(join77(gitDir, "config"), "utf8").catch(() => "");
   }
   let inOriginBlock = false;
   for (const line of config.split(/\r?\n/u)) {
@@ -99036,7 +99110,7 @@ async function readGitOriginRemote(cwd) {
 async function resolveGitRoot(cwd) {
   let current2 = resolve26(cwd);
   while (true) {
-    if (existsSync21(join76(current2, ".git")))
+    if (existsSync21(join77(current2, ".git")))
       return current2;
     const parent = dirname34(current2);
     if (parent === current2)
@@ -99045,7 +99119,7 @@ async function resolveGitRoot(cwd) {
   }
 }
 async function resolveGitDir(cwd) {
-  const dotGit = join76(cwd, ".git");
+  const dotGit = join77(cwd, ".git");
   if (!existsSync21(dotGit))
     return null;
   const stats = await lstat9(dotGit);
@@ -99053,7 +99127,7 @@ async function resolveGitDir(cwd) {
     return dotGit;
   if (!stats.isFile())
     return null;
-  const raw = await readFile63(dotGit, "utf8").catch(() => "");
+  const raw = await readFile64(dotGit, "utf8").catch(() => "");
   const match = /^gitdir:\s*(.+)\s*$/iu.exec(raw.trim());
   if (match?.[1] === undefined)
     return null;
@@ -99063,17 +99137,17 @@ async function readGitHead(cwd) {
   const gitDir = await resolveGitDir(cwd);
   if (gitDir === null)
     return null;
-  const headRaw = (await readFile63(join76(gitDir, "HEAD"), "utf8").catch(() => "")).trim();
+  const headRaw = (await readFile64(join77(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 readFile63(join76(gitDir, refPath), "utf8").catch(() => "")).trim();
+  const looseRef = (await readFile64(join77(gitDir, refPath), "utf8").catch(() => "")).trim();
   if (/^[a-f0-9]{40}$/iu.test(looseRef))
     return looseRef.toLowerCase();
-  const packedRefs = await readFile63(join76(gitDir, "packed-refs"), "utf8").catch(() => "");
+  const packedRefs = await readFile64(join77(gitDir, "packed-refs"), "utf8").catch(() => "");
   for (const line of packedRefs.split(/\r?\n/u)) {
     if (line.startsWith("#") || line.startsWith("^"))
       continue;
@@ -99084,7 +99158,7 @@ async function readGitHead(cwd) {
   return null;
 }
 async function ensureMaterializedSymlink(input) {
-  const linkPath = join76(input.projectRoot, input.materializedAt);
+  const linkPath = join77(input.projectRoot, input.materializedAt);
   await mkdir28(dirname34(linkPath), { recursive: true });
   if (existsSync21(linkPath)) {
     const stats = await lstat9(linkPath);
@@ -99103,7 +99177,7 @@ async function ensureMaterializedSymlink(input) {
   return true;
 }
 async function diagnoseMaterializedSymlink(input) {
-  const linkPath = join76(input.projectRoot, input.materializedAt);
+  const linkPath = join77(input.projectRoot, input.materializedAt);
   if (!existsSync21(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.`);
@@ -99326,7 +99400,7 @@ async function inspectRepoSource(input) {
   const subpath = normalizeSubpath2(source2.subpath);
   const scopedAbs = localAbs === null ? null : scopedLocalPath(localAbs, subpath);
   const scopeExists = scopedAbs !== null && existsSync21(scopedAbs);
-  let materialized = existsSync21(join76(input.projectRoot, materializedAt));
+  let materialized = existsSync21(join77(input.projectRoot, materializedAt));
   const checkout = await inspectRepoCheckout({
     source: source2,
     localAbs,
@@ -99495,8 +99569,8 @@ init_approvedKnowledgeMetadata();
 init_knowledgeAssets();
 var import_yaml38 = __toESM(require_dist(), 1);
 import { createHash as createHash22 } from "node:crypto";
-import { mkdir as mkdir29, writeFile as writeFile22 } from "node:fs/promises";
-import { dirname as dirname35, join as join77 } from "node:path";
+import { mkdir as mkdir29, writeFile as writeFile23 } from "node:fs/promises";
+import { dirname as dirname35, join as join78 } from "node:path";
 
 // src/project/entityId.ts
 init_cliFeedback();
@@ -99515,7 +99589,7 @@ function assertSafeEntityId(id3) {
 }
 
 // src/project/reviewShared.ts
-var REVIEW_ACTION_ROOT2 = join77(".tmp", "context-runtime", "review-actions");
+var REVIEW_ACTION_ROOT2 = join78(".tmp", "context-runtime", "review-actions");
 var REVIEW_PAYLOAD_SCHEMA = "context.review.decisions.v1";
 function isRecord14(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -99559,7 +99633,7 @@ async function buildApprovedArticleIndex(projectRoot) {
     if (!isApprovedKnowledgeMarkdownPath(rel))
       continue;
     const { absPath, content: content3 } = file;
-    const relPath = join77("knowledge", collection, rel);
+    const relPath = join78("knowledge", collection, rel);
     assetReferencesByRelPath.set(relPath, knowledgeAssetReferences({
       pageRelPath: relPath,
       content: content3
@@ -99572,7 +99646,7 @@ async function buildApprovedArticleIndex(projectRoot) {
       continue;
     const frontmatter2 = hydrateApprovedFrontmatter({
       frontmatter: parsed,
-      relPath: join77(collection, rel),
+      relPath: join78(collection, rel),
       metadata
     });
     const article = articlesByPath.get(`${collection}/${rel}`);
@@ -99627,10 +99701,10 @@ ${yaml3}
 }
 async function writeReviewActionLog(input) {
   const stamp = new Date().toISOString().replace(/[-:.TZ]/gu, "");
-  const relPath = join77(REVIEW_ACTION_ROOT2, `${stamp}-${input.action}-${input.id.replace(/[\\/]+/gu, "_")}.json`);
-  const path2 = join77(input.projectRoot, relPath);
+  const relPath = join78(REVIEW_ACTION_ROOT2, `${stamp}-${input.action}-${input.id.replace(/[\\/]+/gu, "_")}.json`);
+  const path2 = join78(input.projectRoot, relPath);
   await mkdir29(dirname35(path2), { recursive: true });
-  await writeFile22(path2, `${JSON.stringify({
+  await writeFile23(path2, `${JSON.stringify({
     action: input.action,
     id: input.id,
     ...input.summary
@@ -99661,7 +99735,7 @@ async function countFiles(root, predicate) {
     const entries2 = await readCommandDirectory(dir);
     for (const entry of entries2) {
       const rel = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
-      const abs = join78(dir, entry.name);
+      const abs = join79(dir, entry.name);
       if (entry.isDirectory())
         await visit3(abs, rel);
       else if (entry.isFile() && predicate(rel))
@@ -99852,7 +99926,7 @@ async function documentSourceSiteHint(input) {
   });
 }
 function documentSnapshotReadiness(input) {
-  const manifestPath = join78(input.projectRoot, input.manifest);
+  const manifestPath = join79(input.projectRoot, input.manifest);
   if (!existsSync22(manifestPath)) {
     return {
       ready: false,
@@ -99922,7 +99996,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) => !existsSync22(join78(input.projectRoot, input.materializedAt, path2)));
+    ].filter((path2) => !existsSync22(join79(input.projectRoot, input.materializedAt, path2)));
     if (missingFiles.length > 0) {
       return {
         ready: false,
@@ -100388,7 +100462,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(join82(projectRoot, "knowledge"), (rel) => {
+  const approvedPages = await countFiles(join83(projectRoot, "knowledge"), (rel) => {
     if (!isApprovedKnowledgeMarkdownPath(rel) || rel.startsWith("assets/"))
       return false;
     collectionsWithPages.add(rel.split("/")[0]);
@@ -100396,7 +100470,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(join82(projectRoot, "dist"), () => true);
+  const distFiles = await countFiles(join83(projectRoot, "dist"), () => true);
   const verifyStatus = !deferDeliveryChecks && draftStatus.diagnostics.length === 0 ? await readVerifyStatus(projectRoot) : { issues: [], diagnostics: [] };
   const pendingCapture = pendingDocumentCaptureCommands({
     phases,
@@ -100765,14 +100839,14 @@ function bindWorkflowExecutionContext(result, context) {
 // src/project/workflow/workflowRouteOutput.ts
 init_atomicWrite();
 import { createHash as createHash23 } from "node:crypto";
-import { join as join83 } from "node:path";
+import { join as join84 } from "node:path";
 async function workflowRouteOutput(projectRoot, route) {
   if (!route)
     return null;
   const body = `${JSON.stringify(route, null, 2)}
 `;
   const digest6 = createHash23("sha256").update(body).digest("hex");
-  const file = join83(projectRoot, ".tmp/context-runtime/routes", `${digest6}.json`);
+  const file = join84(projectRoot, ".tmp/context-runtime/routes", `${digest6}.json`);
   await atomicWriteFile(file, body);
   return {
     file,
@@ -100788,7 +100862,7 @@ async function workflowRunResultFile(projectRoot, result) {
   const body = `${JSON.stringify(result, null, 2)}
 `;
   const digest6 = createHash23("sha256").update(body).digest("hex");
-  const file = join83(projectRoot, ".tmp/context-runtime/action-results", `${digest6}.run.json`);
+  const file = join84(projectRoot, ".tmp/context-runtime/action-results", `${digest6}.run.json`);
   await atomicWriteFile(file, body);
   return file;
 }
@@ -104162,8 +104236,8 @@ function renderReviewMarkdown(markdown, pageTitle) {
 
 // src/project/reviewHtml.ts
 init_candidateLedger();
-import { mkdir as mkdir30, writeFile as writeFile23 } from "node:fs/promises";
-import { dirname as dirname38, isAbsolute as isAbsolute15, join as join84, resolve as resolve28 } from "node:path";
+import { mkdir as mkdir30, writeFile as writeFile24 } from "node:fs/promises";
+import { dirname as dirname38, isAbsolute as isAbsolute15, join as join85, resolve as resolve28 } from "node:path";
 
 // src/project/reviewHtmlPresentation.ts
 import { dirname as dirname37 } from "node:path";
@@ -104325,7 +104399,7 @@ var REVIEW_HTML_STYLES = `
 `;
 
 // src/project/reviewHtml.ts
-var REVIEW_HTML_ROOT = join84(".tmp", "context-runtime", "review");
+var REVIEW_HTML_ROOT = join85(".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");
@@ -104781,7 +104855,7 @@ function renderReviewHtml(candidates, reviewScope) {
 }
 function resolveOutputPath(projectRoot, outPath, reviewScope) {
   if (outPath === undefined)
-    return join84(projectRoot, REVIEW_HTML_ROOT, `${reviewScope}.html`);
+    return join85(projectRoot, REVIEW_HTML_ROOT, `${reviewScope}.html`);
   return isAbsolute15(outPath) ? outPath : resolve28(projectRoot, outPath);
 }
 async function writeReviewHtml(input) {
@@ -104792,7 +104866,7 @@ 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 mkdir30(dirname38(outPath), { recursive: true });
-  await writeFile23(outPath, renderReviewHtml(candidates, reviewScope), "utf8");
+  await writeFile24(outPath, renderReviewHtml(candidates, reviewScope), "utf8");
   return {
     path: outPath,
     candidates: candidates.length,
@@ -104805,8 +104879,8 @@ async function writeReviewHtml(input) {
 init_productionRequirements();
 init_dist();
 init_atomicWrite();
-import { mkdir as mkdir31, readFile as readFile66 } from "node:fs/promises";
-import { join as join85 } from "node:path";
+import { mkdir as mkdir31, readFile as readFile67 } from "node:fs/promises";
+import { join as join86 } from "node:path";
 var REVIEW_BATCH_MAX_CANDIDATES = 6;
 var REVIEW_BATCH_MAX_BYTES = 512 * 1024;
 async function readerPurposes(projectRoot, sources) {
@@ -104885,12 +104959,12 @@ async function materializeCurrentReviewBatchSet(input) {
   const batches = buildCurrentReviewBatchDocuments(input.candidates);
   const setDigest = digestText(batches.map((batch) => `${batch.task_key}:${batch.digest}`).join(`
 `));
-  const root2 = join85(input.projectRoot, ".tmp", "context-runtime", "review", `current-${setDigest.slice("sha256:".length)}`);
+  const root2 = join86(input.projectRoot, ".tmp", "context-runtime", "review", `current-${setDigest.slice("sha256:".length)}`);
   await mkdir31(root2, { recursive: true });
   const entries2 = [];
   for (const batch of batches) {
-    const path4 = join85(input.projectRoot, ".tmp", "context-runtime", "review", `${batch.task_key}-${batch.digest.slice("sha256:".length)}.md`);
-    const existing = await readFile66(path4, "utf8").catch((error) => {
+    const path4 = join86(input.projectRoot, ".tmp", "context-runtime", "review", `${batch.task_key}-${batch.digest.slice("sha256:".length)}.md`);
+    const existing = await readFile67(path4, "utf8").catch((error) => {
       if (error.code === "ENOENT")
         return;
       throw error;
@@ -104942,7 +105016,7 @@ async function materializeCurrentReviewBatchSet(input) {
   ].join(`
 `);
   const digest6 = digestText(content3);
-  const path3 = join85(root2, "index.md");
+  const path3 = join86(root2, "index.md");
   await atomicWriteFile(path3, `${content3}
 `);
   return {
@@ -104975,11 +105049,11 @@ function shellQuote6(value) {
 }
 function receiptSetPath(receipts) {
   const token = digestText(JSON.stringify(receipts)).slice("sha256:".length);
-  return join86(".tmp", "context-runtime", "workflow", "read-receipts", `${token}.json`);
+  return join87(".tmp", "context-runtime", "workflow", "read-receipts", `${token}.json`);
 }
 async function writeReceiptContinuation(input) {
   const path3 = receiptSetPath(input.receipts);
-  const absolutePath = join86(input.projectRoot, path3);
+  const absolutePath = join87(input.projectRoot, path3);
   await writeJsonAtomic(absolutePath, input.receipts);
   const contextCommand = input.managed ? [
     "context",
@@ -105074,7 +105148,7 @@ async function materializeContextWorkflowResource(input) {
   const resourceId = workflowResourceId(input.resourceId);
   const content3 = renderContextWorkflowResource(resourceId, status);
   const location = await materializeResource(await loadContextWorkflowProvider(), resourceId, {
-    cache: join86(found.projectRoot, ".tmp", "context-runtime", "workflow", "resources"),
+    cache: join87(found.projectRoot, ".tmp", "context-runtime", "workflow", "resources"),
     workspace: found.projectRoot,
     revision: input.revision,
     input: {
@@ -105106,7 +105180,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(`@${join86(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(`@${join87(found.projectRoot, continuation.path)}`)} --format json`;
   return {
     protocol: "context.workflow.resource.v1",
     id: resourceId,
@@ -105167,14 +105241,14 @@ async function acknowledgeCurrentWorkflowResources(input) {
   const reevaluated = await reevaluateProjectStatusWorkflow({
     snapshot,
     resourceReceipts: normalizedReceipts,
-    resourceReceiptsReference: `@${join86(found.projectRoot, continuation.path)}`
+    resourceReceiptsReference: `@${join87(found.projectRoot, continuation.path)}`
   });
   return {
     ...reevaluated,
     resourceAcknowledgement: {
       protocol: "context.workflow.resource-receipts.v1",
       acknowledged: directResources.length,
-      receiptReference: `@${join86(found.projectRoot, continuation.path)}`
+      receiptReference: `@${join87(found.projectRoot, continuation.path)}`
     }
   };
 }
@@ -105220,9 +105294,9 @@ init_cliFeedback();
 init_errors3();
 init_exitCode();
 init_workspace();
-import { readFile as readFile67 } from "node:fs/promises";
-import { isAbsolute as isAbsolute16, join as join87, sep as sep6, resolve as resolve29 } from "node:path";
-var RECEIPT_DIRECTORY = join87(".tmp", "context-runtime", "workflow", "read-receipts");
+import { readFile as readFile68 } from "node:fs/promises";
+import { isAbsolute as isAbsolute16, join as join88, sep as sep6, resolve as resolve29 } from "node:path";
+var RECEIPT_DIRECTORY = join88(".tmp", "context-runtime", "workflow", "read-receipts");
 function workflowResourceReceiptCwd(value, cwd) {
   if (value === undefined || !value.startsWith("@"))
     return cwd;
@@ -105240,7 +105314,7 @@ async function receiptDocument(value, cwd) {
   let source2 = value;
   if (value.startsWith("@")) {
     try {
-      source2 = await readFile67(resolve29(cwd, value.slice(1)), "utf8");
+      source2 = await readFile68(resolve29(cwd, value.slice(1)), "utf8");
     } catch (error) {
       const ioCode = error !== null && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : undefined;
       throw new ContextError(ExitCode.UserError, "resource read receipt file is unavailable", {
@@ -105486,17 +105560,17 @@ function compactJsonResult(result, verbose) {
 
 // src/project/runLog.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { mkdir as mkdir32, writeFile as writeFile24 } from "node:fs/promises";
-import { dirname as dirname39, join as join90 } from "node:path";
+import { mkdir as mkdir32, writeFile as writeFile25 } from "node:fs/promises";
+import { dirname as dirname39, join as join91 } from "node:path";
 var createPhaseRunId = () => {
   const timestamp = new Date().toISOString().replace(/[-:.TZ]/gu, "");
   return `run_${timestamp}_${randomUUID5().slice(0, 8)}`;
 };
 async function writePhaseRunLog(input) {
-  const relPath = join90(".tmp", "context-runtime", "runs", `${input.runId}.json`);
-  const absPath = join90(input.projectRoot, relPath);
+  const relPath = join91(".tmp", "context-runtime", "runs", `${input.runId}.json`);
+  const absPath = join91(input.projectRoot, relPath);
   await mkdir32(dirname39(absPath), { recursive: true });
-  await writeFile24(absPath, `${JSON.stringify({
+  await writeFile25(absPath, `${JSON.stringify({
     run_id: input.runId,
     phase_id: input.phase.id,
     phase_kind: input.phase.kind,
@@ -106441,7 +106515,7 @@ init_workflowFacts();
 init_cliFeedback();
 init_errors3();
 init_exitCode();
-import { readFile as readFile72 } from "node:fs/promises";
+import { readFile as readFile73 } from "node:fs/promises";
 import { isAbsolute as isAbsolute18, resolve as resolve30 } from "node:path";
 
 // src/project/reviewApply.ts
@@ -106454,8 +106528,8 @@ init_writeLock();
 init_reviewApplyIndexer();
 init_approvedKnowledgeSnapshots();
 import { existsSync as existsSync25 } from "node:fs";
-import { readFile as readFile70 } from "node:fs/promises";
-import { join as join91 } from "node:path";
+import { readFile as readFile71 } from "node:fs/promises";
+import { join as join92 } from "node:path";
 
 // src/project/reviewCandidateAuthority.ts
 init_src2();
@@ -106552,7 +106626,7 @@ async function prepareApprovedPage(input) {
       next: "Refresh the current production or article revision, then reopen Review before approval."
     });
   }
-  const relPath = join91("knowledge", input.record.path);
+  const relPath = join92("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("\\")))
@@ -106567,13 +106641,13 @@ async function prepareApprovedPage(input) {
       next: "Resolve the approved page path migration explicitly before approving this candidate."
     });
   }
-  const absPath = join91(input.projectRoot, relPath);
-  const existing = existsSync25(absPath) ? await readFile70(absPath, "utf8") : undefined;
+  const absPath = join92(input.projectRoot, relPath);
+  const existing = existsSync25(absPath) ? await readFile71(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 readFile70(join91(input.projectRoot, "knowledge", previousPath), "utf8") };
+    previous3 = { path: `knowledge/${previousPath}`, content: await readFile71(join92(input.projectRoot, "knowledge", previousPath), "utf8") };
   }
   if (input.record.approved_revision !== undefined) {
     const base = previous3?.content ?? existing;
@@ -106620,7 +106694,7 @@ async function prepareApprovedPage(input) {
 }
 async function readProjectFileMaybe(projectRoot, relPath) {
   try {
-    return await readFile70(join91(projectRoot, relPath), "utf8");
+    return await readFile71(join92(projectRoot, relPath), "utf8");
   } catch (error) {
     if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT") {
       return;
@@ -106813,7 +106887,7 @@ async function applyReviewDecisions(input) {
           });
         }
         seenApprovedIds.set(approvedRef, row.candidate_id);
-        const approvedPath = join91("knowledge", row.path);
+        const approvedPath = join92("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}`, {
@@ -106863,7 +106937,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 readFile70(join91(input.projectRoot, path3), "utf8");
+        const before = await readFile71(join92(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 }));
@@ -106917,17 +106991,17 @@ async function applyReviewDecisions(input) {
 }
 
 // src/project/reviewMaintenance.ts
-import { readFile as readFile71, writeFile as writeFile25 } from "node:fs/promises";
+import { readFile as readFile72, writeFile as writeFile26 } from "node:fs/promises";
 init_writeLock();
 init_verifyFrontmatter();
 function deprecateApprovedPage(input) {
   return withProjectWriteLock(input.projectRoot, "deprecate-article", async () => {
     const page = await approvedPageForArticleId(input.projectRoot, input.viewRef);
-    const original = await readFile71(page.path, "utf8");
+    const original = await readFile72(page.path, "utf8");
     const content3 = parseFrontmatterLoose(original).deprecated === true ? original : updateFrontmatter(original, (metadata) => ({ ...metadata, deprecated: true, timestamp: new Date().toISOString() }));
     const changed = content3 !== original;
     if (changed)
-      await writeFile25(page.path, content3, "utf8");
+      await writeFile26(page.path, content3, "utf8");
     const actionLog = await writeReviewActionLog({
       projectRoot: input.projectRoot,
       action: "deprecate",
@@ -106943,12 +107017,12 @@ init_candidateLedger();
 
 // src/project/localHtmlReport.ts
 import { execFile as execFile10 } from "node:child_process";
-import { isAbsolute as isAbsolute17, join as join92 } from "node:path";
+import { isAbsolute as isAbsolute17, join as join93 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import { promisify as promisify10 } from "node:util";
 var execFileAsync5 = promisify10(execFile10);
 function htmlReportReference(input) {
-  const absolutePath = isAbsolute17(input.path) ? input.path : join92(input.projectRoot, input.path);
+  const absolutePath = isAbsolute17(input.path) ? input.path : join93(input.projectRoot, input.path);
   return {
     format: "html",
     path: input.path,
@@ -107120,7 +107194,7 @@ function parseReviewPayloadText(raw) {
 async function readReviewPayloadFile(filePath2) {
   let raw;
   try {
-    raw = await readFile72(filePath2, "utf8");
+    raw = await readFile73(filePath2, "utf8");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new ContextError(ExitCode.UserError, `review payload file cannot be read: ${filePath2}`, {
@@ -107951,8 +108025,8 @@ init_exitCode();
 init_maintenanceStorage();
 init_productionFeedback();
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { readFile as readFile73 } from "node:fs/promises";
-import { join as join93 } from "node:path";
+import { readFile as readFile74 } from "node:fs/promises";
+import { join as join94 } from "node:path";
 async function beginProductionRevision(input) {
   return withProductionFeedback({ operation: "revision" }, () => withProjectWriteLock(input.projectRoot, "production-revision", async () => {
     await recoverDurableMultiFileTransactions(input.projectRoot);
@@ -107991,7 +108065,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 readFile73(await safeProjectTarget(input.projectRoot, join93("knowledge", path3)), "utf8");
+      const markdown = prior?.body ?? await readFile74(await safeProjectTarget(input.projectRoot, join94("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) {
@@ -108168,7 +108242,7 @@ init_cliFeedback();
 init_errors3();
 init_exitCode();
 var import_yaml40 = __toESM(require_dist(), 1);
-import { readFile as readFile74 } from "node:fs/promises";
+import { readFile as readFile75 } from "node:fs/promises";
 function userInputError2(message, detail = {}) {
   return new ContextError(ExitCode.UserError, message, {
     category: ErrorCategory.UserInputInvalid,
@@ -108237,7 +108311,7 @@ async function readPayloadTextFromStdin(stdin) {
 }
 async function readPayloadText(path3) {
   if (path3 !== "-")
-    return readFile74(path3, "utf8");
+    return readFile75(path3, "utf8");
   return readPayloadTextFromStdin(process.stdin);
 }
 async function readYamlOrJsonInput(input) {
@@ -108631,7 +108705,7 @@ init_atomicWrite();
 var import_yaml43 = __toESM(require_dist(), 1);
 import { Buffer as Buffer4 } from "node:buffer";
 import { createHash as createHash29 } from "node:crypto";
-import { join as join97 } from "node:path";
+import { join as join98 } from "node:path";
 var INLINE_LIMIT = 16 * 1024;
 function record4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
@@ -108657,8 +108731,8 @@ async function prepareActionCompletionOutput(input) {
   if (production && Buffer4.byteLength(full) <= INLINE_LIMIT)
     return input.result;
   const digest6 = createHash29("sha256").update(full).digest("hex");
-  const root2 = join97(input.projectRoot, ".tmp/context-runtime/action-results");
-  const resultFile = join97(root2, `${digest6}.json`);
+  const root2 = join98(input.projectRoot, ".tmp/context-runtime/action-results");
+  const resultFile = join98(root2, `${digest6}.json`);
   await atomicWriteFile(resultFile, full);
   if (production)
     return {
@@ -108669,7 +108743,7 @@ async function prepareActionCompletionOutput(input) {
       ...pick(result, ["next", "next_preparation"])
     };
   const next2 = record4(result.next) ?? record4(record4(result.workflow)?.current) ?? record4(record4(result.continuation)?.next);
-  const nextFile = next2 === undefined ? undefined : join97(root2, `${digest6}.next.json`);
+  const nextFile = next2 === undefined ? undefined : join98(root2, `${digest6}.next.json`);
   if (nextFile !== undefined)
     await atomicWriteFile(nextFile, serializeActionCompletion(next2, "json"));
   const outcomes = (Array.isArray(result.outcomes) ? result.outcomes : []).map(record4).filter((item) => item !== undefined);
@@ -109072,7 +109146,7 @@ init_cliFeedback();
 import { existsSync as existsSync27 } from "node:fs";
 import { readdir as readdir25, rm as rm20 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join as join98 } from "node:path";
+import { join as join99 } 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";
@@ -109089,19 +109163,19 @@ async function cleanClaudePluginCache(opts = {}) {
   for (const mp of marketplaces) {
     if (!mp.isDirectory())
       continue;
-    const mpDir = join98(cacheRoot, mp.name);
+    const mpDir = join99(cacheRoot, mp.name);
     const plugins = await readdir25(mpDir, { withFileTypes: true });
     for (const pl of plugins) {
       if (!pl.isDirectory())
         continue;
-      const plDir = join98(mpDir, pl.name);
+      const plDir = join99(mpDir, pl.name);
       const versions = await readdir25(plDir, { withFileTypes: true });
       for (const ver of versions) {
         if (!ver.isDirectory())
           continue;
         scanned += 1;
-        const verDir = join98(plDir, ver.name);
-        const markerPath = join98(verDir, ORPHAN_MARKER);
+        const verDir = join99(plDir, ver.name);
+        const markerPath = join99(verDir, ORPHAN_MARKER);
         if (!existsSync27(markerPath))
           continue;
         const label2 = `${mp.name}/${pl.name}/${ver.name}`;
@@ -109133,7 +109207,7 @@ function resolveClaudePluginCacheRoot(opts) {
   if (explicitRoot)
     return explicitRoot;
   const home = opts.home ?? process.env[CLAUDE_PLUGIN_CACHE_HOME_ENV] ?? homedir();
-  return join98(home, ".claude", "plugins", "cache");
+  return join99(home, ".claude", "plugins", "cache");
 }
 async function isEmptyDir(dir) {
   try {
@@ -109165,13 +109239,13 @@ init_exitCode();
 
 // src/lib/packageVersion.ts
 import { existsSync as existsSync28, readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname42, join as join99 } from "node:path";
+import { dirname as dirname42, join as join100 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function readPackageVersion() {
   try {
     let dir = dirname42(fileURLToPath7(import.meta.url));
     for (let depth = 0;depth < 8; depth += 1) {
-      const packagePath = join99(dir, "package.json");
+      const packagePath = join100(dir, "package.json");
       if (existsSync28(packagePath)) {
         const parsed = JSON.parse(readFileSync9(packagePath, "utf8"));
         if (typeof parsed.version === "string" && parsed.version.length > 0) {
@@ -109194,7 +109268,7 @@ function readPackageVersion() {
 
 // src/project/sourceCommands.ts
 init_src2();
-import { readFile as readFile87 } from "node:fs/promises";
+import { readFile as readFile88 } from "node:fs/promises";
 import { isAbsolute as isAbsolute22, resolve as resolve37 } from "node:path";
 init_cliFeedback();
 init_errors3();
@@ -109553,11 +109627,11 @@ async function restoreRepositorySources(input) {
 // src/project/sourceDocumentStatus.ts
 init_src2();
 import { existsSync as existsSync30 } from "node:fs";
+import { readFile as readFile81 } from "node:fs/promises";
+import { join as join102 } from "node:path";
+// src/project/sourceCommandViews.ts
 import { readFile as readFile80 } from "node:fs/promises";
 import { join as join101 } from "node:path";
-// src/project/sourceCommandViews.ts
-import { readFile as readFile79 } from "node:fs/promises";
-import { join as join100 } from "node:path";
 init_workspace();
 init_documentBatchManifest();
 function repoSourceAgentView(source2) {
@@ -109620,7 +109694,7 @@ async function fileSourceAgentViewWithNextAction(input) {
   };
 }
 function documentSourceManifestPath(source2) {
-  return source2.snapshot?.manifest ?? join100(source2.materializedAt, "manifest.json");
+  return source2.snapshot?.manifest ?? join101(source2.materializedAt, "manifest.json");
 }
 async function fileSourceDocumentSiteHint(input) {
   const detection = await detectDocumentSiteFiles({
@@ -109630,7 +109704,7 @@ async function fileSourceDocumentSiteHint(input) {
   let snapshotConfigured = false;
   const manifest = documentSourceManifestPath(input.source);
   try {
-    const parsed = parseDocumentSnapshotForSource(JSON.parse(await readFile79(join100(input.projectRoot, manifest), "utf8")), input.source.name);
+    const parsed = parseDocumentSnapshotForSource(JSON.parse(await readFile80(join101(input.projectRoot, manifest), "utf8")), input.source.name);
     snapshotConfigured = manifestUsesMdxJsonDocs(parsed);
   } catch {
     snapshotConfigured = false;
@@ -109662,11 +109736,11 @@ async function larkSourceAgentViewWithNextAction(input) {
 // src/project/sourceDocumentStatus.ts
 init_documentBatchManifest();
 function documentSourceManifestPath2(source2) {
-  return source2.snapshot?.manifest ?? join101(source2.materializedAt, "manifest.json");
+  return source2.snapshot?.manifest ?? join102(source2.materializedAt, "manifest.json");
 }
 async function documentSnapshotState(input) {
   const manifest = documentSourceManifestPath2(input.source);
-  const manifestPath = join101(input.projectRoot, manifest);
+  const manifestPath = join102(input.projectRoot, manifest);
   if (!existsSync30(manifestPath)) {
     return {
       snapshotReady: false,
@@ -109677,7 +109751,7 @@ async function documentSnapshotState(input) {
     };
   }
   try {
-    const parsed = findDocumentSnapshotForSource(JSON.parse(await readFile80(manifestPath, "utf8")), input.source.name);
+    const parsed = findDocumentSnapshotForSource(JSON.parse(await readFile81(manifestPath, "utf8")), input.source.name);
     if (parsed === null) {
       return {
         snapshotReady: false,
@@ -109745,7 +109819,7 @@ async function documentSnapshotState(input) {
     const missing = [
       ...parsed.files.map((file) => file.path),
       ...(parsed.assets ?? []).filter((asset) => asset.content_hash !== undefined).map((asset) => asset.path)
-    ].find((path3) => !existsSync30(join101(input.projectRoot, input.source.materializedAt, path3)));
+    ].find((path3) => !existsSync30(join102(input.projectRoot, input.source.materializedAt, path3)));
     if (missing !== undefined) {
       return {
         snapshotReady: false,
@@ -109846,8 +109920,8 @@ init_errors3();
 init_exitCode();
 var import_yaml46 = __toESM(require_dist(), 1);
 import { createHash as createHash30 } from "node:crypto";
-import { readFile as readFile81, realpath as realpath11 } from "node:fs/promises";
-import { basename as basename12, extname as extname15, isAbsolute as isAbsolute20, join as join102, relative as relative27, resolve as resolve35 } from "node:path";
+import { readFile as readFile82, realpath as realpath11 } from "node:fs/promises";
+import { basename as basename12, extname as extname15, isAbsolute as isAbsolute20, join as join103, relative as relative27, resolve as resolve35 } from "node:path";
 init_writeLock();
 var SOURCE_NAME_PATTERN3 = /^[a-z0-9][a-z0-9._-]*$/u;
 function isDateSourceNamespace(value) {
@@ -109943,7 +110017,7 @@ function assertSafeFileInclude(value) {
 }
 async function readRegistryDocument(projectRoot, registryPath2) {
   try {
-    const content3 = await readFile81(join102(projectRoot, registryPath2), "utf8");
+    const content3 = await readFile82(join103(projectRoot, registryPath2), "utf8");
     return content3.trim().length === 0 ? { sources: [] } : import_yaml46.default.parse(content3);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
@@ -110061,7 +110135,7 @@ async function addFileSourceUnlocked(input) {
     const record6 = entry2;
     return record6.name !== input.name && record6.id !== input.name;
   }), nextEntry];
-  await atomicWriteFile(join102(input.projectRoot, DEFAULT_FILE_SOURCES_REGISTRY_PATH), import_yaml46.default.stringify({ sources: nextSources }));
+  await atomicWriteFile(join103(input.projectRoot, DEFAULT_FILE_SOURCES_REGISTRY_PATH), import_yaml46.default.stringify({ sources: nextSources }));
   const updated = await loadSourcesRegistry({ rootDir: input.projectRoot });
   const entry = updated.files.find((source2) => source2.name === input.name || source2.id === input.name);
   if (entry === undefined) {
@@ -110117,7 +110191,7 @@ async function addLarkSourceUnlocked(input) {
     const record6 = entry2;
     return record6.name !== input.name && record6.id !== input.name;
   }), nextEntry];
-  await atomicWriteFile(join102(input.projectRoot, DEFAULT_LARK_SOURCES_REGISTRY_PATH), import_yaml46.default.stringify({ sources: nextSources }));
+  await atomicWriteFile(join103(input.projectRoot, DEFAULT_LARK_SOURCES_REGISTRY_PATH), import_yaml46.default.stringify({ sources: nextSources }));
   const updated = await loadSourcesRegistry({ rootDir: input.projectRoot });
   const entry = updated.larks.find((source2) => source2.name === input.name || source2.id === input.name);
   if (entry === undefined) {
@@ -110320,8 +110394,8 @@ init_writeLock();
 var import_yaml47 = __toESM(require_dist(), 1);
 import { existsSync as existsSync31 } from "node:fs";
 import { createHash as createHash31 } from "node:crypto";
-import { readFile as readFile82, readdir as readdir26, rm as rm22 } from "node:fs/promises";
-import { isAbsolute as isAbsolute21, join as join103, relative as relative28, resolve as resolve36, sep as sep8 } from "node:path";
+import { readFile as readFile83, readdir as readdir26, rm as rm22 } from "node:fs/promises";
+import { isAbsolute as isAbsolute21, join as join104, relative as relative28, resolve as resolve36, sep as sep8 } from "node:path";
 function sourceIdentity(source2) {
   if (source2.kind === "source.collection")
     return;
@@ -110353,10 +110427,10 @@ function collectStrings(value, output) {
   }
 }
 async function yamlReferences(input) {
-  const absolutePath = join103(input.projectRoot, input.path);
+  const absolutePath = join104(input.projectRoot, input.path);
   if (!existsSync31(absolutePath))
     return false;
-  const parsed = import_yaml47.default.parse(await readFile82(absolutePath, "utf8"));
+  const parsed = import_yaml47.default.parse(await readFile83(absolutePath, "utf8"));
   const strings = [];
   collectStrings(parsed, strings);
   return strings.some((value) => stringReferencesSource(value, input.source));
@@ -110482,8 +110556,8 @@ async function registryRemovalWrite(projectRoot, source2) {
   const path3 = registryPath2(source2.type);
   if (path3 === null)
     return;
-  const absolutePath = join103(projectRoot, path3);
-  const document4 = existsSync31(absolutePath) ? import_yaml47.default.parse(await readFile82(absolutePath, "utf8")) : { sources: [] };
+  const absolutePath = join104(projectRoot, path3);
+  const document4 = existsSync31(absolutePath) ? import_yaml47.default.parse(await readFile83(absolutePath, "utf8")) : { sources: [] };
   return {
     path: absolutePath,
     bytes: import_yaml47.default.stringify(removeDocumentEntry(document4, source2))
@@ -110501,7 +110575,7 @@ function safeManagedMaterializedPath(projectRoot, source2) {
   return absolute;
 }
 function safeManagedManifestPath(projectRoot, source2) {
-  const manifest = source2.manifest ?? join103(source2.materializedAt, "manifest.json");
+  const manifest = source2.manifest ?? join104(source2.materializedAt, "manifest.json");
   if (isAbsolute21(manifest))
     throw unsafeOwnership(source2, manifest);
   const absolute = resolve36(projectRoot, manifest);
@@ -110630,7 +110704,7 @@ async function createRemovalPlan(projectRoot, selector) {
     source: source2,
     registry: registryPath2(source2.type),
     registryBytes: registryWrite?.bytes ?? null,
-    managedBytes: source2.type === "note" || source2.type === "sessions" ? await readFile82(absoluteRemovals[0], "utf8") : null,
+    managedBytes: source2.type === "note" || source2.type === "sessions" ? await readFile83(absoluteRemovals[0], "utf8") : null,
     references,
     cleanup,
     manifestBytes: manifestWrite?.bytes ?? null
@@ -110663,10 +110737,10 @@ function publicRemovalResult(plan, action) {
   };
 }
 async function pruneExtractRuntime(projectRoot, source2) {
-  const fingerprintPath = join103(projectRoot, ".tmp/context-runtime/extract/source-fingerprints.json");
+  const fingerprintPath = join104(projectRoot, ".tmp/context-runtime/extract/source-fingerprints.json");
   const removedPhaseIds = new Set;
   if (existsSync31(fingerprintPath)) {
-    const parsed = JSON.parse(await readFile82(fingerprintPath, "utf8"));
+    const parsed = JSON.parse(await readFile83(fingerprintPath, "utf8"));
     const phases = parsed.phases ?? {};
     const next2 = Object.fromEntries(Object.entries(phases).filter(([phaseId, raw]) => {
       if (raw === null || typeof raw !== "object" || Array.isArray(raw))
@@ -110680,27 +110754,27 @@ async function pruneExtractRuntime(projectRoot, source2) {
     await atomicWriteFile(fingerprintPath, `${JSON.stringify({ ...parsed, phases: next2 }, null, 2)}
 `);
   }
-  const phaseOwnershipPath = join103(projectRoot, ".tmp/context-runtime/extract/custom-phase-candidates.json");
+  const phaseOwnershipPath = join104(projectRoot, ".tmp/context-runtime/extract/custom-phase-candidates.json");
   if (existsSync31(phaseOwnershipPath) && removedPhaseIds.size > 0) {
-    const parsed = JSON.parse(await readFile82(phaseOwnershipPath, "utf8"));
+    const parsed = JSON.parse(await readFile83(phaseOwnershipPath, "utf8"));
     const phases = Object.fromEntries(Object.entries(parsed.phases ?? {}).filter(([phaseId]) => !removedPhaseIds.has(phaseId)));
     await atomicWriteFile(phaseOwnershipPath, `${JSON.stringify({ ...parsed, phases }, null, 2)}
 `);
   }
-  const symbolPath = join103(projectRoot, ".tmp/context-runtime/extract/source-symbols.json");
+  const symbolPath = join104(projectRoot, ".tmp/context-runtime/extract/source-symbols.json");
   if (existsSync31(symbolPath)) {
-    const parsed = JSON.parse(await readFile82(symbolPath, "utf8"));
+    const parsed = JSON.parse(await readFile83(symbolPath, "utf8"));
     const symbols = Array.isArray(parsed.symbols) ? parsed.symbols.filter((entry) => entry === null || typeof entry !== "object" || Array.isArray(entry) || entry.source !== source2.name) : [];
     const phaseFingerprints = Object.fromEntries(Object.entries(parsed.phaseFingerprints ?? {}).filter(([phaseId]) => !removedPhaseIds.has(phaseId)));
     await atomicWriteFile(symbolPath, `${JSON.stringify({ ...parsed, phaseFingerprints, symbols }, null, 2)}
 `);
   }
-  const snapshotRoot = join103(projectRoot, ".tmp/context-runtime/extract/candidates");
+  const snapshotRoot = join104(projectRoot, ".tmp/context-runtime/extract/candidates");
   const visit4 = async (directory) => {
     if (!existsSync31(directory))
       return;
     for (const entry of await readdir26(directory, { withFileTypes: true })) {
-      const path3 = join103(directory, entry.name);
+      const path3 = join104(directory, entry.name);
       if (entry.isDirectory()) {
         await visit4(path3);
         continue;
@@ -110708,7 +110782,7 @@ async function pruneExtractRuntime(projectRoot, source2) {
       if (!entry.isFile() || !entry.name.endsWith(".json"))
         continue;
       try {
-        const parsed = JSON.parse(await readFile82(path3, "utf8"));
+        const parsed = JSON.parse(await readFile83(path3, "utf8"));
         const refs = Array.isArray(parsed.source_refs) ? parsed.source_refs : [];
         if (parsed.source === source2.name || refs.some((ref2) => typeof ref2 === "string" && stringReferencesSource(ref2, source2))) {
           await rm22(path3, { force: true });
@@ -110750,7 +110824,7 @@ async function removeProjectSource(input) {
       });
     }
     await applyAtomicFileBatch({
-      transactionRoot: join103(input.projectRoot, ".tmp", "context-runtime", "source-remove-transactions"),
+      transactionRoot: join104(input.projectRoot, ".tmp", "context-runtime", "source-remove-transactions"),
       writes: [...plan.registryWrite === undefined ? [] : [plan.registryWrite], ...plan.manifestWrite !== undefined ? [plan.manifestWrite] : []],
       removals: plan.absoluteRemovals
     });
@@ -110766,7 +110840,7 @@ init_workspace();
 init_writeLock();
 init_durableMultiFileTransaction();
 init_durableSingleFileTransaction();
-import { readFile as readFile83 } from "node:fs/promises";
+import { readFile as readFile84 } from "node:fs/promises";
 import ts from "typescript";
 function generateSourceConfiguration(text10, selected) {
   const file = ts.createSourceFile("index.ts", text10, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
@@ -110906,7 +110980,7 @@ function generateSourceConfiguration(text10, selected) {
 async function configureRegisteredSources(projectRoot, selected) {
   return withProjectWriteLock(projectRoot, "source-project-configuration", async () => {
     const path3 = "src/index.ts";
-    const config = JSON.parse(await readFile83(await safeProjectTarget(projectRoot, "package.json"), "utf8"));
+    const config = JSON.parse(await readFile84(await safeProjectTarget(projectRoot, "package.json"), "utf8"));
     if (config.context?.entry !== path3)
       return {
         status: "manual",
@@ -110915,7 +110989,7 @@ async function configureRegisteredSources(projectRoot, selected) {
         sources: selected
       };
     const target = await safeProjectTarget(projectRoot, path3);
-    const text10 = await readFile83(target, "utf8");
+    const text10 = await readFile84(target, "utf8");
     const updated = generateSourceConfiguration(text10, selected);
     if (updated === undefined)
       return {
@@ -110995,7 +111069,7 @@ async function readIncludeList(projectRoot, path3) {
   }
   let content3;
   try {
-    content3 = await readFile87(isAbsolute22(trimmed) ? resolve37(trimmed) : resolve37(projectRoot, trimmed), "utf8");
+    content3 = await readFile88(isAbsolute22(trimmed) ? resolve37(trimmed) : resolve37(projectRoot, trimmed), "utf8");
   } catch (error) {
     throw new ContextError(ExitCode.UserError, `cannot read include list: ${trimmed}`, {
       category: ErrorCategory.UserInputInvalid,
@@ -111393,7 +111467,7 @@ init_exitCode();
 var import_yaml50 = __toESM(require_dist(), 1);
 import { constants as constants6, existsSync as existsSync32 } from "node:fs";
 import { lstat as lstat13, open as open5, readdir as readdir27 } from "node:fs/promises";
-import { dirname as dirname44, join as join105, resolve as resolve38 } from "node:path";
+import { dirname as dirname44, join as join106, resolve as resolve38 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function bundledSkillRoot() {
   const directory = dirname44(fileURLToPath8(import.meta.url));
@@ -111423,7 +111497,7 @@ async function readProductionSkills(root2) {
   const entries2 = (await readdir27(root2, { withFileTypes: true })).filter((entry) => entry.isDirectory()).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
   const skills = [];
   for (const directory of entries2) {
-    const entry = join105(root2, directory.name, "SKILL.md");
+    const entry = join106(root2, directory.name, "SKILL.md");
     if (!(await lstat13(entry)).isFile())
       throw new TypeError(`Skill entry must be a regular file: ${entry}`);
     const handle2 = await open5(entry, constants6.O_RDONLY | constants6.O_NOFOLLOW | constants6.O_NONBLOCK);
@@ -111831,7 +111905,7 @@ init_cliFeedback();
 init_errors3();
 init_exitCode();
 import { existsSync as existsSync35 } from "node:fs";
-import { dirname as dirname47, join as join107, resolve as resolve40 } from "node:path";
+import { dirname as dirname47, join as join108, resolve as resolve40 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 
 // src/project/pluginInstallTargets.ts
@@ -111840,9 +111914,9 @@ init_errors3();
 init_exitCode();
 import { execFile as execFile12 } from "node:child_process";
 import { existsSync as existsSync34 } from "node:fs";
-import { cp as cp2, mkdir as mkdir35, readdir as readdir28, readFile as readFile88, rename as rename8, rm as rm23, writeFile as writeFile26 } from "node:fs/promises";
+import { cp as cp2, mkdir as mkdir35, readdir as readdir28, readFile as readFile89, rename as rename9, rm as rm23, writeFile as writeFile27 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname46, join as join106 } from "node:path";
+import { dirname as dirname46, join as join107 } from "node:path";
 import { promisify as promisify12 } from "node:util";
 var execFileAsync7 = promisify12(execFile12);
 var MARKETPLACE_NAME = "c4a";
@@ -111896,23 +111970,23 @@ async function claudePluginInstalled(pluginId) {
   }
 }
 function codexHome() {
-  return process.env.CODEX_HOME?.trim() || join106(homedir2(), ".codex");
+  return process.env.CODEX_HOME?.trim() || join107(homedir2(), ".codex");
 }
 function claudePluginCacheRoot() {
   const explicitRoot = process.env[CLAUDE_PLUGIN_CACHE_ROOT_ENV2]?.trim();
   if (explicitRoot)
     return explicitRoot;
   const home = process.env[CLAUDE_PLUGIN_CACHE_HOME_ENV2]?.trim() || homedir2();
-  return join106(home, ".claude", "plugins", "cache");
+  return join107(home, ".claude", "plugins", "cache");
 }
 function sharedSkillsRoot() {
-  return process.env[SHARED_SKILLS_ROOT_ENV]?.trim() || join106(homedir2(), ".agents", "skills");
+  return process.env[SHARED_SKILLS_ROOT_ENV]?.trim() || join107(homedir2(), ".agents", "skills");
 }
 function claudeSkillsRoot() {
-  return process.env[CLAUDE_SKILLS_ROOT_ENV]?.trim() || join106(homedir2(), ".claude", "skills");
+  return process.env[CLAUDE_SKILLS_ROOT_ENV]?.trim() || join107(homedir2(), ".claude", "skills");
 }
 function cursorPluginRoot() {
-  return process.env[CURSOR_PLUGIN_ROOT_ENV]?.trim() || join106(homedir2(), ".cursor", "plugins", "local", PLUGIN_NAME);
+  return process.env[CURSOR_PLUGIN_ROOT_ENV]?.trim() || join107(homedir2(), ".cursor", "plugins", "local", PLUGIN_NAME);
 }
 function blockHeader(line) {
   const match = line.match(/^\s*\[([^\]]+)\]\s*$/u);
@@ -111963,8 +112037,8 @@ function pruneLegacyCodexConfigContent(content3) {
 `), removed };
 }
 async function pruneLegacyCodexConfig(dryRun, steps) {
-  const configPath = join106(codexHome(), "config.toml");
-  const current2 = await readFile88(configPath, "utf8").catch(() => "");
+  const configPath = join107(codexHome(), "config.toml");
+  const current2 = await readFile89(configPath, "utf8").catch(() => "");
   if (!current2)
     return;
   const next2 = pruneLegacyCodexConfigContent(current2);
@@ -111976,11 +112050,11 @@ async function pruneLegacyCodexConfig(dryRun, steps) {
     status: dryRun ? "planned" : "ran"
   });
   if (!dryRun) {
-    await writeFile26(configPath, next2.content, "utf8");
+    await writeFile27(configPath, next2.content, "utf8");
   }
 }
 async function pruneCodexPluginCacheForName(pluginName, keepVersion, dryRun, steps) {
-  const cacheRoot = join106(codexHome(), "plugins", "cache", MARKETPLACE_NAME, pluginName);
+  const cacheRoot = join107(codexHome(), "plugins", "cache", MARKETPLACE_NAME, pluginName);
   if (!existsSync34(cacheRoot))
     return;
   const versions = (await readdir28(cacheRoot, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory() && entry.name !== keepVersion).map((entry) => entry.name).sort();
@@ -111992,7 +112066,7 @@ async function pruneCodexPluginCacheForName(pluginName, keepVersion, dryRun, ste
     status: dryRun ? "planned" : "ran"
   });
   if (!dryRun)
-    await Promise.all(versions.map((version3) => rm23(join106(cacheRoot, version3), { recursive: true, force: true })));
+    await Promise.all(versions.map((version3) => rm23(join107(cacheRoot, version3), { recursive: true, force: true })));
 }
 async function pruneCodexPluginCache(currentVersion, dryRun, steps) {
   await pruneCodexPluginCacheForName(PLUGIN_NAME, currentVersion, dryRun, steps);
@@ -112016,15 +112090,15 @@ async function pruneClaudeOrphanContextCache(dryRun, steps) {
   for (const marketplace of marketplaces) {
     if (!marketplace.isDirectory())
       continue;
-    const pluginDir = join106(cacheRoot, marketplace.name, PLUGIN_NAME);
+    const pluginDir = join107(cacheRoot, marketplace.name, PLUGIN_NAME);
     if (!existsSync34(pluginDir))
       continue;
     const versions = await readdir28(pluginDir, { withFileTypes: true }).catch(() => []);
     for (const version3 of versions) {
       if (!version3.isDirectory())
         continue;
-      const versionDir = join106(pluginDir, version3.name);
-      if (!existsSync34(join106(versionDir, ORPHAN_MARKER2)))
+      const versionDir = join107(pluginDir, version3.name);
+      if (!existsSync34(join107(versionDir, ORPHAN_MARKER2)))
         continue;
       removed.push(`${marketplace.name}/${PLUGIN_NAME}/${version3.name}`);
       if (!dryRun) {
@@ -112034,7 +112108,7 @@ async function pruneClaudeOrphanContextCache(dryRun, steps) {
     if (!dryRun && await isEmptyDir2(pluginDir)) {
       await rm23(pluginDir, { recursive: true, force: true });
     }
-    const marketplaceDir = join106(cacheRoot, marketplace.name);
+    const marketplaceDir = join107(cacheRoot, marketplace.name);
     if (!dryRun && await isEmptyDir2(marketplaceDir)) {
       await rm23(marketplaceDir, { recursive: true, force: true });
     }
@@ -112055,7 +112129,7 @@ async function pruneClaudeLegacyPluginCache(dryRun, steps) {
     return;
   const removed = [];
   for (const pluginName of LEGACY_PLUGIN_NAMES) {
-    const pluginDir = join106(cacheRoot, MARKETPLACE_NAME, pluginName);
+    const pluginDir = join107(cacheRoot, MARKETPLACE_NAME, pluginName);
     if (!existsSync34(pluginDir))
       continue;
     removed.push(`${MARKETPLACE_NAME}/${pluginName}`);
@@ -112072,11 +112146,11 @@ async function pruneClaudeLegacyPluginCache(dryRun, steps) {
   }
 }
 async function pruneClaudeSupersededContextCache(root2, dryRun, steps) {
-  const manifest = await readFile88(join106(root2, "claude", ".claude-plugin", "plugin.json"), "utf8").then((content3) => JSON.parse(content3)).catch(() => null);
+  const manifest = await readFile89(join107(root2, "claude", ".claude-plugin", "plugin.json"), "utf8").then((content3) => JSON.parse(content3)).catch(() => null);
   const currentVersion = typeof manifest?.version === "string" ? manifest.version : null;
   if (!currentVersion)
     return;
-  const pluginDir = join106(claudePluginCacheRoot(), MARKETPLACE_NAME, PLUGIN_NAME);
+  const pluginDir = join107(claudePluginCacheRoot(), MARKETPLACE_NAME, PLUGIN_NAME);
   const staleVersions = (await readdir28(pluginDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory() && entry.name !== currentVersion).map((entry) => entry.name);
   if (staleVersions.length === 0)
     return;
@@ -112086,7 +112160,7 @@ async function pruneClaudeSupersededContextCache(root2, dryRun, steps) {
     status: dryRun ? "planned" : "ran"
   });
   if (!dryRun) {
-    await Promise.all(staleVersions.map((version3) => rm23(join106(pluginDir, version3), { recursive: true, force: true })));
+    await Promise.all(staleVersions.map((version3) => rm23(join107(pluginDir, version3), { recursive: true, force: true })));
   }
 }
 function enableCodexPluginConfig(content3) {
@@ -112150,33 +112224,33 @@ source = ${JSON.stringify(root2)}
 `;
 }
 async function ensureCodexPluginEnabled() {
-  const configPath = join106(codexHome(), "config.toml");
+  const configPath = join107(codexHome(), "config.toml");
   await mkdir35(dirname46(configPath), { recursive: true });
-  const current2 = await readFile88(configPath, "utf8").catch(() => "");
+  const current2 = await readFile89(configPath, "utf8").catch(() => "");
   const next2 = enableCodexPluginConfig(current2);
   if (next2 !== current2) {
-    await writeFile26(configPath, next2, "utf8");
+    await writeFile27(configPath, next2, "utf8");
   }
 }
 async function ensureCodexLocalMarketplace(root2) {
-  const configPath = join106(codexHome(), "config.toml");
+  const configPath = join107(codexHome(), "config.toml");
   await mkdir35(dirname46(configPath), { recursive: true });
-  const current2 = await readFile88(configPath, "utf8").catch(() => "");
+  const current2 = await readFile89(configPath, "utf8").catch(() => "");
   const next2 = upsertCodexLocalMarketplaceConfig(current2, root2);
   if (next2 !== current2) {
-    await writeFile26(configPath, next2, "utf8");
+    await writeFile27(configPath, next2, "utf8");
   }
 }
 async function codexPluginVersion(root2) {
-  const manifestPath = join106(root2, "codex", ".codex-plugin", "plugin.json");
-  const manifest = JSON.parse(await readFile88(manifestPath, "utf8"));
+  const manifestPath = join107(root2, "codex", ".codex-plugin", "plugin.json");
+  const manifest = JSON.parse(await readFile89(manifestPath, "utf8"));
   if (typeof manifest.version !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(manifest.version)) {
     throw new Error(`Codex plugin manifest has an invalid version: ${manifestPath}`);
   }
   return manifest.version;
 }
 function codexPluginCacheDir(version3) {
-  return join106(codexHome(), "plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME, version3);
+  return join107(codexHome(), "plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME, version3);
 }
 async function replaceDirectoryFromSource(source2, target) {
   await mkdir35(dirname46(target), { recursive: true });
@@ -112187,19 +112261,19 @@ async function replaceDirectoryFromSource(source2, target) {
   const hadPrevious = existsSync34(target);
   try {
     if (hadPrevious)
-      await rename8(target, previous3);
-    await rename8(temporary, target);
+      await rename9(target, previous3);
+    await rename9(temporary, target);
     if (hadPrevious)
       await rm23(previous3, { recursive: true, force: true });
   } catch (error) {
     await rm23(temporary, { recursive: true, force: true });
     if (hadPrevious && !existsSync34(target) && existsSync34(previous3))
-      await rename8(previous3, target);
+      await rename9(previous3, target);
     throw error;
   }
 }
 async function materializeCodexPluginCache(root2, version3, dryRun, steps) {
-  const source2 = join106(root2, "codex");
+  const source2 = join107(root2, "codex");
   const target = codexPluginCacheDir(version3);
   steps.push({
     agent: "codex",
@@ -112211,16 +112285,16 @@ async function materializeCodexPluginCache(root2, version3, dryRun, steps) {
   await replaceDirectoryFromSource(source2, target);
 }
 async function bundledProviderSkillNames(root2) {
-  const skillsRoot = join106(root2, "skills");
+  const skillsRoot = join107(root2, "skills");
   const entries2 = await readdir28(skillsRoot, { withFileTypes: true });
   const names = [];
   for (const entry of entries2) {
     if (!entry.isDirectory() || entry.name === "context")
       continue;
-    const skillPath = join106(skillsRoot, entry.name, "SKILL.md");
+    const skillPath = join107(skillsRoot, entry.name, "SKILL.md");
     if (!existsSync34(skillPath))
       continue;
-    const skill = await readFile88(skillPath, "utf8");
+    const skill = await readFile89(skillPath, "utf8");
     if (!/^\s*context-role:\s*["']?indexer-provider["']?\s*$/mu.test(skill))
       continue;
     names.push(entry.name);
@@ -112232,10 +112306,10 @@ async function bundledProviderSkillNames(root2) {
   return names;
 }
 async function materializeProviderSkills(root2, targetRoot, agent, dryRun, steps) {
-  const sourceRoot2 = join106(root2, "skills");
+  const sourceRoot2 = join107(root2, "skills");
   for (const name3 of await bundledProviderSkillNames(root2)) {
-    const source2 = join106(sourceRoot2, name3);
-    const target = join106(targetRoot, name3);
+    const source2 = join107(sourceRoot2, name3);
+    const target = join107(targetRoot, name3);
     steps.push({
       agent,
       command: `materialize lifecycle Provider skill: ${shellQuote8(source2)} -> ${shellQuote8(target)}`,
@@ -112246,7 +112320,7 @@ async function materializeProviderSkills(root2, targetRoot, agent, dryRun, steps
   }
 }
 async function installCursor(root2, dryRun, steps) {
-  const source2 = join106(root2, "cursor");
+  const source2 = join107(root2, "cursor");
   const target = cursorPluginRoot();
   steps.push({
     agent: "cursor",
@@ -112301,12 +112375,12 @@ async function installCodex(root2, dryRun, steps) {
   steps.push({ agent: "codex", command: commandLine("codex", addArgs), status: dryRun ? "planned" : "ran" });
   steps.push({
     agent: "codex",
-    command: `ensure ${shellQuote8(join106(codexHome(), "config.toml"))} registers local marketplace ${shellQuote8(MARKETPLACE_NAME)}`,
+    command: `ensure ${shellQuote8(join107(codexHome(), "config.toml"))} registers local marketplace ${shellQuote8(MARKETPLACE_NAME)}`,
     status: dryRun ? "planned" : "ran"
   });
   steps.push({
     agent: "codex",
-    command: `ensure ${shellQuote8(join106(codexHome(), "config.toml"))} enables ${shellQuote8(PLUGIN_ID)}`,
+    command: `ensure ${shellQuote8(join107(codexHome(), "config.toml"))} enables ${shellQuote8(PLUGIN_ID)}`,
     status: dryRun ? "planned" : "ran"
   });
   if (dryRun) {
@@ -112361,13 +112435,13 @@ function pluginRootCandidates() {
     return [resolve40(envRoot)];
   const candidates = [];
   for (const dir of packageCandidateDirs()) {
-    candidates.push(join107(dir, "plugins"));
-    candidates.push(join107(dir, "dist", "plugins"));
+    candidates.push(join108(dir, "plugins"));
+    candidates.push(join108(dir, "dist", "plugins"));
   }
   return [...new Set(candidates)];
 }
 function isInstallablePluginRoot(root2) {
-  return existsSync35(join107(root2, ".claude-plugin", "marketplace.json")) && existsSync35(join107(root2, ".agents", "plugins", "marketplace.json")) && existsSync35(join107(root2, "claude", ".claude-plugin", "plugin.json")) && existsSync35(join107(root2, "codex", ".codex-plugin", "plugin.json")) && existsSync35(join107(root2, "cursor", ".cursor-plugin", "plugin.json")) && existsSync35(join107(root2, "skills"));
+  return existsSync35(join108(root2, ".claude-plugin", "marketplace.json")) && existsSync35(join108(root2, ".agents", "plugins", "marketplace.json")) && existsSync35(join108(root2, "claude", ".claude-plugin", "plugin.json")) && existsSync35(join108(root2, "codex", ".codex-plugin", "plugin.json")) && existsSync35(join108(root2, "cursor", ".cursor-plugin", "plugin.json")) && existsSync35(join108(root2, "skills"));
 }
 function resolveBundledPluginsRoot() {
   const candidates = pluginRootCandidates();
@@ -112528,6 +112602,7 @@ function registerPluginCommands(program2) {
 }
 
 // src/registerPackageCommands.ts
+init_packageSiteAddress();
 init_cliFeedback();
 init_errors3();
 init_packageTemplateReview();
@@ -112535,6 +112610,13 @@ init_workspace();
 init_exitCode();
 function registerPackageCommands(program2) {
   const packageCommand = program2.command("package").description("Inspect or resolve package output configuration");
+  packageCommand.command("site-url <package-name> <url>").description("Record a deployed site root in existing site maps without network checks").action(async (packageName, url) => {
+    const root2 = findContextProjectRoot(process.cwd())?.projectRoot;
+    if (!root2)
+      throw new TypeError("Run inside a Context workspace");
+    process.stdout.write(JSON.stringify(await recordPackageSiteUrl(root2, packageName, url), null, 2) + `
+`);
+  });
   const packageTemplate = packageCommand.command("template").description("Manage package template review state");
   packageTemplate.command("accept [package-name]").description("Explicitly accept an unchanged generated starter template").option("--all", "accept all unchanged generated starter templates").option("--format <format>", "output format: text | json", "text").action(async (packageName, options) => {
     if (packageName === undefined === (options.all !== true)) {
@@ -112597,10 +112679,10 @@ function readQuickstartPath() {
   try {
     let dir = dirname48(fileURLToPath10(import.meta.url));
     for (let i2 = 0;i2 < 8; i2++) {
-      const candidate = join108(dir, "docs", "quickstart.md");
+      const candidate = join109(dir, "docs", "quickstart.md");
       if (existsSync36(candidate))
         return candidate;
-      const pkg = join108(dir, "package.json");
+      const pkg = join109(dir, "package.json");
       if (existsSync36(pkg))
         return candidate;
       const parent = dirname48(dir);
@@ -112609,7 +112691,7 @@ function readQuickstartPath() {
       dir = parent;
     }
   } catch {}
-  return join108(dirname48(fileURLToPath10(import.meta.url)), "docs", "quickstart.md");
+  return join109(dirname48(fileURLToPath10(import.meta.url)), "docs", "quickstart.md");
 }
 var GREEN = "\x1B[32m";
 var RESET = "\x1B[0m";