@c4a/context-cli 0.6.5 → 0.6.7

package/cli.js

@@ -17720,17 +17720,17 @@ var init_writeLock = __esm(() => {
 
 // src/project/packageTemplateReview.ts
 import { createHash as createHash12 } from "node:crypto";
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import { mkdir as mkdir13, readFile as readFile20, readdir as readdir8, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname17, join as join24, relative as relative10, resolve as resolve14 } from "node:path";
+import { dirname as dirname18, join as join25, relative as relative10, resolve as resolve14 } from "node:path";
 async function templateFiles(root) {
-  if (!existsSync14(root))
+  if (!existsSync15(root))
     return [];
   const files = [];
   const visit2 = async (dir) => {
     const entries = await readdir8(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = join24(dir, entry.name);
+      const absolutePath = join25(dir, entry.name);
       if (entry.isDirectory()) {
         await visit2(absolutePath);
         continue;
@@ -17757,8 +17757,8 @@ function isMarker(value) {
   return marker.schema === PACKAGE_TEMPLATE_REVIEW_SCHEMA && /^sha256:[a-f0-9]{64}$/u.test(marker.starter_digest ?? "") && (marker.disposition === "review-required" || marker.disposition === "starter-accepted");
 }
 async function readMarker(templateRoot) {
-  const markerPath = join24(templateRoot, PACKAGE_TEMPLATE_REVIEW_FILE);
-  if (!existsSync14(markerPath))
+  const markerPath = join25(templateRoot, PACKAGE_TEMPLATE_REVIEW_FILE);
+  if (!existsSync15(markerPath))
     return null;
   try {
     const parsed = JSON.parse(await readFile20(markerPath, "utf8"));
@@ -17768,15 +17768,15 @@ async function readMarker(templateRoot) {
   }
 }
 async function writeStarterTemplateReviewMarker(templateRoot) {
-  const markerPath = join24(templateRoot, PACKAGE_TEMPLATE_REVIEW_FILE);
-  if (existsSync14(markerPath))
+  const markerPath = join25(templateRoot, PACKAGE_TEMPLATE_REVIEW_FILE);
+  if (existsSync15(markerPath))
     return false;
   const marker = {
     schema: PACKAGE_TEMPLATE_REVIEW_SCHEMA,
     starter_digest: await templateDigest(templateRoot),
     disposition: "review-required"
   };
-  await mkdir13(dirname17(markerPath), { recursive: true });
+  await mkdir13(dirname18(markerPath), { recursive: true });
   await writeFile9(markerPath, `${JSON.stringify(marker, null, 2)}
 `, "utf8");
   return true;
@@ -17796,7 +17796,7 @@ async function inspectPackageTemplateReview(projectRoot, pkg) {
       packageName: pkg.name,
       templatePath: pkg.template.path,
       state: "invalid",
-      diagnostic: `${join24(pkg.template.path, PACKAGE_TEMPLATE_REVIEW_FILE)} is invalid`
+      diagnostic: `${join25(pkg.template.path, PACKAGE_TEMPLATE_REVIEW_FILE)} is invalid`
     };
   }
   const currentDigest = await templateDigest(templateRoot);
@@ -17837,8 +17837,8 @@ async function acceptStarterPackageTemplates(input) {
         alreadyResolved.push(pkg.name);
         continue;
       }
-      const markerPath = join24(input.projectRoot, pkg.template.path, PACKAGE_TEMPLATE_REVIEW_FILE);
-      const marker = await readMarker(join24(input.projectRoot, pkg.template.path));
+      const markerPath = join25(input.projectRoot, pkg.template.path, PACKAGE_TEMPLATE_REVIEW_FILE);
+      const marker = await readMarker(join25(input.projectRoot, pkg.template.path));
       if (marker === null || marker === "invalid") {
         throw new ContextError(ExitCode.WorkspaceStateError, "package template review marker changed before acceptance", {
           category: ErrorCategory.WorkspaceStateInvalid,
@@ -17866,6 +17866,7 @@ var init_packageTemplateReview = __esm(() => {
 // src/project/workspace.ts
 var exports_workspace = {};
 __export(exports_workspace, {
+  resolveContextProjectInitTarget: () => resolveContextProjectInitTarget,
   projectLanguage: () => projectLanguage,
   loadContextProjectModule: () => loadContextProjectModule,
   isContextProjectRoot: () => isContextProjectRoot,
@@ -17876,30 +17877,30 @@ __export(exports_workspace, {
   assertContextStatusWorkspaceAllowed: () => assertContextStatusWorkspaceAllowed,
   PROJECT_LANGUAGES: () => PROJECT_LANGUAGES
 });
-import { existsSync as existsSync15, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync6 } from "node:fs";
 import { mkdir as mkdir14, readFile as readFile21, readdir as readdir9, writeFile as writeFile10 } from "node:fs/promises";
 import { createRequire as createRequire3 } from "node:module";
-import { basename as basename5, dirname as dirname18, isAbsolute as isAbsolute6, join as join25, parse as parse6, relative as relative11, resolve as resolve15 } from "node:path";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { basename as basename5, dirname as dirname19, isAbsolute as isAbsolute6, join as join26, parse as parse6, relative as relative11, resolve as resolve15 } from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { createJiti } from "jiti";
-function isRecord12(value) {
+function isRecord13(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function readPackageJson(root) {
-  const packagePath = join25(root, "package.json");
-  if (!existsSync15(packagePath))
+  const packagePath = join26(root, "package.json");
+  if (!existsSync16(packagePath))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync5(packagePath, "utf8"));
-    return isRecord12(parsed) ? parsed : null;
+    const parsed = JSON.parse(readFileSync6(packagePath, "utf8"));
+    return isRecord13(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
 function readPackageJsonFile(packageJsonPath) {
   try {
-    const parsed = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
-    return isRecord12(parsed) ? parsed : null;
+    const parsed = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
+    return isRecord13(parsed) ? parsed : null;
   } catch {
     return null;
   }
@@ -17910,22 +17911,22 @@ function resolveExportImportTarget(packageJsonPath) {
     return null;
   const exportsField = parsed.exports;
   if (typeof exportsField === "string") {
-    return join25(dirname18(packageJsonPath), exportsField);
+    return join26(dirname19(packageJsonPath), exportsField);
   }
-  if (isRecord12(exportsField)) {
+  if (isRecord13(exportsField)) {
     const rootExport = exportsField["."];
     if (typeof rootExport === "string") {
-      return join25(dirname18(packageJsonPath), rootExport);
+      return join26(dirname19(packageJsonPath), rootExport);
     }
-    if (isRecord12(rootExport) && typeof rootExport.import === "string") {
-      return join25(dirname18(packageJsonPath), rootExport.import);
+    if (isRecord13(rootExport) && typeof rootExport.import === "string") {
+      return join26(dirname19(packageJsonPath), rootExport.import);
     }
   }
   if (typeof parsed.module === "string") {
-    return join25(dirname18(packageJsonPath), parsed.module);
+    return join26(dirname19(packageJsonPath), parsed.module);
   }
   if (typeof parsed.main === "string") {
-    return join25(dirname18(packageJsonPath), parsed.main);
+    return join26(dirname19(packageJsonPath), parsed.main);
   }
   return null;
 }
@@ -17941,16 +17942,16 @@ function resolveContextSdkImportAlias(entryPath) {
   return "@c4a/context";
 }
 function readCurrentPackageVersion() {
-  let dir = dirname18(fileURLToPath5(import.meta.url));
+  let dir = dirname19(fileURLToPath6(import.meta.url));
   for (let index2 = 0;index2 < 8; index2++) {
-    const packagePath = join25(dir, "package.json");
-    if (existsSync15(packagePath)) {
+    const packagePath = join26(dir, "package.json");
+    if (existsSync16(packagePath)) {
       const parsed = readPackageJson(dir);
       if (typeof parsed?.version === "string" && parsed.version.trim().length > 0) {
         return parsed.version;
       }
     }
-    const parent = dirname18(dir);
+    const parent = dirname19(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -17959,7 +17960,7 @@ function readCurrentPackageVersion() {
 }
 function readContextProjectPackage(root) {
   const parsed = readPackageJson(root);
-  const context = isRecord12(parsed?.context) ? parsed.context : null;
+  const context = isRecord13(parsed?.context) ? parsed.context : null;
   if (context?.project !== true || typeof context.entry !== "string" || context.entry.trim().length === 0) {
     return null;
   }
@@ -17970,7 +17971,7 @@ function readContextProjectPackage(root) {
 }
 function readContextWorkspaceDir(root) {
   const parsed = readPackageJson(root);
-  const context = isRecord12(parsed?.context) ? parsed.context : null;
+  const context = isRecord13(parsed?.context) ? parsed.context : null;
   const workspaceDir = context?.workspaceDir;
   if (typeof workspaceDir !== "string" || workspaceDir.trim().length === 0)
     return null;
@@ -17978,7 +17979,7 @@ function readContextWorkspaceDir(root) {
 }
 function readContextProjectLanguage(root) {
   const parsed = readPackageJson(root);
-  const context = isRecord12(parsed?.context) ? parsed.context : null;
+  const context = isRecord13(parsed?.context) ? parsed.context : null;
   return context?.language === "en" || context?.language === "zh-CN" ? context.language : undefined;
 }
 function isSameOrChildPath(path3, parent) {
@@ -17999,13 +18000,13 @@ function findContextWorkspaceExpectation(startDir = process.cwd()) {
           workspaceDir,
           workspaceRoot,
           cwd,
-          exists: existsSync15(workspaceRoot)
+          exists: existsSync16(workspaceRoot)
         };
       }
     }
     if (dir === root)
       return null;
-    const parent = dirname18(dir);
+    const parent = dirname19(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -18039,7 +18040,7 @@ function findContextProjectRoot(startDir = process.cwd()) {
       return { projectRoot: dir };
     if (dir === root)
       return null;
-    const parent = dirname18(dir);
+    const parent = dirname19(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -18049,6 +18050,9 @@ function normalizeProjectDir(cwd, projectDir) {
   const raw = projectDir?.trim() || DEFAULT_PROJECT_DIR;
   return raw === "." ? resolve15(cwd) : resolve15(cwd, raw);
 }
+function resolveContextProjectInitTarget(cwd, projectDir) {
+  return normalizeProjectDir(cwd, projectDir);
+}
 function slugifyName(value) {
   const slug = value.trim().toLowerCase().replace(/[^a-z0-9._-]+/gu, "-").replace(/^-+|-+$/gu, "");
   return slug.length > 0 ? slug : "context";
@@ -18078,7 +18082,7 @@ function initCommand(input, allowNonempty) {
   return args.map(shellQuote3).join(" ");
 }
 async function assertInitTargetAllowed(input, projectRoot) {
-  if (!existsSync15(projectRoot) || isContextProjectRoot(projectRoot) || input.allowNonempty === true)
+  if (!existsSync16(projectRoot) || isContextProjectRoot(projectRoot) || input.allowNonempty === true)
     return;
   const entries = (await readdir9(projectRoot)).sort();
   if (entries.length === 0)
@@ -18102,11 +18106,11 @@ async function assertInitTargetAllowed(input, projectRoot) {
   });
 }
 async function writeIfMissing(path3, content3, result) {
-  if (existsSync15(path3)) {
+  if (existsSync16(path3)) {
     result.kept.push(path3);
     return;
   }
-  await mkdir14(dirname18(path3), { recursive: true });
+  await mkdir14(dirname19(path3), { recursive: true });
   await writeFile10(path3, content3, "utf8");
   result.created.push(path3);
 }
@@ -18114,7 +18118,7 @@ async function listStaticTemplateFiles(root, dir = root) {
   const entries = await readdir9(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const absolutePath = join25(dir, entry.name);
+    const absolutePath = join26(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listStaticTemplateFiles(root, absolutePath));
       continue;
@@ -18131,8 +18135,8 @@ async function listStaticTemplateFiles(root, dir = root) {
 function resolveContextPackageTemplatesRoot() {
   try {
     const packageJsonPath = createRequire3(import.meta.url).resolve("@c4a/context/package.json");
-    const templateRoot = join25(dirname18(packageJsonPath), "templates", "package-templates");
-    if (existsSync15(templateRoot))
+    const templateRoot = join26(dirname19(packageJsonPath), "templates", "package-templates");
+    if (existsSync16(templateRoot))
       return templateRoot;
   } catch {}
   throw new ContextError(ExitCode.WorkspaceStateError, "missing @c4a/context package templates", {
@@ -18143,8 +18147,8 @@ function resolveContextPackageTemplatesRoot() {
 }
 async function writeDefaultPackageTemplates(projectRoot, result, language) {
   const defaultRoot = resolveContextPackageTemplatesRoot();
-  const templateRoot = language === "zh-CN" ? join25(dirname18(defaultRoot), "package-templates.zh-CN") : defaultRoot;
-  if (!existsSync15(templateRoot)) {
+  const templateRoot = language === "zh-CN" ? join26(dirname19(defaultRoot), "package-templates.zh-CN") : defaultRoot;
+  if (!existsSync16(templateRoot)) {
     throw new ContextError(ExitCode.WorkspaceStateError, `missing ${language} @c4a/context package templates`, {
       category: ErrorCategory.WorkspaceStateInvalid,
       path: templateRoot,
@@ -18153,21 +18157,21 @@ async function writeDefaultPackageTemplates(projectRoot, result, language) {
   }
   const files = await listStaticTemplateFiles(templateRoot);
   for (const file of files) {
-    await writeIfMissing(join25(projectRoot, "src", "package-templates", ...file.relativePath.split("/")), await readFile21(file.absolutePath, "utf8"), result);
+    await writeIfMissing(join26(projectRoot, "src", "package-templates", ...file.relativePath.split("/")), await readFile21(file.absolutePath, "utf8"), result);
   }
   const templateKinds = [...new Set(files.map((file) => file.relativePath.split("/")[0]).filter((value) => value !== undefined && value.length > 0))];
   for (const templateKind of templateKinds) {
-    const root = join25(projectRoot, "src", "package-templates", templateKind);
+    const root = join26(projectRoot, "src", "package-templates", templateKind);
     if (await writeStarterTemplateReviewMarker(root)) {
-      result.created.push(join25(root, PACKAGE_TEMPLATE_REVIEW_FILE));
+      result.created.push(join26(root, PACKAGE_TEMPLATE_REVIEW_FILE));
     } else {
-      result.kept.push(join25(root, PACKAGE_TEMPLATE_REVIEW_FILE));
+      result.kept.push(join26(root, PACKAGE_TEMPLATE_REVIEW_FILE));
     }
   }
 }
 function resolveLocalSdkDependency() {
   const packageJsonPath = createRequire3(import.meta.url).resolve("@c4a/context/package.json");
-  return `file:${dirname18(packageJsonPath)}`;
+  return `file:${dirname19(packageJsonPath)}`;
 }
 function resolveSdkDependency(dev, version3) {
   return dev === true ? resolveLocalSdkDependency() : version3;
@@ -18465,20 +18469,20 @@ async function initContextProject(input) {
     kept: []
   };
   for (const dir of PROJECT_DIRS) {
-    await mkdir14(join25(projectRoot, dir), { recursive: true });
+    await mkdir14(join26(projectRoot, dir), { recursive: true });
   }
-  await mkdir14(join25(projectRoot, "sources", "repo"), { recursive: true });
-  await mkdir14(join25(projectRoot, "sources", "file"), { recursive: true });
-  await mkdir14(join25(projectRoot, "sources", "lark"), { recursive: true });
-  await writeIfMissing(join25(projectRoot, "package.json"), renderPackageJson(projectName, readCurrentPackageVersion(), input.dev, language, input.debug), result);
-  await writeIfMissing(join25(projectRoot, "src", "index.ts"), renderProjectEntry(language), result);
+  await mkdir14(join26(projectRoot, "sources", "repo"), { recursive: true });
+  await mkdir14(join26(projectRoot, "sources", "file"), { recursive: true });
+  await mkdir14(join26(projectRoot, "sources", "lark"), { recursive: true });
+  await writeIfMissing(join26(projectRoot, "package.json"), renderPackageJson(projectName, readCurrentPackageVersion(), input.dev, language, input.debug), result);
+  await writeIfMissing(join26(projectRoot, "src", "index.ts"), renderProjectEntry(language), result);
   await writeDefaultPackageTemplates(projectRoot, result, language);
-  await writeIfMissing(join25(projectRoot, "sources", "repo", "index.yaml"), renderRepoIndex(), result);
-  await writeIfMissing(join25(projectRoot, "sources", "file", "index.yaml"), renderFileIndex(), result);
-  await writeIfMissing(join25(projectRoot, "sources", "lark", "index.yaml"), renderLarkIndex(), result);
-  await writeIfMissing(join25(projectRoot, ".gitignore"), renderGitignore(), result);
-  await writeIfMissing(join25(projectRoot, "README.md"), renderReadme(projectName, language), result);
-  await writeIfMissing(join25(projectRoot, "AGENTS.md"), renderAgents(projectName, language), result);
+  await writeIfMissing(join26(projectRoot, "sources", "repo", "index.yaml"), renderRepoIndex(), result);
+  await writeIfMissing(join26(projectRoot, "sources", "file", "index.yaml"), renderFileIndex(), result);
+  await writeIfMissing(join26(projectRoot, "sources", "lark", "index.yaml"), renderLarkIndex(), result);
+  await writeIfMissing(join26(projectRoot, ".gitignore"), renderGitignore(), result);
+  await writeIfMissing(join26(projectRoot, "README.md"), renderReadme(projectName, language), result);
+  await writeIfMissing(join26(projectRoot, "AGENTS.md"), renderAgents(projectName, language), result);
   if (input.debug === true)
     await enableContextDebug(projectRoot, "init");
   return result;
@@ -18492,7 +18496,7 @@ async function loadContextProjectModule(root) {
       next: "Ensure package.json declares context.project=true and context.entry points to src/index.ts, then rerun the command."
     });
   }
-  const entryPath = join25(root, projectConfig.entry);
+  const entryPath = join26(root, projectConfig.entry);
   const jiti = createJiti(entryPath, {
     alias: {
       "@c4a/context": resolveContextSdkImportAlias(entryPath)
@@ -18502,7 +18506,7 @@ async function loadContextProjectModule(root) {
     moduleCache: false
   });
   const loadedProject = await jiti.import(entryPath, { default: true });
-  if (!isRecord12(loadedProject) || loadedProject.kind !== "context.project") {
+  if (!isRecord13(loadedProject) || loadedProject.kind !== "context.project") {
     throw new ContextError(ExitCode.WorkspaceStateError, "src/index.ts default export must be a @c4a/context project module", {
       category: ErrorCategory.SchemaInvalid,
       path: projectConfig.entry,
@@ -21518,7 +21522,7 @@ var require_util2 = __commonJS((exports) => {
     return path4;
   }
   exports.normalize = normalize;
-  function join46(aRoot, aPath) {
+  function join47(aRoot, aPath) {
     if (aRoot === "") {
       aRoot = ".";
     }
@@ -21550,7 +21554,7 @@ var require_util2 = __commonJS((exports) => {
     }
     return joined;
   }
-  exports.join = join46;
+  exports.join = join47;
   exports.isAbsolute = function(aPath) {
     return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
   };
@@ -21723,7 +21727,7 @@ var require_util2 = __commonJS((exports) => {
           parsed.path = parsed.path.substring(0, index2 + 1);
         }
       }
-      sourceURL = join46(urlGenerate(parsed), sourceURL);
+      sourceURL = join47(urlGenerate(parsed), sourceURL);
     }
     return normalize(sourceURL);
   }
@@ -24123,9 +24127,9 @@ var require_lib = __commonJS((exports, module) => {
 });
 
 // src/cli.ts
-import { existsSync as existsSync46, readFileSync as readFileSync9, realpathSync } from "node:fs";
-import { dirname as dirname42, join as join73 } from "node:path";
-import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL4 } from "node:url";
+import { existsSync as existsSync47, readFileSync as readFileSync10, realpathSync } from "node:fs";
+import { dirname as dirname43, join as join74 } from "node:path";
+import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL4 } from "node:url";
 
 // ../../node_modules/.bun/commander@11.1.0/node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -24189,7 +24193,7 @@ function mergedWorkflowAuthorities(...values) {
 }
 
 // src/project/workflow/workflowResource.ts
-import { join as join55 } from "node:path";
+import { join as join56 } from "node:path";
 
 // ../../node_modules/.bun/@c4a+agent-graph@0.2.5/node_modules/@c4a/agent-graph/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
@@ -40402,7 +40406,7 @@ init_errors();
 init_exitCode();
 
 // src/project/status.ts
-import { join as join54 } from "node:path";
+import { join as join55 } from "node:path";
 
 // ../context/src/contracts.ts
 var DEFAULT_PACKAGE_NAVIGATION = {
@@ -45289,9 +45293,9 @@ function resolveStructureCompileRoute(input) {
 // src/project/statusReaders.ts
 init_errors();
 var import_yaml29 = __toESM(require_dist3(), 1);
-import { existsSync as existsSync35, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync36, readFileSync as readFileSync8 } from "node:fs";
 import { readdir as readdir16 } from "node:fs/promises";
-import { join as join52 } from "node:path";
+import { join as join53 } from "node:path";
 
 // src/project/documentCapture.ts
 import { createHash as createHash4 } from "node:crypto";
@@ -68944,20 +68948,235 @@ async function readApprovedCodegraphPages(input) {
 // src/project/close.ts
 init_cliFeedback();
 init_errors();
-init_exitCode();
 var import_yaml14 = __toESM(require_dist3(), 1);
-import { existsSync as existsSync21 } from "node:fs";
+import { existsSync as existsSync22 } from "node:fs";
 import { mkdir as mkdir17, readdir as readdir11, readFile as readFile27, writeFile as writeFile13 } from "node:fs/promises";
-import { dirname as dirname21, join as join32, relative as relative13 } from "node:path";
+import { dirname as dirname22, join as join33, relative as relative13 } from "node:path";
+
+// src/runtimeEvents.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  existsSync as existsSync8,
+  mkdirSync,
+  readFileSync as readFileSync4,
+  renameSync,
+  writeFileSync
+} from "node:fs";
+import { spawn as spawn2 } from "node:child_process";
+import { dirname as dirname15, join as join17 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+var CONTEXT_RUNTIME_EVENT_BATCH_SCHEMA = "context.runtime-event-batch.v1";
+var CONTEXT_RUNTIME_EVENT_SINK_SCHEMA = "context.runtime-event-sink.v1";
+var CONTEXT_RUNTIME_EVENT_DELIVERY_TIMEOUT_MS = 3000;
+var CONTEXT_WORKSPACE_ACTIVE_THROTTLE_MS = 60 * 60 * 1000;
+var RUNTIME_EVENT_STATE_SCHEMA = "context.runtime-event-state.v1";
+var RUNTIME_EVENT_STATE_FILE = "runtime-event-state.json";
+var activeScope;
+function isRecord8(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseContextRuntimeEventSink(value) {
+  if (!isRecord8(value))
+    return null;
+  if (value.schema !== CONTEXT_RUNTIME_EVENT_SINK_SCHEMA || value.transport !== "command")
+    return null;
+  if (typeof value.command !== "string" || value.command.trim().length === 0)
+    return null;
+  if (!Array.isArray(value.args) || !value.args.every((arg) => typeof arg === "string"))
+    return null;
+  return {
+    schema: CONTEXT_RUNTIME_EVENT_SINK_SCHEMA,
+    transport: "command",
+    command: value.command,
+    args: [...value.args]
+  };
+}
+function readRuntimePackageMetadata() {
+  try {
+    let dir = dirname15(fileURLToPath4(import.meta.url));
+    for (let index2 = 0;index2 < 8; index2++) {
+      const packagePath = join17(dir, "package.json");
+      if (existsSync8(packagePath)) {
+        const parsed = JSON.parse(readFileSync4(packagePath, "utf8"));
+        if (isRecord8(parsed)) {
+          return {
+            contextVersion: typeof parsed.version === "string" ? parsed.version : "unknown",
+            sink: parseContextRuntimeEventSink(parsed.contextRuntimeEventSink)
+          };
+        }
+      }
+      const parent = dirname15(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {}
+  return { contextVersion: "unknown", sink: null };
+}
+function dispatchCommand(sink, batch, cwd) {
+  return new Promise((resolve8) => {
+    let settled = false;
+    let timer;
+    const finish = (delivered) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      resolve8(delivered);
+    };
+    try {
+      const child = spawn2(sink.command, sink.args, {
+        cwd,
+        env: process.env,
+        shell: false,
+        stdio: ["pipe", "ignore", "ignore"]
+      });
+      child.once("error", () => finish(false));
+      child.once("exit", (code) => finish(code === 0));
+      child.stdin.once("error", () => {
+        child.kill();
+        finish(false);
+      });
+      child.stdin.end(JSON.stringify(batch));
+      timer = setTimeout(() => {
+        child.kill();
+        finish(false);
+      }, CONTEXT_RUNTIME_EVENT_DELIVERY_TIMEOUT_MS);
+    } catch {
+      finish(false);
+    }
+  });
+}
+function runtimeEventStatePath(cwd) {
+  return join17(cwd, ".tmp", "context-runtime", RUNTIME_EVENT_STATE_FILE);
+}
+function readRuntimeEventState(cwd) {
+  try {
+    const parsed = JSON.parse(readFileSync4(runtimeEventStatePath(cwd), "utf8"));
+    if (!isRecord8(parsed) || parsed.schema !== RUNTIME_EVENT_STATE_SCHEMA)
+      return null;
+    const active = parsed.workspace_active;
+    if (active === undefined)
+      return { schema: RUNTIME_EVENT_STATE_SCHEMA };
+    if (!isRecord8(active) || typeof active.workflow_status !== "string" || typeof active.delivered_at !== "number" || !Number.isFinite(active.delivered_at)) {
+      return null;
+    }
+    return {
+      schema: RUNTIME_EVENT_STATE_SCHEMA,
+      workspace_active: {
+        workflow_status: active.workflow_status,
+        delivered_at: active.delivered_at
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function shouldDeliverWorkspaceActive(event, state) {
+  const workflowStatus = event.properties.workflow_status;
+  if (typeof workflowStatus !== "string")
+    return true;
+  const previous2 = state?.workspace_active;
+  if (previous2 === undefined || previous2.workflow_status !== workflowStatus)
+    return true;
+  return event.event_time - previous2.delivered_at >= CONTEXT_WORKSPACE_ACTIVE_THROTTLE_MS;
+}
+function selectRuntimeEventsForDelivery(events, state) {
+  return events.filter((event) => event.kind !== "workspace.active" || shouldDeliverWorkspaceActive(event, state));
+}
+function persistDeliveredWorkspaceActive(cwd, events) {
+  const delivered = [...events].reverse().find((event) => event.kind === "workspace.active");
+  const workflowStatus = delivered?.properties.workflow_status;
+  if (delivered === undefined || typeof workflowStatus !== "string")
+    return;
+  try {
+    const statePath = runtimeEventStatePath(cwd);
+    const stateDir = dirname15(statePath);
+    const temporaryPath = `${statePath}.${process.pid}.tmp`;
+    mkdirSync(stateDir, { recursive: true });
+    writeFileSync(temporaryPath, `${JSON.stringify({
+      schema: RUNTIME_EVENT_STATE_SCHEMA,
+      workspace_active: {
+        workflow_status: workflowStatus,
+        delivered_at: delivered.event_time
+      }
+    })}
+`, "utf8");
+    renameSync(temporaryPath, statePath);
+  } catch {}
+}
+async function flushRuntimeEvents(scope) {
+  const grouped = new Map;
+  for (const queued of scope.events) {
+    const events = grouped.get(queued.cwd) ?? [];
+    events.push(queued.event);
+    grouped.set(queued.cwd, events);
+  }
+  await Promise.all([...grouped.entries()].map(async ([cwd, events]) => {
+    try {
+      const selectedEvents = selectRuntimeEventsForDelivery(events, readRuntimeEventState(cwd));
+      if (selectedEvents.length === 0)
+        return;
+      try {
+        await scope.dispatch(scope.sink, {
+          schema: CONTEXT_RUNTIME_EVENT_BATCH_SCHEMA,
+          context_version: scope.contextVersion,
+          events: selectedEvents
+        }, cwd);
+      } finally {
+        persistDeliveredWorkspaceActive(cwd, selectedEvents);
+      }
+    } catch {}
+  }));
+}
+function queueContextRuntimeEvent(input) {
+  if (activeScope === undefined)
+    return;
+  activeScope.events.push({
+    cwd: input.cwd,
+    event: {
+      event_id: randomUUID2(),
+      event_time: Date.now(),
+      kind: input.kind,
+      properties: input.properties ?? {}
+    }
+  });
+}
+async function withContextRuntimeEventDelivery(work, options = {}) {
+  if (activeScope !== undefined || process.env.CONTEXT_RUNTIME_EVENTS_DISABLED === "1" && options.forceDelivery !== true) {
+    return work();
+  }
+  const metadata = readRuntimePackageMetadata();
+  const sink = options.sink === undefined ? metadata.sink : options.sink;
+  if (sink === null)
+    return work();
+  const scope = {
+    contextVersion: options.contextVersion ?? metadata.contextVersion,
+    dispatch: options.dispatch ?? dispatchCommand,
+    events: [],
+    sink
+  };
+  activeScope = scope;
+  try {
+    return await work();
+  } finally {
+    activeScope = undefined;
+    await flushRuntimeEvents(scope);
+  }
+}
+
+// src/project/close.ts
+init_exitCode();
 
 // src/project/approvedStructureEdges.ts
 init_cliFeedback();
 init_errors();
 init_exitCode();
 var import_yaml10 = __toESM(require_dist3(), 1);
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 import { readFile as readFile17 } from "node:fs/promises";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 
 // src/project/proseAlignTypes.ts
 import { createHash as createHash9 } from "node:crypto";
@@ -69014,21 +69233,21 @@ function slugify2(input, maxLen = 60) {
 // src/project/semanticRules.ts
 var import_yaml8 = __toESM(require_dist3(), 1);
 import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync4, readdirSync } from "node:fs";
-import { basename as basename4, dirname as dirname15, join as join17 } from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { existsSync as existsSync9, readFileSync as readFileSync5, readdirSync } from "node:fs";
+import { basename as basename4, dirname as dirname16, join as join18 } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 function sha256(value) {
   return `sha256:${createHash8("sha256").update(value).digest("hex")}`;
 }
 function workflowRootCandidates() {
-  const runtimeDir = dirname15(fileURLToPath4(import.meta.url));
+  const runtimeDir = dirname16(fileURLToPath5(import.meta.url));
   return [
-    join17(runtimeDir, "providers", "context"),
-    join17(runtimeDir, "..", "..", "context-workflow")
+    join18(runtimeDir, "providers", "context"),
+    join18(runtimeDir, "..", "..", "context-workflow")
   ];
 }
 function semanticRuleMetadata(scope, filePath) {
-  const content3 = readFileSync4(filePath, "utf8").replaceAll(`\r
+  const content3 = readFileSync5(filePath, "utf8").replaceAll(`\r
 `, `
 `);
   const end = content3.indexOf(`
@@ -69059,19 +69278,19 @@ function semanticRuleMetadata(scope, filePath) {
 }
 function semanticRuleDescriptors(scope) {
   for (const root of workflowRootCandidates()) {
-    const directory = join17(root, "resources", "semantic", scope);
-    if (!existsSync8(directory))
+    const directory = join18(root, "resources", "semantic", scope);
+    if (!existsSync9(directory))
       continue;
-    return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name)).map((entry) => semanticRuleMetadata(scope, join17(directory, entry.name)));
+    return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name)).map((entry) => semanticRuleMetadata(scope, join18(directory, entry.name)));
   }
   throw new Error(`Context ${scope} semantic workflow resources are missing. Rebuild or reinstall @c4a/context-cli.`);
 }
 function ruleContent(rulePath) {
   for (const root of workflowRootCandidates()) {
-    const absolute = join17(root, rulePath);
-    if (existsSync8(absolute)) {
+    const absolute = join18(root, rulePath);
+    if (existsSync9(absolute)) {
       return {
-        content: readFileSync4(absolute, "utf8"),
+        content: readFileSync5(absolute, "utf8"),
         available: true,
         filePath: absolute
       };
@@ -69484,15 +69703,15 @@ init_cliFeedback();
 init_errors();
 init_exitCode();
 var import_yaml9 = __toESM(require_dist3(), 1);
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import { mkdir as mkdir12, readFile as readFile16, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname16, join as join18 } from "node:path";
+import { dirname as dirname17, join as join19 } from "node:path";
 
 // src/project/proseAlignPayloadParse.ts
 import { createHash as createHash10 } from "node:crypto";
 
 // src/project/proseAlignSchemaUtils.ts
-function isRecord8(value) {
+function isRecord9(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function stringValue2(record, field) {
@@ -69559,7 +69778,7 @@ function parsePreferredNodes(value, diagnostics) {
   }
   const nodes = [];
   for (const [index2, rawNode] of value.entries()) {
-    if (!isRecord8(rawNode)) {
+    if (!isRecord9(rawNode)) {
       diagnostics.push(diagnostic("error", "schema.preferred_node_object", "schema", "preferred_nodes item must be an object.", `user_or_agent_hints.preferred_nodes[${index2}]`));
       continue;
     }
@@ -69584,7 +69803,7 @@ function parsePreferredNodes(value, diagnostics) {
 function parseUserOrAgentHints(value, diagnostics) {
   if (value === undefined)
     return;
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     diagnostics.push(diagnostic("error", "schema.user_or_agent_hints_object", "schema", "user_or_agent_hints must be an object.", "user_or_agent_hints"));
     return;
   }
@@ -69787,7 +70006,7 @@ function parseNodes(value, diagnostics) {
     diagnostics.push(diagnostic("error", "schema.nodes_missing", "schema", "Payload must include at least one node.", "nodes"));
   const nodes = [];
   for (const [index2, rawNode] of value.entries()) {
-    if (!isRecord8(rawNode)) {
+    if (!isRecord9(rawNode)) {
       diagnostics.push(diagnostic("error", "schema.node_object", "schema", `Node ${index2 + 1} must be an object.`, `nodes[${index2}]`));
       continue;
     }
@@ -69824,7 +70043,7 @@ function parseSections(input) {
   const sectionIds = new Set;
   for (const [sectionIndex, rawSection] of input.value.entries()) {
     const field = `views[${input.viewIndex}].sections[${sectionIndex}]`;
-    if (!isRecord8(rawSection)) {
+    if (!isRecord9(rawSection)) {
       input.diagnostics.push(diagnostic("error", "schema.section_object", "schema", "Section must be an object.", field));
       continue;
     }
@@ -69926,7 +70145,7 @@ function parseViews(value, nodes, diagnostics) {
   const nodeByRef = new Map(nodes.map((node3) => [node3.node_ref, node3]));
   const views = [];
   for (const [index2, rawView] of value.entries()) {
-    if (!isRecord8(rawView)) {
+    if (!isRecord9(rawView)) {
       diagnostics.push(diagnostic("error", "schema.view_object", "schema", `View ${index2 + 1} must be an object.`, `views[${index2}]`));
       continue;
     }
@@ -69945,7 +70164,7 @@ function parseEdges(value, diagnostics) {
   }
   const edges = [];
   for (const [index2, rawEdge] of value.entries()) {
-    if (!isRecord8(rawEdge)) {
+    if (!isRecord9(rawEdge)) {
       diagnostics.push(diagnostic("error", "schema.edge_object", "schema", `Edge ${index2 + 1} must be an object.`, `edges[${index2}]`));
       continue;
     }
@@ -69992,7 +70211,7 @@ function parseUnresolved(value, diagnostics) {
   }
   const unresolved = [];
   for (const [index2, rawIssue] of value.entries()) {
-    if (!isRecord8(rawIssue)) {
+    if (!isRecord9(rawIssue)) {
       diagnostics.push(diagnostic("error", "schema.unresolved_object", "schema", `Unresolved issue ${index2 + 1} must be an object.`, `unresolved[${index2}]`));
       continue;
     }
@@ -70015,7 +70234,7 @@ function parseUnresolved(value, diagnostics) {
 function parseLifecycle(value, diagnostics) {
   if (value === undefined)
     return { state: "draft" };
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     diagnostics.push(diagnostic("error", "schema.lifecycle_object", "schema", "Payload lifecycle must be an object.", "lifecycle"));
     return { state: "draft" };
   }
@@ -70073,7 +70292,7 @@ function structureBody(input) {
 }
 function parseAlignPayload(value) {
   const diagnostics = [];
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     return {
       diagnostics: [diagnostic("error", "schema.payload_object", "schema", "Payload must be a YAML/JSON object.", "schema")]
     };
@@ -70158,7 +70377,7 @@ function snapshotPath(projectRoot, structureDigest) {
       structure_digest: structureDigest
     });
   }
-  return join18(projectRoot, STRUCTURE_SNAPSHOT_ROOT, `${match[1]}.yaml`);
+  return join19(projectRoot, STRUCTURE_SNAPSHOT_ROOT, `${match[1]}.yaml`);
 }
 function normalizedSnapshot(payload) {
   const { user_or_agent_hints: _hints, ...body } = payload;
@@ -70174,8 +70393,8 @@ function normalizedSnapshot(payload) {
   });
 }
 async function readSlots(projectRoot) {
-  const path3 = join18(projectRoot, STRUCTURE_SLOT_FILE);
-  if (!existsSync9(path3))
+  const path3 = join19(projectRoot, STRUCTURE_SLOT_FILE);
+  if (!existsSync10(path3))
     return [];
   const parsed = import_yaml9.default.parse(await readFile16(path3, "utf8"));
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -70223,8 +70442,8 @@ async function updateSlots(projectRoot, payload) {
     ...current2.filter((slot) => !replacements.has(`${slot.source}\x00${slot.collection}`)),
     ...replacements.values()
   ].sort((left, right) => left.source.localeCompare(right.source) || left.collection.localeCompare(right.collection));
-  const path3 = join18(projectRoot, STRUCTURE_SLOT_FILE);
-  await mkdir12(dirname16(path3), { recursive: true });
+  const path3 = join19(projectRoot, STRUCTURE_SLOT_FILE);
+  await mkdir12(dirname17(path3), { recursive: true });
   await writeFile8(path3, import_yaml9.default.stringify({ schema_version: STRUCTURE_SLOT_SCHEMA_VERSION, slots }), "utf8");
 }
 async function writeStructureSnapshot(projectRoot, payload) {
@@ -70239,7 +70458,7 @@ async function writeStructureSnapshot(projectRoot, payload) {
     });
   }
   const content3 = import_yaml9.default.stringify(normalized);
-  if (existsSync9(path3)) {
+  if (existsSync10(path3)) {
     const current2 = await readFile16(path3, "utf8");
     const existing = parseAlignPayload(import_yaml9.default.parse(current2)).payload;
     if (existing?.structure_digest !== payload.structure_digest) {
@@ -70255,14 +70474,14 @@ async function writeStructureSnapshot(projectRoot, payload) {
     await updateSlots(projectRoot, payload);
     return path3;
   }
-  await mkdir12(dirname16(path3), { recursive: true });
+  await mkdir12(dirname17(path3), { recursive: true });
   await writeFile8(path3, content3, "utf8");
   await updateSlots(projectRoot, payload);
   return path3;
 }
 async function readStructureSnapshot(projectRoot, structureDigest) {
   const path3 = snapshotPath(projectRoot, structureDigest);
-  if (!existsSync9(path3))
+  if (!existsSync10(path3))
     return null;
   try {
     return import_yaml9.default.parse(await readFile16(path3, "utf8"));
@@ -70290,8 +70509,8 @@ async function readStructureSnapshotPayload(projectRoot, structureDigest) {
   return { ...record, structure_digest: structureDigest };
 }
 async function archiveActiveStructure(projectRoot) {
-  const path3 = join18(projectRoot, LIFECYCLE_STRUCTURE_FILE);
-  if (!existsSync9(path3))
+  const path3 = join19(projectRoot, LIFECYCLE_STRUCTURE_FILE);
+  if (!existsSync10(path3))
     return null;
   let parsed;
   try {
@@ -70319,7 +70538,7 @@ function structureSnapshotRelativePath(structureDigest) {
   const match = STRUCTURE_DIGEST_PATTERN.exec(structureDigest);
   if (match?.[1] === undefined)
     return STRUCTURE_SNAPSHOT_ROOT;
-  return join18(STRUCTURE_SNAPSHOT_ROOT, `${match[1]}.yaml`);
+  return join19(STRUCTURE_SNAPSHOT_ROOT, `${match[1]}.yaml`);
 }
 async function currentStructureSlotDigest(projectRoot, source2, collection) {
   return (await readSlots(projectRoot)).find((slot) => slot.source === source2 && slot.collection === collection)?.structure_digest;
@@ -70334,9 +70553,9 @@ async function activeStructureSlots(projectRoot, collection) {
 
 // src/project/approvedStructureEdges.ts
 var KNOWLEDGE_ROOT = "knowledge";
-var APPROVED_STRUCTURE_PATH = join19(KNOWLEDGE_ROOT, "structure.yaml");
+var APPROVED_STRUCTURE_PATH = join20(KNOWLEDGE_ROOT, "structure.yaml");
 var STRUCTURE_EDGE_CONFIDENCE_SET = new Set(STRUCTURE_EDGE_CONFIDENCES);
-function isRecord9(value) {
+function isRecord10(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function readEdgeArray(structure) {
@@ -70346,7 +70565,7 @@ function normalizeApprovedEdges(input) {
   const allowed = new Set(STRUCTURE_EDGE_TYPES);
   const edges = [];
   for (const [index2, rawEdge] of input.rawEdges.entries()) {
-    if (!isRecord9(rawEdge)) {
+    if (!isRecord10(rawEdge)) {
       throw new ContextError(ExitCode.WorkspaceStateError, "structure edge must be an object", {
         category: ErrorCategory.WorkspaceStateInvalid,
         path: input.path,
@@ -70437,20 +70656,20 @@ function structureEndpointRefs(structure) {
   const refs = [];
   if (Array.isArray(structure.nodes)) {
     for (const node3 of structure.nodes) {
-      if (isRecord9(node3) && typeof node3.node_ref === "string")
+      if (isRecord10(node3) && typeof node3.node_ref === "string")
         refs.push(node3.node_ref);
     }
   }
   if (Array.isArray(structure.views)) {
     for (const view of structure.views) {
-      if (!isRecord9(view))
+      if (!isRecord10(view))
         continue;
       if (typeof view.view_ref === "string")
         refs.push(view.view_ref);
       if (!Array.isArray(view.sections))
         continue;
       for (const section of view.sections) {
-        if (isRecord9(section) && typeof section.section_ref === "string")
+        if (isRecord10(section) && typeof section.section_ref === "string")
           refs.push(section.section_ref);
       }
     }
@@ -70458,12 +70677,12 @@ function structureEndpointRefs(structure) {
   return refs;
 }
 async function readYamlRecord(projectRoot, relPath) {
-  const absPath = join19(projectRoot, relPath);
-  if (!existsSync10(absPath))
+  const absPath = join20(projectRoot, relPath);
+  if (!existsSync11(absPath))
     return null;
   try {
     const parsed = import_yaml10.default.parse(await readFile17(absPath, "utf8"));
-    return isRecord9(parsed) ? parsed : null;
+    return isRecord10(parsed) ? parsed : null;
   } catch (error) {
     throw new ContextError(ExitCode.WorkspaceStateError, `${relPath} is invalid YAML`, {
       category: ErrorCategory.WorkspaceStateInvalid,
@@ -70502,7 +70721,7 @@ async function readConfirmedStructureEdgeProjection(projectRoot, approvedEndpoin
     const snapshotEdges = [];
     for (const structureDigest of [...new Set(slots.map((slot) => slot.structureDigest))].sort()) {
       const structure2 = await readStructureSnapshot(projectRoot, structureDigest);
-      if (!isRecord9(structure2)) {
+      if (!isRecord10(structure2)) {
         throw new ContextError(ExitCode.WorkspaceStateError, "active structure snapshot is missing", {
           category: ErrorCategory.WorkspaceStateInvalid,
           structure_digest: structureDigest,
@@ -70543,7 +70762,7 @@ async function readConfirmedStructureEdgeProjection(projectRoot, approvedEndpoin
   }
   if (structure === null)
     return null;
-  const lifecycle = isRecord9(structure.lifecycle) ? structure.lifecycle : {};
+  const lifecycle = isRecord10(structure.lifecycle) ? structure.lifecycle : {};
   if (lifecycle.state !== "confirmed" && lifecycle.state !== "frozen")
     return null;
   return normalizeApprovedEdges({
@@ -70559,15 +70778,15 @@ async function readConfirmedStructureEdgeProjection(projectRoot, approvedEndpoin
 init_cliFeedback();
 init_errors();
 init_exitCode();
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 import { readFile as readFile23 } from "node:fs/promises";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 
 // src/project/verifyApprovedStructure.ts
 var import_yaml12 = __toESM(require_dist3(), 1);
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import { readFile as readFile19 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 
 // src/project/approvedStructureInputHash.ts
 import { createHash as createHash11 } from "node:crypto";
@@ -70608,11 +70827,11 @@ function approvedStructureInputHash(input) {
 }
 
 // src/project/verifyApprovedStructureEdges.ts
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 
 // src/project/verifyCanonicalSourceRefs.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync12 } from "node:fs";
+import { join as join21 } from "node:path";
 var CANONICAL_SOURCE_REF = /^repo:([^#]+)#symbol:(.+):([^:@]+):([^:@]+)@([a-f0-9]+)$/iu;
 function validateCanonicalSourceRef(input) {
   const path3 = input.path ?? ".tmp/context-runtime/lifecycle/candidates.jsonl";
@@ -70668,7 +70887,7 @@ async function validateCanonicalEvidenceSourceRef(input) {
   const registryEntry = input.sourceRegistry.loaded ? registeredDocumentSource(input.sourceRegistry, locator.sourceType, locator.sourceName) : undefined;
   const materializedAt = registryEntry?.materializedAt ?? defaultDocumentMaterializedAt(locator.sourceType, locator.sourceName);
   const manifestPath = registryEntry?.snapshot?.manifest ?? defaultDocumentManifest(materializedAt);
-  if (!existsSync11(join20(input.projectRoot, manifestPath)) && !snapshotRootExists(input.projectRoot, materializedAt)) {
+  if (!existsSync12(join21(input.projectRoot, manifestPath)) && !snapshotRootExists(input.projectRoot, materializedAt)) {
     input.issues.push({
       severity: unresolvedSeverity,
       code: "approved-evidence-unavailable",
@@ -70741,7 +70960,7 @@ async function validateCanonicalEvidenceSourceRef(input) {
 }
 
 // src/project/verifyApprovedStructureEdges.ts
-var APPROVED_STRUCTURE_PATH2 = join21("knowledge", "structure.yaml");
+var APPROVED_STRUCTURE_PATH2 = join22("knowledge", "structure.yaml");
 function approvedStructureEdgeRecords(parsed, issues) {
   if (parsed.edges === undefined)
     return [];
@@ -70874,7 +71093,7 @@ async function validateApprovedStructureEdgeRecords(input) {
 init_cliFeedback();
 init_errors();
 init_exitCode();
-function isRecord10(value) {
+function isRecord11(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function codegraphEdgesFromFrontmatter(frontmatter, path3) {
@@ -70887,7 +71106,7 @@ function codegraphEdgesFromFrontmatter(frontmatter, path3) {
     });
   }
   return frontmatter.code_edges.map((rawEdge, index2) => {
-    if (!isRecord10(rawEdge)) {
+    if (!isRecord11(rawEdge)) {
       throw new ContextError(ExitCode.WorkspaceStateError, "approved code edge must be an object", {
         category: ErrorCategory.WorkspaceStateInvalid,
         path: path3,
@@ -70947,17 +71166,17 @@ function codegraphRelationshipCoverage(input) {
 }
 
 // src/project/approvedStructureInputs.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import { readFile as readFile18 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 init_cliFeedback();
 init_errors();
 init_exitCode();
 var import_yaml11 = __toESM(require_dist3(), 1);
-var APPROVED_STRUCTURE_FILE = join22("knowledge", "structure.yaml");
+var APPROVED_STRUCTURE_FILE = join23("knowledge", "structure.yaml");
 var COLLECTIONS = new Set(KNOWLEDGE_COLLECTIONS);
 var SNAPSHOT_HASH_PATTERN = /^sha256:[a-f0-9]{64}$/u;
-function isRecord11(value) {
+function isRecord12(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function invalidSourceInputs(reason) {
@@ -70976,14 +71195,14 @@ function sortedSourceInputs(values2) {
 function parseApprovedStructureSourceInputs(structure) {
   if (structure.source_inputs === undefined)
     return [];
-  if (!isRecord11(structure.source_inputs)) {
+  if (!isRecord12(structure.source_inputs)) {
     throw invalidSourceInputs("source_inputs must be an object when present");
   }
   const inputs = new Map;
   for (const [source2, collections] of Object.entries(structure.source_inputs)) {
     if (source2.trim().length === 0)
       throw invalidSourceInputs("source_inputs source key must not be empty");
-    if (!isRecord11(collections)) {
+    if (!isRecord12(collections)) {
       throw invalidSourceInputs(`source_inputs.${source2} must be an object`);
     }
     for (const [collection, snapshotHash] of Object.entries(collections)) {
@@ -71008,8 +71227,8 @@ function approvedStructureSourceInputsRecord(inputs) {
   return result;
 }
 async function readApprovedStructureSourceInputs(projectRoot) {
-  const path3 = join22(projectRoot, APPROVED_STRUCTURE_FILE);
-  if (!existsSync12(path3))
+  const path3 = join23(projectRoot, APPROVED_STRUCTURE_FILE);
+  if (!existsSync13(path3))
     return [];
   let parsed;
   try {
@@ -71017,7 +71236,7 @@ async function readApprovedStructureSourceInputs(projectRoot) {
   } catch {
     return [];
   }
-  if (!isRecord11(parsed))
+  if (!isRecord12(parsed))
     return [];
   return parseApprovedStructureSourceInputs(parsed);
 }
@@ -71046,14 +71265,14 @@ function approvedStructureSourceInputKey(input) {
 }
 
 // src/project/verifyApprovedStructure.ts
-var APPROVED_STRUCTURE_PATH3 = join23("knowledge", "structure.yaml");
+var APPROVED_STRUCTURE_PATH3 = join24("knowledge", "structure.yaml");
 var APPROVED_STRUCTURE_SCHEMA_VERSION = "context.approved-structure.v1";
 var LOCAL_REF = /^src-(\d+)(#(?:span|symbol):.+)$/u;
 async function readApprovedStructureForVerify(input) {
   if (input.structureOverride !== undefined)
     return input.structureOverride;
-  const structurePath = join23(input.projectRoot, APPROVED_STRUCTURE_PATH3);
-  if (!existsSync13(structurePath))
+  const structurePath = join24(input.projectRoot, APPROVED_STRUCTURE_PATH3);
+  if (!existsSync14(structurePath))
     return;
   let rawParsed;
   try {
@@ -71278,7 +71497,7 @@ async function approvedStructureProjection(projectRoot) {
   const views = [];
   const parentIndexes = [];
   const codeEdges = [];
-  for (const file of await walkMarkdown(join23(projectRoot, "knowledge"))) {
+  for (const file of await walkMarkdown(join24(projectRoot, "knowledge"))) {
     if (isKnowledgeAssetPath(file.relPath))
       continue;
     const content3 = await readFile19(file.absPath, "utf8");
@@ -71692,13 +71911,13 @@ async function validateApprovedStructureEdges(input) {
 init_workspace();
 
 // src/project/reviewDecisions.ts
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 import { mkdir as mkdir15, readFile as readFile22, rename as rename3, rm as rm8, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname19, join as join26 } from "node:path";
+import { dirname as dirname20, join as join27 } from "node:path";
 init_cliFeedback();
 init_errors();
 init_exitCode();
-var REVIEW_DECISIONS_FILE = join26("knowledge", "decisions.json");
+var REVIEW_DECISIONS_FILE = join27("knowledge", "decisions.json");
 var FINGERPRINT_PATTERN = /^sha256:[a-f0-9]{64}$/u;
 var COLLECTIONS2 = new Set(KNOWLEDGE_COLLECTIONS);
 function isCandidateId(value) {
@@ -71713,8 +71932,8 @@ function invalidDecisions(reason) {
   });
 }
 async function readRejectedDecisions(projectRoot) {
-  const path3 = join26(projectRoot, REVIEW_DECISIONS_FILE);
-  if (!existsSync16(path3))
+  const path3 = join27(projectRoot, REVIEW_DECISIONS_FILE);
+  if (!existsSync17(path3))
     return new Map;
   let parsed;
   try {
@@ -71738,14 +71957,14 @@ async function readRejectedDecisions(projectRoot) {
   return decisions;
 }
 async function writeRejectedDecisions(projectRoot, decisions) {
-  const path3 = join26(projectRoot, REVIEW_DECISIONS_FILE);
+  const path3 = join27(projectRoot, REVIEW_DECISIONS_FILE);
   if (decisions.size === 0) {
     await rm8(path3, { force: true });
     return;
   }
   const rejected = Object.fromEntries([...decisions.entries()].sort(([left], [right]) => left.localeCompare(right)));
   const tempPath = `${path3}.${process.pid}.tmp`;
-  await mkdir15(dirname19(path3), { recursive: true });
+  await mkdir15(dirname20(path3), { recursive: true });
   await writeFile11(tempPath, `${JSON.stringify(rejected, null, 2)}
 `, "utf8");
   await rename3(tempPath, path3);
@@ -71922,7 +72141,7 @@ async function verifyProjectWorkspace(projectRoot, options = {}) {
     issues
   });
   const seenViewRefs = new Set;
-  for (const file of await walkMarkdown(join27(projectRoot, "knowledge"))) {
+  for (const file of await walkMarkdown(join28(projectRoot, "knowledge"))) {
     if (isKnowledgeAssetPath(file.relPath))
       continue;
     const content3 = await readFile23(file.absPath, "utf8");
@@ -71945,7 +72164,7 @@ async function verifyProjectWorkspace(projectRoot, options = {}) {
       pageRelPath: `knowledge/${file.relPath}`,
       content: content3
     })) {
-      if (!existsSync17(join27(projectRoot, assetPath))) {
+      if (!existsSync18(join28(projectRoot, assetPath))) {
         issues.push({
           severity: "error",
           code: "approved-resource-missing",
@@ -72131,9 +72350,9 @@ init_writeLock();
 
 // src/project/proseCompileBatch.ts
 var import_yaml13 = __toESM(require_dist3(), 1);
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 import { readFile as readFile25 } from "node:fs/promises";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 init_cliFeedback();
 init_errors();
 init_exitCode();
@@ -72142,9 +72361,9 @@ init_exitCode();
 init_cliFeedback();
 init_errors();
 init_exitCode();
-import { existsSync as existsSync18 } from "node:fs";
+import { existsSync as existsSync19 } from "node:fs";
 import { readFile as readFile24, readdir as readdir10 } from "node:fs/promises";
-import { basename as basename6, join as join28, relative as relative12 } from "node:path";
+import { basename as basename6, join as join29, relative as relative12 } from "node:path";
 init_writeLock();
 function candidateSourceKey(record) {
   return record.source === undefined ? undefined : `${record.source.type}:${record.source.name}`;
@@ -72156,11 +72375,11 @@ function toPosixPath8(value) {
   return value.split(/[\\/]+/u).join("/");
 }
 async function approvedPageIdentities(projectRoot) {
-  const root = join28(projectRoot, "knowledge");
+  const root = join29(projectRoot, "knowledge");
   const identities = [];
   const visit2 = async (directory) => {
     for (const entry of await readdir10(directory, { withFileTypes: true })) {
-      const absolutePath = join28(directory, entry.name);
+      const absolutePath = join29(directory, entry.name);
       if (entry.isDirectory()) {
         await visit2(absolutePath);
         continue;
@@ -72178,7 +72397,7 @@ async function approvedPageIdentities(projectRoot) {
       });
     }
   };
-  if (existsSync18(root))
+  if (existsSync19(root))
     await visit2(root);
   return {
     byPath: new Map(identities.map((identity) => [identity.path, identity])),
@@ -72407,7 +72626,7 @@ async function preserveApprovedPathIdentities(input) {
 }
 
 // src/project/proseCompileBatch.ts
-function isRecord13(value) {
+function isRecord14(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function stringField2(value, field) {
@@ -72415,11 +72634,11 @@ function stringField2(value, field) {
   return typeof candidate === "string" && candidate.trim().length > 0 ? candidate.trim() : undefined;
 }
 async function readConfirmedStructure(projectRoot) {
-  const path3 = join29(projectRoot, LIFECYCLE_STRUCTURE_FILE);
-  if (!existsSync19(path3))
+  const path3 = join30(projectRoot, LIFECYCLE_STRUCTURE_FILE);
+  if (!existsSync20(path3))
     return;
   const parsed = import_yaml13.default.parse(await readFile25(path3, "utf8"));
-  if (!isRecord13(parsed) || !isRecord13(parsed.lifecycle))
+  if (!isRecord14(parsed) || !isRecord14(parsed.lifecycle))
     return;
   if (parsed.lifecycle.state !== "confirmed" && parsed.lifecycle.state !== "frozen")
     return;
@@ -72434,7 +72653,7 @@ async function readCurrentSnapshotHashes(projectRoot) {
 }
 async function approvedViewRefs(projectRoot, planned) {
   const approved = [];
-  for (const file of await walkMarkdown(join29(projectRoot, "knowledge"))) {
+  for (const file of await walkMarkdown(join30(projectRoot, "knowledge"))) {
     if (isKnowledgeAssetPath(file.relPath))
       continue;
     const content3 = await readFile25(file.absPath, "utf8");
@@ -72702,7 +72921,7 @@ function proseCompileBatchNextAction(input) {
 
 // src/project/lifecycleCleanup.ts
 import { rm as rm9 } from "node:fs/promises";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 var COMPLETED_RUNTIME_PATHS = [
   LIFECYCLE_ROOT,
   REVIEW_RUNTIME_ROOT,
@@ -72711,13 +72930,13 @@ var COMPLETED_RUNTIME_PATHS = [
   CANDIDATE_SNAPSHOT_ROOT
 ];
 async function clearCompletedLifecycle(projectRoot) {
-  await Promise.all(COMPLETED_RUNTIME_PATHS.map((path3) => rm9(join30(projectRoot, path3), { recursive: true, force: true })));
+  await Promise.all(COMPLETED_RUNTIME_PATHS.map((path3) => rm9(join31(projectRoot, path3), { recursive: true, force: true })));
 }
 
 // src/project/knowledgeAssetRepair.ts
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 import { mkdir as mkdir16, readFile as readFile26, writeFile as writeFile12 } from "node:fs/promises";
-import { dirname as dirname20, join as join31 } from "node:path";
+import { dirname as dirname21, join as join32 } from "node:path";
 init_cliFeedback();
 init_errors();
 init_exitCode();
@@ -72728,14 +72947,14 @@ function sourceLocators(frontmatter) {
   ])];
 }
 async function bytesEqual(path3, expected) {
-  if (!existsSync20(path3))
+  if (!existsSync21(path3))
     return false;
   const actual = await readFile26(path3);
   return actual.length === expected.length && actual.equals(Buffer.from(expected));
 }
 async function repairApprovedKnowledgeAssetProjections(projectRoot) {
   const affected = [];
-  for (const file of await walkMarkdown(join31(projectRoot, "knowledge"))) {
+  for (const file of await walkMarkdown(join32(projectRoot, "knowledge"))) {
     if (isKnowledgeAssetPath(file.relPath))
       continue;
     const content3 = await readFile26(file.absPath, "utf8");
@@ -72809,7 +73028,7 @@ async function repairApprovedKnowledgeAssetProjections(projectRoot) {
   for (const asset of assets.values()) {
     if (await bytesEqual(asset.absPath, asset.bytes))
       continue;
-    await mkdir16(dirname20(asset.absPath), { recursive: true });
+    await mkdir16(dirname21(asset.absPath), { recursive: true });
     await writeFile12(asset.absPath, asset.bytes);
     writtenAssets.push(asset.relPath);
   }
@@ -72825,7 +73044,7 @@ async function repairApprovedKnowledgeAssetProjections(projectRoot) {
 
 // src/project/close.ts
 var KNOWLEDGE_ROOT2 = "knowledge";
-var STRUCTURE_PATH = join32(KNOWLEDGE_ROOT2, "structure.yaml");
+var STRUCTURE_PATH = join33(KNOWLEDGE_ROOT2, "structure.yaml");
 var STRUCTURE_SCHEMA_VERSION2 = "context.approved-structure.v1";
 var LOCAL_REF2 = /^src-(\d+)(#(?:span|symbol):.+)$/u;
 var APPROVED_NODE_TYPES2 = new Set(["entity", "domain", "action"]);
@@ -72855,13 +73074,13 @@ function requiredFrontmatterString(frontmatter, field, relPath) {
   });
 }
 async function walkFiles2(root) {
-  if (!existsSync21(root))
+  if (!existsSync22(root))
     return [];
   const files = [];
   const visit2 = async (dir) => {
     const entries = await readdir11(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const absPath = join32(dir, entry.name);
+      const absPath = join33(dir, entry.name);
       if (entry.isDirectory()) {
         await visit2(absPath);
         continue;
@@ -72886,7 +73105,7 @@ function isDeprecated(content3) {
   return parseFrontmatter3(content3).deprecated === true;
 }
 async function approvedKnowledgeFiles(projectRoot) {
-  const files = await walkFiles2(join32(projectRoot, KNOWLEDGE_ROOT2));
+  const files = await walkFiles2(join33(projectRoot, KNOWLEDGE_ROOT2));
   const markdown = await Promise.all(files.filter((file) => file.relPath.endsWith(".md") && !isKnowledgeAssetPath(file.relPath)).map(async (file) => ({
     ...file,
     content: await readFile27(file.absPath, "utf8")
@@ -73156,11 +73375,11 @@ function referencesReceipt() {
 }
 async function readProjectCloseStatus(projectRoot) {
   const approved = await approvedKnowledgeFiles(projectRoot);
-  const structurePath = join32(projectRoot, STRUCTURE_PATH);
-  if (approved.length === 0 && !existsSync21(structurePath))
+  const structurePath = join33(projectRoot, STRUCTURE_PATH);
+  if (approved.length === 0 && !existsSync22(structurePath))
     return { state: "missing", diagnostics: [] };
   const inputHash = await approvedKnowledgeInputHash(projectRoot);
-  if (!existsSync21(structurePath))
+  if (!existsSync22(structurePath))
     return { state: "missing", inputHash, diagnostics: [`close structure is missing: ${STRUCTURE_PATH}`] };
   try {
     const parsed = import_yaml14.default.parse(await readFile27(structurePath, "utf8"));
@@ -73229,8 +73448,8 @@ async function closeProjectWorkspace(projectRoot) {
         next: "Fix context verify errors, then rerun context close --format json."
       });
     }
-    const outputPath = join32(projectRoot, STRUCTURE_PATH);
-    await mkdir17(dirname21(outputPath), { recursive: true });
+    const outputPath = join33(projectRoot, STRUCTURE_PATH);
+    await mkdir17(dirname22(outputPath), { recursive: true });
     await writeFile13(outputPath, `${import_yaml14.default.stringify(structure)}`, "utf8");
     await clearCompletedLifecycle(projectRoot);
     return {
@@ -73279,22 +73498,33 @@ async function runProjectCloseCommand(input) {
     ].join(`
 `));
   }
+  queueContextRuntimeEvent({
+    cwd: result.projectRoot,
+    kind: "knowledge.closed",
+    properties: {
+      node_count: result.nodes,
+      view_count: result.views,
+      edge_count: result.edges,
+      verify_warning_count: result.verifyWarnings,
+      relationship_coverage: result.relationshipCoverage.state
+    }
+  });
   return true;
 }
 
 // src/project/reviewApply.ts
-import { existsSync as existsSync26 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { mkdir as mkdir22, readFile as readFile34, rm as rm11, writeFile as writeFile18 } from "node:fs/promises";
-import { dirname as dirname26, join as join41 } from "node:path";
+import { dirname as dirname27, join as join42 } from "node:path";
 init_cliFeedback();
 init_errors();
 init_exitCode();
 
 // src/project/proseCompileStructure.ts
 import { createHash as createHash15 } from "node:crypto";
-import { existsSync as existsSync24 } from "node:fs";
+import { existsSync as existsSync25 } from "node:fs";
 import { mkdir as mkdir20, readFile as readFile32, writeFile as writeFile16 } from "node:fs/promises";
-import { dirname as dirname24, join as join39 } from "node:path";
+import { dirname as dirname25, join as join40 } from "node:path";
 init_cliFeedback();
 init_errors();
 init_exitCode();
@@ -73303,7 +73533,7 @@ var import_yaml20 = __toESM(require_dist3(), 1);
 // src/project/proseAlignEvidence.ts
 import { createHash as createHash13 } from "node:crypto";
 import { readFile as readFile28 } from "node:fs/promises";
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 
 // src/incremental/rawBlocks.ts
 var import_yaml15 = __toESM(require_dist3(), 1);
@@ -77198,7 +77428,7 @@ async function loadProseEvidence(input) {
   const documents = [];
   const chunks = [];
   for (const [documentIndex, document4] of indexResult.index.documents.entries()) {
-    const markdown = await readFile28(join33(input.projectRoot, indexResult.index.materialized_at, document4.path), "utf8");
+    const markdown = await readFile28(join34(input.projectRoot, indexResult.index.materialized_at, document4.path), "utf8");
     const locator = locatorFor({
       sourceType: resolved.sourceType,
       sourceName: resolved.sourceName,
@@ -77673,19 +77903,19 @@ function repairHints(diagnostics, phaseId) {
 
 // src/project/proseAlignStructureSummary.ts
 import { mkdir as mkdir18, writeFile as writeFile14 } from "node:fs/promises";
-import { dirname as dirname22, join as join36 } from "node:path";
+import { dirname as dirname23, join as join37 } from "node:path";
 
 // src/project/proseAlignExistingApprovedStructure.ts
 var import_yaml16 = __toESM(require_dist3(), 1);
-import { existsSync as existsSync22 } from "node:fs";
+import { existsSync as existsSync23 } from "node:fs";
 import { readFile as readFile29, readdir as readdir12 } from "node:fs/promises";
-import { basename as basename7, join as join34, relative as relative14 } from "node:path";
-var APPROVED_STRUCTURE_PATH4 = join34("knowledge", "structure.yaml");
+import { basename as basename7, join as join35, relative as relative14 } from "node:path";
+var APPROVED_STRUCTURE_PATH4 = join35("knowledge", "structure.yaml");
 var KNOWLEDGE_ROOT3 = "knowledge";
 function uniqueRefs(refs) {
   return [...new Set(refs)].sort();
 }
-function isRecord14(value) {
+function isRecord15(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function stringField3(record, key) {
@@ -77702,14 +77932,14 @@ function toPosixPath10(path4) {
   return path4.split(/[\\/]+/u).join("/");
 }
 async function approvedMarkdownFiles(projectRoot) {
-  const root2 = join34(projectRoot, KNOWLEDGE_ROOT3);
-  if (!existsSync22(root2))
+  const root2 = join35(projectRoot, KNOWLEDGE_ROOT3);
+  if (!existsSync23(root2))
     return [];
   const files = [];
   const visit3 = async (directory) => {
     const entries = await readdir12(directory, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = join34(directory, entry.name);
+      const absolutePath = join35(directory, entry.name);
       if (entry.isDirectory()) {
         await visit3(absolutePath);
         continue;
@@ -77726,7 +77956,7 @@ function frontmatterRecord(markdown) {
   if (match === null)
     return;
   const parsed = import_yaml16.default.parse(match[1] ?? "");
-  return isRecord14(parsed) ? parsed : undefined;
+  return isRecord15(parsed) ? parsed : undefined;
 }
 function isDeprecatedApprovedPage(markdown) {
   return /^deprecated:\s*true\s*$/mu.test(markdown);
@@ -77775,7 +78005,7 @@ async function parseExistingApprovedMarkdown(projectRoot) {
       node_type: existingNode?.node_type ?? nodeType,
       tags: uniqueRefs([...existingNode?.tags ?? [], ...nodeTags])
     });
-    const relPath = toPosixPath10(relative14(join34(projectRoot, KNOWLEDGE_ROOT3), filePath));
+    const relPath = toPosixPath10(relative14(join35(projectRoot, KNOWLEDGE_ROOT3), filePath));
     const location = pathLocation(relPath);
     const collection = viewRef.split(":", 1)[0] ?? location.collection;
     views.set(viewRef, {
@@ -77804,8 +78034,8 @@ async function parseExistingApprovedMarkdown(projectRoot) {
   return { nodes, views, sections, edges: [], diagnostics: [] };
 }
 async function readFreshApprovedStructureEdges(projectRoot) {
-  const absolutePath = join34(projectRoot, APPROVED_STRUCTURE_PATH4);
-  if (!existsSync22(absolutePath))
+  const absolutePath = join35(projectRoot, APPROVED_STRUCTURE_PATH4);
+  if (!existsSync23(absolutePath))
     return { edges: [], diagnostics: [] };
   let raw;
   try {
@@ -77814,7 +78044,7 @@ async function readFreshApprovedStructureEdges(projectRoot) {
     const message = error instanceof Error ? error.message : String(error);
     return { edges: [], diagnostics: [`knowledge/structure.yaml could not be parsed: ${message}`] };
   }
-  if (!isRecord14(raw) || raw.schema_version !== "context.approved-structure.v1") {
+  if (!isRecord15(raw) || raw.schema_version !== "context.approved-structure.v1") {
     return { edges: [], diagnostics: ["knowledge/structure.yaml schema is not current; approved summary uses Markdown projection only."] };
   }
   const expectedInputHash = await approvedKnowledgeInputHash(projectRoot).catch(() => {
@@ -77848,7 +78078,7 @@ function emptyExistingApprovedStructureSummary(diagnostics = []) {
 function parseApprovedEdges(raw) {
   const edges = [];
   for (const rawEdge of Array.isArray(raw.edges) ? raw.edges : []) {
-    if (!isRecord14(rawEdge))
+    if (!isRecord15(rawEdge))
       continue;
     const type = stringField3(rawEdge, "type");
     const from = stringField3(rawEdge, "from");
@@ -77918,7 +78148,7 @@ async function readExistingApprovedStructureSummary(input) {
   const freshStructure = await readFreshApprovedStructureEdges(input.projectRoot);
   approved.edges = freshStructure.edges;
   approved.diagnostics.push(...freshStructure.diagnostics);
-  if (approved.nodes.size === 0 && approved.views.size === 0 && approved.sections.size === 0 && !existsSync22(join34(input.projectRoot, APPROVED_STRUCTURE_PATH4))) {
+  if (approved.nodes.size === 0 && approved.views.size === 0 && approved.sections.size === 0 && !existsSync23(join35(input.projectRoot, APPROVED_STRUCTURE_PATH4))) {
     return emptyExistingApprovedStructureSummary();
   }
   const endpointRefs = new Set([
@@ -79026,12 +79256,12 @@ function renderStructureSummaryHtml(input) {
 
 // src/project/localHtmlReport.ts
 import { execFile as execFile3 } from "node:child_process";
-import { isAbsolute as isAbsolute7, join as join35 } from "node:path";
+import { isAbsolute as isAbsolute7, join as join36 } from "node:path";
 import { pathToFileURL } from "node:url";
 import { promisify as promisify3 } from "node:util";
 var execFileAsync3 = promisify3(execFile3);
 function htmlReportReference(input) {
-  const absolutePath = isAbsolute7(input.path) ? input.path : join35(input.projectRoot, input.path);
+  const absolutePath = isAbsolute7(input.path) ? input.path : join36(input.projectRoot, input.path);
   return {
     format: "html",
     path: input.path,
@@ -79377,9 +79607,9 @@ function buildStructureSummary(input) {
 async function writeStructureSummaryReport(input) {
   const summary = buildStructureSummary(input);
   const shortDigest = summary.structure_digest.replace(/^sha256:/u, "").slice(0, 16);
-  const reportPath = join36(".tmp", "context-runtime", "reports", `structure-summary-${shortDigest}.html`);
-  const absolutePath = join36(input.projectRoot, reportPath);
-  await mkdir18(dirname22(absolutePath), { recursive: true });
+  const reportPath = join37(".tmp", "context-runtime", "reports", `structure-summary-${shortDigest}.html`);
+  const absolutePath = join37(input.projectRoot, reportPath);
+  await mkdir18(dirname23(absolutePath), { recursive: true });
   await writeFile14(absolutePath, renderStructureSummaryHtml({ summary, diagnostics: input.diagnostics }), "utf8");
   return {
     summary,
@@ -79554,9 +79784,9 @@ function withStructureReviewArtifacts(input) {
 // src/project/proseCompileViews.ts
 var import_yaml17 = __toESM(require_dist3(), 1);
 import { createHash as createHash14 } from "node:crypto";
-import { existsSync as existsSync23 } from "node:fs";
+import { existsSync as existsSync24 } from "node:fs";
 import { readFile as readFile30 } from "node:fs/promises";
-import { join as join37 } from "node:path";
+import { join as join38 } from "node:path";
 
 // src/project/proseCompileSemanticRules.ts
 function compileSemanticRules(input) {
@@ -79959,8 +80189,8 @@ function canonicalizeApprovedSourceRef2(ref2, sources) {
 }
 async function existingApprovedNodeSections(input) {
   const relativePath = `knowledge/${input.node.path}`;
-  const absolutePath = join37(input.projectRoot, relativePath);
-  if (!existsSync23(absolutePath)) {
+  const absolutePath = join38(input.projectRoot, relativePath);
+  if (!existsSync24(absolutePath)) {
     return {
       path: relativePath,
       present: false,
@@ -80342,7 +80572,7 @@ function parsePayloadText(raw) {
 // src/project/proseAlignPayloadStage.ts
 var import_yaml19 = __toESM(require_dist3(), 1);
 import { mkdir as mkdir19, writeFile as writeFile15 } from "node:fs/promises";
-import { dirname as dirname23, join as join38 } from "node:path";
+import { dirname as dirname24, join as join39 } from "node:path";
 init_writeLock();
 async function resolveStagedPayloadConfirmation(input) {
   await archiveActiveStructure(input.projectRoot);
@@ -80413,7 +80643,7 @@ async function stageAlignPayload(input) {
         next: readPlanCommand
       });
     }
-    const structurePath = join38(input.projectRoot, LIFECYCLE_STRUCTURE_FILE);
+    const structurePath = join39(input.projectRoot, LIFECYCLE_STRUCTURE_FILE);
     const resolved = await resolveStagedPayloadConfirmation(input);
     const effectivePayload = {
       ...resolved.payload,
@@ -80425,7 +80655,7 @@ async function stageAlignPayload(input) {
     if (effectivePayload.lifecycle.state === "confirmed" || effectivePayload.lifecycle.state === "frozen") {
       await writeStructureSnapshot(input.projectRoot, effectivePayload);
     }
-    await mkdir19(dirname23(structurePath), { recursive: true });
+    await mkdir19(dirname24(structurePath), { recursive: true });
     await writeFile15(structurePath, import_yaml19.default.stringify(normalizeAlignPayloadForWrite(effectivePayload)), "utf8");
     return {
       structureFile: LIFECYCLE_STRUCTURE_FILE,
@@ -80941,7 +81171,7 @@ function canonicalJson2(value) {
 function digest3(value) {
   return `sha256:${createHash15("sha256").update(canonicalJson2(value)).digest("hex")}`;
 }
-function isRecord15(value) {
+function isRecord16(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function stringField4(record, field) {
@@ -80952,8 +81182,8 @@ function stringArray2(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
 }
 async function readStructureFile(projectRoot) {
-  const structurePath = join39(projectRoot, LIFECYCLE_STRUCTURE_FILE);
-  if (!existsSync24(structurePath)) {
+  const structurePath = join40(projectRoot, LIFECYCLE_STRUCTURE_FILE);
+  if (!existsSync25(structurePath)) {
     return null;
   }
   let raw;
@@ -80978,8 +81208,8 @@ async function readStructureFile(projectRoot) {
   }
 }
 async function readApprovedStructureFile(projectRoot) {
-  const structurePath = join39(projectRoot, APPROVED_STRUCTURE_FILE2);
-  if (!existsSync24(structurePath))
+  const structurePath = join40(projectRoot, APPROVED_STRUCTURE_FILE2);
+  if (!existsSync25(structurePath))
     return null;
   try {
     return import_yaml20.default.parse(await readFile32(structurePath, "utf8"));
@@ -80994,13 +81224,13 @@ async function readApprovedStructureFile(projectRoot) {
 async function compileStructureSlotDigest(input) {
   const slotDigest = await currentStructureSlotDigest(input.projectRoot, input.sourceKey, input.collection);
   const current2 = await readStructureFile(input.projectRoot);
-  if (current2 === null || !isRecord15(current2) || !Array.isArray(current2.sources) || !Array.isArray(current2.views)) {
+  if (current2 === null || !isRecord16(current2) || !Array.isArray(current2.sources) || !Array.isArray(current2.views)) {
     return slotDigest;
   }
-  const currentOwnsTarget = current2.sources.includes(input.sourceKey) && current2.views.some((view) => isRecord15(view) && view.collection === input.collection);
+  const currentOwnsTarget = current2.sources.includes(input.sourceKey) && current2.views.some((view) => isRecord16(view) && view.collection === input.collection);
   if (!currentOwnsTarget)
     return slotDigest;
-  const lifecycle = isRecord15(current2.lifecycle) ? current2.lifecycle : undefined;
+  const lifecycle = isRecord16(current2.lifecycle) ? current2.lifecycle : undefined;
   const currentDigest = lifecycle === undefined ? undefined : stringField4(lifecycle, "structure_digest");
   return slotDigest !== undefined && slotDigest !== currentDigest ? slotDigest : undefined;
 }
@@ -81009,7 +81239,7 @@ function parseApprovedSections(value, viewRef) {
     return [];
   const sections = [];
   for (const rawSection of value) {
-    if (!isRecord15(rawSection))
+    if (!isRecord16(rawSection))
       continue;
     const id2 = stringField4(rawSection, "id");
     const kind = stringField4(rawSection, "kind");
@@ -81032,7 +81262,7 @@ function parseApprovedNodes(value) {
     return [];
   const nodes = [];
   for (const rawNode of value) {
-    if (!isRecord15(rawNode))
+    if (!isRecord16(rawNode))
       continue;
     const nodeRef = stringField4(rawNode, "node_ref");
     const title = stringField4(rawNode, "title");
@@ -81056,7 +81286,7 @@ function parseApprovedViews(value, nodes) {
   const nodeByRef = new Map(nodes.map((node3) => [node3.node_ref, node3]));
   const views = [];
   for (const rawView of value) {
-    if (!isRecord15(rawView))
+    if (!isRecord16(rawView))
       continue;
     const viewRef = stringField4(rawView, "view_ref");
     const nodeRef = stringField4(rawView, "node_ref");
@@ -81094,7 +81324,7 @@ function parseApprovedEdges2(value) {
     return [];
   const edges = [];
   for (const rawEdge of value) {
-    if (!isRecord15(rawEdge))
+    if (!isRecord16(rawEdge))
       continue;
     const type = stringField4(rawEdge, "type");
     const from = stringField4(rawEdge, "from");
@@ -81158,7 +81388,7 @@ function assertApprovedEdgeContract(value, endpointRefs) {
     });
   }
   for (const [index2, rawEdge] of value.entries()) {
-    if (!isRecord15(rawEdge)) {
+    if (!isRecord16(rawEdge)) {
       throw workspaceError("knowledge/structure.yaml edge must be an object", {
         path: APPROVED_STRUCTURE_FILE2,
         edge_index: index2,
@@ -81298,7 +81528,7 @@ async function loadConfirmedStructure(input) {
   let rawStructure = input.structureDigest === undefined ? await readStructureFile(input.projectRoot) : await readStructureSnapshot(input.projectRoot, input.structureDigest);
   if (rawStructure === null && input.structureDigest !== undefined) {
     const active = await readStructureFile(input.projectRoot);
-    const activeDigest = isRecord15(active) && isRecord15(active.lifecycle) ? stringField4(active.lifecycle, "structure_digest") : undefined;
+    const activeDigest = isRecord16(active) && isRecord16(active.lifecycle) ? stringField4(active.lifecycle, "structure_digest") : undefined;
     if (activeDigest === input.structureDigest) {
       rawStructure = active;
     } else if (input.readOnly !== true) {
@@ -81315,7 +81545,7 @@ async function loadConfirmedStructure(input) {
       });
     }
     const approvedStructure = await readApprovedStructureFile(input.projectRoot);
-    if (!isRecord15(approvedStructure)) {
+    if (!isRecord16(approvedStructure)) {
       throw workspaceError("compileProse requires confirmed .tmp/context-runtime/lifecycle/structure.yaml or approved knowledge/structure.yaml", {
         path: LIFECYCLE_STRUCTURE_FILE,
         approved_structure: APPROVED_STRUCTURE_FILE2,
@@ -81411,8 +81641,8 @@ async function freezeStructureIfNeeded(input) {
     };
     await archiveActiveStructure(input.projectRoot);
     await writeStructureSnapshot(input.projectRoot, nextStructure);
-    const structurePath = join39(input.projectRoot, LIFECYCLE_STRUCTURE_FILE);
-    await mkdir20(dirname24(structurePath), { recursive: true });
+    const structurePath = join40(input.projectRoot, LIFECYCLE_STRUCTURE_FILE);
+    await mkdir20(dirname25(structurePath), { recursive: true });
     await writeFile16(structurePath, import_yaml20.default.stringify({
       schema_version: nextStructure.schema_version,
       sources: nextStructure.sources,
@@ -81495,9 +81725,9 @@ var import_yaml22 = __toESM(require_dist3(), 1);
 
 // src/project/reviewShared.ts
 import { createHash as createHash16 } from "node:crypto";
-import { existsSync as existsSync25, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync26, readdirSync as readdirSync2, readFileSync as readFileSync7 } from "node:fs";
 import { mkdir as mkdir21, readFile as readFile33, rm as rm10, rmdir as rmdir2, writeFile as writeFile17 } from "node:fs/promises";
-import { dirname as dirname25, join as join40 } from "node:path";
+import { dirname as dirname26, join as join41 } from "node:path";
 init_cliFeedback();
 init_errors();
 init_exitCode();
@@ -81527,10 +81757,10 @@ function proseCandidateMarkdown(input) {
 
 // src/project/reviewShared.ts
 init_workspace();
-var SNAPSHOT_ROOT2 = join40(".tmp", "context-runtime", "extract", "candidates");
-var REVIEW_ACTION_ROOT2 = join40(".tmp", "context-runtime", "review-actions");
+var SNAPSHOT_ROOT2 = join41(".tmp", "context-runtime", "extract", "candidates");
+var REVIEW_ACTION_ROOT2 = join41(".tmp", "context-runtime", "review-actions");
 var REVIEW_PAYLOAD_SCHEMA = "context.review.decisions.v1";
-function isRecord16(value) {
+function isRecord17(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function assertCollection(value) {
@@ -81551,26 +81781,26 @@ function assertCollection(value) {
 }
 function snapshotPath2(projectRoot, candidateId) {
   assertSafeEntityId(candidateId);
-  return join40(projectRoot, SNAPSHOT_ROOT2, `${candidateId}.json`);
+  return join41(projectRoot, SNAPSHOT_ROOT2, `${candidateId}.json`);
 }
 async function readCandidateSnapshot(projectRoot, candidateId) {
   const file = snapshotPath2(projectRoot, candidateId);
-  if (!existsSync25(file))
+  if (!existsSync26(file))
     return;
   let parsed;
   try {
     parsed = JSON.parse(await readFile33(file, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new ContextError(ExitCode.WorkspaceStateError, `candidate snapshot is invalid JSON: ${join40(SNAPSHOT_ROOT2, `${candidateId}.json`)}`, {
+    throw new ContextError(ExitCode.WorkspaceStateError, `candidate snapshot is invalid JSON: ${join41(SNAPSHOT_ROOT2, `${candidateId}.json`)}`, {
       category: ErrorCategory.SchemaInvalid,
       candidate_id: candidateId,
       reason: message,
       next: "Rerun the extract phase before reviewing this candidate."
     });
   }
-  if (!isRecord16(parsed) || typeof parsed.candidate_id !== "string" || typeof parsed.markdown !== "string") {
-    throw new ContextError(ExitCode.WorkspaceStateError, `candidate snapshot is invalid: ${join40(SNAPSHOT_ROOT2, `${candidateId}.json`)}`, {
+  if (!isRecord17(parsed) || typeof parsed.candidate_id !== "string" || typeof parsed.markdown !== "string") {
+    throw new ContextError(ExitCode.WorkspaceStateError, `candidate snapshot is invalid: ${join41(SNAPSHOT_ROOT2, `${candidateId}.json`)}`, {
       category: ErrorCategory.SchemaInvalid,
       candidate_id: candidateId,
       next: "Rerun the extract phase before reviewing this candidate."
@@ -81601,15 +81831,15 @@ async function extractCandidateSnapshotIsCurrent(projectRoot, snapshot) {
 async function removeCandidateSnapshot2(projectRoot, candidateId) {
   const file = snapshotPath2(projectRoot, candidateId);
   await rm10(file, { force: true });
-  const snapshotRoot = join40(projectRoot, SNAPSHOT_ROOT2);
-  let current2 = dirname25(file);
+  const snapshotRoot = join41(projectRoot, SNAPSHOT_ROOT2);
+  let current2 = dirname26(file);
   while (current2 !== snapshotRoot && current2.startsWith(snapshotRoot)) {
     try {
       await rmdir2(current2);
     } catch {
       break;
     }
-    current2 = dirname25(current2);
+    current2 = dirname26(current2);
   }
 }
 function parseCanonicalSourceRef(ref2) {
@@ -81730,11 +81960,11 @@ function findApprovedPageForViewRef(projectRoot, viewRef) {
   }
   const nodeRef = viewRef.slice(separator + 1);
   assertSafeEntityId(nodeRef);
-  const collectionRoot = join40(projectRoot, "knowledge", collection);
-  if (existsSync25(collectionRoot)) {
+  const collectionRoot = join41(projectRoot, "knowledge", collection);
+  if (existsSync26(collectionRoot)) {
     const visit3 = (dir, relDir) => {
       for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-        const absPath = join40(dir, entry.name);
+        const absPath = join41(dir, entry.name);
         const rel = relDir.length === 0 ? entry.name : `${relDir}/${entry.name}`;
         if (entry.isDirectory()) {
           const found2 = visit3(absPath, rel);
@@ -81744,16 +81974,16 @@ function findApprovedPageForViewRef(projectRoot, viewRef) {
         }
         if (!entry.isFile() || !entry.name.endsWith(".md"))
           continue;
-        const block = frontmatterBlock(readFileSync6(absPath, "utf8"));
+        const block = frontmatterBlock(readFileSync7(absPath, "utf8"));
         if (block === null)
           continue;
         const parsed = import_yaml21.default.parse(block.yaml);
-        if (!isRecord16(parsed) || parsed.view_ref !== viewRef)
+        if (!isRecord17(parsed) || parsed.view_ref !== viewRef)
           continue;
         const approvedNodeRef = typeof parsed.node_ref === "string" && parsed.node_ref.trim().length > 0 ? parsed.node_ref.trim() : nodeRef;
         return {
           path: absPath,
-          relPath: join40("knowledge", collection, rel),
+          relPath: join41("knowledge", collection, rel),
           nodeRef: approvedNodeRef
         };
       }
@@ -81794,7 +82024,7 @@ function updateFrontmatter(content3, mutate) {
     });
   }
   const parsed = import_yaml21.default.parse(block.yaml);
-  if (!isRecord16(parsed)) {
+  if (!isRecord17(parsed)) {
     throw new ContextError(ExitCode.WorkspaceStateError, "approved page frontmatter must be a YAML object", {
       category: ErrorCategory.SchemaInvalid
     });
@@ -81809,16 +82039,16 @@ function parseApprovedSources(content3) {
   if (block === null)
     return [];
   const parsed = import_yaml21.default.parse(block.yaml);
-  if (!isRecord16(parsed))
+  if (!isRecord17(parsed))
     return [];
   const sources = parsed.sources;
   return Array.isArray(sources) ? sources.filter((source2) => typeof source2 === "string") : [];
 }
 async function writeReviewActionLog(input) {
   const stamp = new Date().toISOString().replace(/[-:.TZ]/gu, "");
-  const relPath = join40(REVIEW_ACTION_ROOT2, `${stamp}-${input.action}-${input.id.replace(/[\\/]+/gu, "_")}.json`);
-  const path4 = join40(input.projectRoot, relPath);
-  await mkdir21(dirname25(path4), { recursive: true });
+  const relPath = join41(REVIEW_ACTION_ROOT2, `${stamp}-${input.action}-${input.id.replace(/[\\/]+/gu, "_")}.json`);
+  const path4 = join41(input.projectRoot, relPath);
+  await mkdir21(dirname26(path4), { recursive: true });
   await writeFile17(path4, `${JSON.stringify({
     action: input.action,
     id: input.id,
@@ -82313,7 +82543,7 @@ async function prepareApprovedPage(input) {
   if (input.record.candidate_type !== "prose-align") {
     assertSafeEntityId(input.record.node_ref);
   }
-  relPath = join41("knowledge", input.record.path);
+  relPath = join42("knowledge", input.record.path);
   const existingView = findApprovedPageForViewRef(input.projectRoot, input.record.view_ref);
   if (existingView !== undefined && existingView.relPath !== relPath) {
     throw new ContextError(ExitCode.WorkspaceStateError, `approved page already exists for view_ref at a different path: ${input.record.view_ref}`, {
@@ -82325,8 +82555,8 @@ async function prepareApprovedPage(input) {
       next: "Resolve the approved page path migration explicitly before approving this candidate."
     });
   }
-  const absPath = join41(input.projectRoot, relPath);
-  const existing = existsSync26(absPath) ? await readFile34(absPath, "utf8") : undefined;
+  const absPath = join42(input.projectRoot, relPath);
+  const existing = existsSync27(absPath) ? await readFile34(absPath, "utf8") : undefined;
   if (existing !== undefined) {
     const frontmatter = parseFrontmatterLoose(existing);
     const existingViewRef = typeof frontmatter.view_ref === "string" ? frontmatter.view_ref : undefined;
@@ -82398,11 +82628,11 @@ async function prepareApprovedPage(input) {
 }
 async function writePreparedApprovedPage(page) {
   for (const asset of page.assets) {
-    await mkdir22(dirname26(asset.absPath), { recursive: true });
+    await mkdir22(dirname27(asset.absPath), { recursive: true });
     await writeFile18(asset.absPath, asset.bytes);
   }
   if (page.changed) {
-    await mkdir22(dirname26(page.absPath), { recursive: true });
+    await mkdir22(dirname27(page.absPath), { recursive: true });
     await writeFile18(page.absPath, page.content, "utf8");
   }
 }
@@ -82633,18 +82863,18 @@ init_errors();
 init_exitCode();
 
 // src/project/repoSources.ts
-import { existsSync as existsSync29 } from "node:fs";
+import { existsSync as existsSync30 } from "node:fs";
 import { lstat, mkdir as mkdir23, readFile as readFile35, readlink, realpath as realpath2, rm as rm12, symlink } from "node:fs/promises";
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import { dirname as dirname27, isAbsolute as isAbsolute8, join as join44, relative as relative15, resolve as resolve17 } from "node:path";
+import { dirname as dirname28, isAbsolute as isAbsolute8, join as join45, relative as relative15, resolve as resolve17 } from "node:path";
 init_cliFeedback();
 init_errors();
 init_exitCode();
 
 // src/project/repoSourceModules.ts
-import { existsSync as existsSync27 } from "node:fs";
-import { join as join42, resolve as resolve16 } from "node:path";
+import { existsSync as existsSync28 } from "node:fs";
+import { join as join43, resolve as resolve16 } from "node:path";
 function normalizeSubpath(value) {
   if (value === undefined)
     return;
@@ -82671,8 +82901,8 @@ function suggestedModuleName(module) {
   return slug || "module";
 }
 async function inspectRepoSourceModules(input) {
-  const inspectPath = input.scopedAbs !== null && existsSync27(input.scopedAbs) ? input.scopedAbs : join42(input.projectRoot, input.status.materializedAt);
-  const modules = existsSync27(inspectPath) ? await detectModuleBoundaries(inspectPath, input.status.head ?? input.status.ref, DEFAULT_PATH_FILTER) : [];
+  const inspectPath = input.scopedAbs !== null && existsSync28(input.scopedAbs) ? input.scopedAbs : join43(input.projectRoot, input.status.materializedAt);
+  const modules = existsSync28(inspectPath) ? await detectModuleBoundaries(inspectPath, input.status.head ?? input.status.ref, DEFAULT_PATH_FILTER) : [];
   const recommended_sources = modules.filter((module) => module.path !== "." || modules.length === 1).map((module) => {
     const local = sourceModuleLocalForDisplay({ source: input.source, status: input.status, module });
     return {
@@ -82703,8 +82933,8 @@ function resolveRepoSourceScopedPath(localAbs, subpath) {
 
 // src/project/repoSourceRegistry.ts
 var import_yaml24 = __toESM(require_dist3(), 1);
-import { existsSync as existsSync28 } from "node:fs";
-import { join as join43 } from "node:path";
+import { existsSync as existsSync29 } from "node:fs";
+import { join as join44 } from "node:path";
 init_cliFeedback();
 init_errors();
 init_exitCode();
@@ -82761,14 +82991,14 @@ function registryEntryToRecord(entry) {
   };
 }
 function registryPath(projectRoot) {
-  return join43(projectRoot, DEFAULT_REPO_SOURCES_REGISTRY_PATH);
+  return join44(projectRoot, DEFAULT_REPO_SOURCES_REGISTRY_PATH);
 }
 function defaultRepoMaterializedAt(source2) {
   return `sources/repo/${source2.namespace}/${source2.module}`;
 }
 async function readRepoRegistry(projectRoot) {
   const path4 = registryPath(projectRoot);
-  if (!existsSync28(path4))
+  if (!existsSync29(path4))
     return { repos: [] };
   const registry2 = await loadSourcesRegistry({ rootDir: projectRoot });
   return {
@@ -82844,13 +83074,13 @@ async function gitOutput(cwd, args) {
   }
 }
 async function readGitOriginRemote(cwd) {
-  const directConfigPath = join44(cwd, ".git", "config");
+  const directConfigPath = join45(cwd, ".git", "config");
   let config = await readFile35(directConfigPath, "utf8").catch(() => "");
   if (config.length === 0) {
     const gitDir = await resolveGitDir(cwd);
     if (gitDir === null)
       return null;
-    config = await readFile35(join44(gitDir, "config"), "utf8").catch(() => "");
+    config = await readFile35(join45(gitDir, "config"), "utf8").catch(() => "");
   }
   let inOriginBlock = false;
   for (const line of config.split(/\r?\n/u)) {
@@ -82870,17 +83100,17 @@ async function readGitOriginRemote(cwd) {
 async function resolveGitRoot(cwd) {
   let current2 = resolve17(cwd);
   while (true) {
-    if (existsSync29(join44(current2, ".git")))
+    if (existsSync30(join45(current2, ".git")))
       return current2;
-    const parent = dirname27(current2);
+    const parent = dirname28(current2);
     if (parent === current2)
       return null;
     current2 = parent;
   }
 }
 async function resolveGitDir(cwd) {
-  const dotGit = join44(cwd, ".git");
-  if (!existsSync29(dotGit))
+  const dotGit = join45(cwd, ".git");
+  if (!existsSync30(dotGit))
     return null;
   const stats = await lstat(dotGit);
   if (stats.isDirectory())
@@ -82897,17 +83127,17 @@ async function readGitHead(cwd) {
   const gitDir = await resolveGitDir(cwd);
   if (gitDir === null)
     return null;
-  const headRaw = (await readFile35(join44(gitDir, "HEAD"), "utf8").catch(() => "")).trim();
+  const headRaw = (await readFile35(join45(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 readFile35(join44(gitDir, refPath), "utf8").catch(() => "")).trim();
+  const looseRef = (await readFile35(join45(gitDir, refPath), "utf8").catch(() => "")).trim();
   if (/^[a-f0-9]{40}$/iu.test(looseRef))
     return looseRef.toLowerCase();
-  const packedRefs = await readFile35(join44(gitDir, "packed-refs"), "utf8").catch(() => "");
+  const packedRefs = await readFile35(join45(gitDir, "packed-refs"), "utf8").catch(() => "");
   for (const line of packedRefs.split(/\r?\n/u)) {
     if (line.startsWith("#") || line.startsWith("^"))
       continue;
@@ -82918,27 +83148,27 @@ async function readGitHead(cwd) {
   return null;
 }
 async function ensureMaterializedSymlink(input) {
-  const linkPath = join44(input.projectRoot, input.materializedAt);
-  await mkdir23(dirname27(linkPath), { recursive: true });
-  if (existsSync29(linkPath)) {
+  const linkPath = join45(input.projectRoot, input.materializedAt);
+  await mkdir23(dirname28(linkPath), { recursive: true });
+  if (existsSync30(linkPath)) {
     const stats = await lstat(linkPath);
     if (!stats.isSymbolicLink()) {
       input.diagnostics.push(`materialized path exists and is not a symlink: ${input.materializedAt}`);
       return false;
     }
     const current2 = await readlink(linkPath);
-    const currentAbs = resolve17(dirname27(linkPath), current2);
+    const currentAbs = resolve17(dirname28(linkPath), current2);
     if (currentAbs === input.localAbs)
       return true;
     await rm12(linkPath);
   }
-  const relTarget = relative15(dirname27(linkPath), input.localAbs) || ".";
+  const relTarget = relative15(dirname28(linkPath), input.localAbs) || ".";
   await symlink(relTarget, linkPath);
   return true;
 }
 async function diagnoseMaterializedSymlink(input) {
-  const linkPath = join44(input.projectRoot, input.materializedAt);
-  if (!existsSync29(linkPath)) {
+  const linkPath = join45(input.projectRoot, input.materializedAt);
+  if (!existsSync30(linkPath)) {
     input.diagnostics.push(`materialized path is missing: ${input.materializedAt}`);
     input.agent_hints.push(`Run context source ensure ${input.sourceName} to materialize the local source link.`);
     return false;
@@ -82949,9 +83179,9 @@ async function diagnoseMaterializedSymlink(input) {
     return false;
   }
   const current2 = await readlink(linkPath);
-  const currentAbs = resolve17(dirname27(linkPath), current2);
+  const currentAbs = resolve17(dirname28(linkPath), current2);
   if (currentAbs !== input.localAbs) {
-    input.diagnostics.push(`materialized path points to ${current2}, expected local checkout ${relative15(dirname27(linkPath), input.localAbs) || "."}`);
+    input.diagnostics.push(`materialized path points to ${current2}, expected local checkout ${relative15(dirname28(linkPath), input.localAbs) || "."}`);
     input.agent_hints.push(`Run context source ensure ${input.sourceName} to refresh the local source link.`);
     return false;
   }
@@ -82983,7 +83213,7 @@ async function normalizeInputRef(input) {
       next: "Pass --local <path> with a git checkout, or use a full 40-character commit sha."
     });
   }
-  if (!existsSync29(localAbs)) {
+  if (!existsSync30(localAbs)) {
     throw new ContextError(ExitCode.UserError, `short repo source ref cannot be resolved because local path is missing: ${input.local}`, {
       category: ErrorCategory.UserInputInvalid,
       sourceName: input.sourceName,
@@ -83035,7 +83265,7 @@ async function normalizeAddInput(input, existing) {
   let gitRootAbs = null;
   if (originalLocal !== undefined) {
     const originalLocalAbs = resolveLocalPath(input.projectRoot, originalLocal);
-    if (originalLocalAbs !== null && existsSync29(originalLocalAbs)) {
+    if (originalLocalAbs !== null && existsSync30(originalLocalAbs)) {
       gitRootAbs = await resolveGitRoot(originalLocalAbs);
       if (gitRootAbs !== null && input.local !== undefined) {
         const detectedSubpath = normalizeSubpath2(relative15(gitRootAbs, originalLocalAbs));
@@ -83131,11 +83361,11 @@ async function inspectRepoSource(input) {
   const diagnostics = [];
   const agent_hints = [];
   const localAbs = resolveLocalPath(input.projectRoot, source2.local);
-  const localExists = localAbs !== null && existsSync29(localAbs);
+  const localExists = localAbs !== null && existsSync30(localAbs);
   const subpath = normalizeSubpath2(source2.subpath);
   const scopedAbs = localAbs === null ? null : scopedLocalPath(localAbs, subpath);
-  const scopeExists = scopedAbs !== null && existsSync29(scopedAbs);
-  let materialized = existsSync29(join44(input.projectRoot, materializedAt));
+  const scopeExists = scopedAbs !== null && existsSync30(scopedAbs);
+  let materialized = existsSync30(join45(input.projectRoot, materializedAt));
   const checkout = await inspectRepoCheckout({
     source: source2,
     localAbs,
@@ -83784,24 +84014,24 @@ The approved symbol is no longer present in the current code extraction.
 // src/project/packageBuilder.ts
 init_cliFeedback();
 init_errors();
-init_exitCode();
 var import_yaml28 = __toESM(require_dist3(), 1);
 import { createHash as createHash20 } from "node:crypto";
-import { existsSync as existsSync34 } from "node:fs";
+import { existsSync as existsSync35 } from "node:fs";
 import { mkdir as mkdir27, readdir as readdir15, readFile as readFile41, rm as rm13, writeFile as writeFile22 } from "node:fs/promises";
-import { dirname as dirname33, join as join51, resolve as resolve19 } from "node:path";
+import { dirname as dirname34, join as join52, resolve as resolve19 } from "node:path";
+init_exitCode();
 
 // src/project/packageBuildInventory.ts
 var import_yaml26 = __toESM(require_dist3(), 1);
 import { createHash as createHash17 } from "node:crypto";
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 import { mkdir as mkdir25, readFile as readFile37, writeFile as writeFile20 } from "node:fs/promises";
-import { dirname as dirname29, join as join46 } from "node:path";
+import { dirname as dirname30, join as join47 } from "node:path";
 
 // src/project/packageIndexes.ts
-import { existsSync as existsSync30, statSync } from "node:fs";
+import { existsSync as existsSync31, statSync } from "node:fs";
 import { mkdir as mkdir24, readdir as readdir13, readFile as readFile36, writeFile as writeFile19 } from "node:fs/promises";
-import { dirname as dirname28, join as join45, posix as pathPosix, relative as relative16 } from "node:path";
+import { dirname as dirname29, join as join46, posix as pathPosix, relative as relative16 } from "node:path";
 init_cliFeedback();
 init_errors();
 init_exitCode();
@@ -83955,7 +84185,7 @@ var PACKAGE_INVENTORY_FIELDS = [
   "candidate_fingerprint"
 ];
 var COMPILER_ONLY_TAGS = new Set(["docs", "prose", "parent-index"]);
-function isRecord17(value) {
+function isRecord18(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function stringList2(value) {
@@ -83969,7 +84199,7 @@ function parseKnowledgeFrontmatter(content3) {
     return {};
   try {
     const parsed = import_yaml25.parse(match[1]);
-    return isRecord17(parsed) ? parsed : {};
+    return isRecord18(parsed) ? parsed : {};
   } catch {
     return {};
   }
@@ -84064,13 +84294,13 @@ function packageKind(pkg) {
   return pkg.kind === "package.kb" ? "kb" : "llms";
 }
 async function walkFiles3(root2) {
-  if (!existsSync30(root2))
+  if (!existsSync31(root2))
     return [];
   const files = [];
   const visit3 = async (dir) => {
     const entries = await readdir13(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const absPath = join45(dir, entry.name);
+      const absPath = join46(dir, entry.name);
       if (entry.isDirectory()) {
         await visit3(absPath);
         continue;
@@ -84362,10 +84592,10 @@ async function writeKnowledgeDirectoryIndexes(input) {
   let written = 0;
   for (const directory of collectKnowledgeDirectoryIndexes(input.pkg, input.selected)) {
     assertSafeRenderedPath(directory.relPath, "knowledge directory index path");
-    const outputPath = join45(input.projectRoot, input.pkg.outDir, directory.relPath);
-    if (existsSync30(outputPath))
+    const outputPath = join46(input.projectRoot, input.pkg.outDir, directory.relPath);
+    if (existsSync31(outputPath))
       continue;
-    await mkdir24(dirname28(outputPath), { recursive: true });
+    await mkdir24(dirname29(outputPath), { recursive: true });
     await writeFile19(outputPath, renderKnowledgeDirectoryIndex({
       pkg: input.pkg,
       directory,
@@ -84411,23 +84641,23 @@ function packageLinkTargetExists(packageRoot, targetRelPath) {
     return false;
   }
   const normalized = targetRelPath.endsWith("/") ? `${targetRelPath}index.md` : targetRelPath;
-  const targetPath = join45(packageRoot, normalized);
-  if (existsSync30(targetPath)) {
+  const targetPath = join46(packageRoot, normalized);
+  if (existsSync31(targetPath)) {
     const stat6 = statSync(targetPath);
     if (stat6.isFile())
       return true;
     if (stat6.isDirectory())
-      return existsSync30(join45(targetPath, "index.md"));
+      return existsSync31(join46(targetPath, "index.md"));
     return false;
   }
-  if (!pathPosix.extname(normalized) && existsSync30(join45(packageRoot, normalized, "index.md")))
+  if (!pathPosix.extname(normalized) && existsSync31(join46(packageRoot, normalized, "index.md")))
     return true;
   return false;
 }
 async function validatePackageIndexLinks(input) {
   if (packageKind(input.pkg) !== "kb")
     return;
-  const packageRoot = join45(input.projectRoot, input.pkg.outDir);
+  const packageRoot = join46(input.projectRoot, input.pkg.outDir);
   const files = await walkFiles3(packageRoot);
   for (const file of files) {
     if (file.relPath !== "index.md" && !file.relPath.endsWith("/index.md"))
@@ -84498,10 +84728,10 @@ function packageKind2(pkg) {
 // src/project/packageBuildInventory.ts
 var PACKAGE_BUILD_INVENTORY_PATH = "context-build-inventory.json";
 function knowledgeStructurePath(projectRoot) {
-  return join46(projectRoot, "knowledge", "structure.yaml");
+  return join47(projectRoot, "knowledge", "structure.yaml");
 }
 async function readOptionalText(path4) {
-  if (!existsSync31(path4))
+  if (!existsSync32(path4))
     return null;
   return readFile37(path4, "utf8");
 }
@@ -84880,8 +85110,8 @@ function packageBuildInventory(input) {
   };
 }
 async function writePackageBuildInventory(input) {
-  const outputPath = join46(input.projectRoot, input.pkg.outDir, PACKAGE_BUILD_INVENTORY_PATH);
-  await mkdir25(dirname29(outputPath), { recursive: true });
+  const outputPath = join47(input.projectRoot, input.pkg.outDir, PACKAGE_BUILD_INVENTORY_PATH);
+  await mkdir25(dirname30(outputPath), { recursive: true });
   await writeFile20(outputPath, `${JSON.stringify(input.inventory, null, 2)}
 `, "utf8");
   return 1;
@@ -84889,12 +85119,12 @@ async function writePackageBuildInventory(input) {
 
 // src/project/packageBuildReceipt.ts
 import { createHash as createHash18 } from "node:crypto";
-import { existsSync as existsSync32 } from "node:fs";
+import { existsSync as existsSync33 } from "node:fs";
 import { readdir as readdir14, readFile as readFile38 } from "node:fs/promises";
-import { join as join47, relative as relative17 } from "node:path";
+import { join as join48, relative as relative17 } from "node:path";
 var IGNORED_PACKAGE_FS_ENTRIES = new Set([".DS_Store"]);
 async function walkPackageFiles(root2) {
-  if (!existsSync32(root2))
+  if (!existsSync33(root2))
     return [];
   const files = [];
   const visit3 = async (dir) => {
@@ -84902,7 +85132,7 @@ async function walkPackageFiles(root2) {
     for (const entry of entries) {
       if (IGNORED_PACKAGE_FS_ENTRIES.has(entry.name))
         continue;
-      const absPath = join47(dir, entry.name);
+      const absPath = join48(dir, entry.name);
       if (entry.isDirectory()) {
         await visit3(absPath);
         continue;
@@ -84933,7 +85163,7 @@ function classifyOutputFile(path4, knowledgeGroups) {
 }
 async function packageOutputSnapshot(projectRoot, pkg, knowledgeGroups, previousOutputs = []) {
   const previousByPath = new Map(previousOutputs.map((file) => [file.path, file]));
-  return Promise.all((await walkPackageFiles(join47(projectRoot, pkg.outDir))).map(async (file) => {
+  return Promise.all((await walkPackageFiles(join48(projectRoot, pkg.outDir))).map(async (file) => {
     const current2 = classifyOutputFile(file.relPath, knowledgeGroups);
     const previous3 = previousByPath.get(file.relPath);
     const classification = current2.kind === "file" && previous3 !== undefined ? { path: file.relPath, kind: previous3.kind, ...previous3.group === undefined ? {} : { group: previous3.group } } : current2;
@@ -84947,7 +85177,7 @@ async function packageOutputFingerprint(projectRoot, pkg) {
   const snapshot = await packageOutputSnapshot(projectRoot, pkg, new Map);
   return {
     fingerprint: createHash18("sha256").update(JSON.stringify({
-      outDirExists: existsSync32(join47(projectRoot, pkg.outDir)),
+      outDirExists: existsSync33(join48(projectRoot, pkg.outDir)),
       files: snapshot.map(({ path: path4, sha256: sha2564 }) => ({ path: path4, sha256: sha2564 }))
     })).digest("hex"),
     files: snapshot.length
@@ -85021,16 +85251,16 @@ function formatPackageBuildSummary(pkg) {
 }
 
 // src/project/packageBuildContent.ts
-import { existsSync as existsSync33 } from "node:fs";
+import { existsSync as existsSync34 } from "node:fs";
 import { mkdir as mkdir26, readFile as readFile40, writeFile as writeFile21 } from "node:fs/promises";
-import { dirname as dirname32, join as join50 } from "node:path";
+import { dirname as dirname33, join as join51 } from "node:path";
 
 // src/project/packageAssets.ts
 init_errors();
 init_cliFeedback();
 init_exitCode();
 import { readFile as readFile39 } from "node:fs/promises";
-import { dirname as dirname30, relative as relative18, sep as sep3 } from "node:path";
+import { dirname as dirname31, relative as relative18, sep as sep3 } from "node:path";
 function posixPath2(value) {
   return value.split(sep3).join("/");
 }
@@ -85052,7 +85282,7 @@ function packageAssetPath(projectRoot, absolute) {
   };
 }
 function packageMarkdownTarget(pageOutputPath, assetOutputPath) {
-  const target = posixPath2(relative18(dirname30(pageOutputPath), assetOutputPath));
+  const target = posixPath2(relative18(dirname31(pageOutputPath), assetOutputPath));
   return target.startsWith(".") ? target : `./${target}`;
 }
 async function projectPackageKnowledgeAssets(input) {
@@ -85092,7 +85322,7 @@ init_errors();
 init_exitCode();
 import { execFile as execFile5 } from "node:child_process";
 import { realpath as realpath3 } from "node:fs/promises";
-import { join as join49, relative as relative19, sep as sep4 } from "node:path";
+import { join as join50, relative as relative19, sep as sep4 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
 // src/project/packageAssetOptimization.ts
@@ -85101,7 +85331,7 @@ init_errors();
 init_exitCode();
 import { createHash as createHash19 } from "node:crypto";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname31, extname as extname10, join as join48 } from "node:path";
+import { dirname as dirname32, extname as extname10, join as join49 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 var PACKAGE_ASSET_OPTIMIZATION_THRESHOLD_BYTES = 20 * 1024 * 1024;
 function isPng(bytes) {
@@ -85123,10 +85353,10 @@ function isWebp(bytes) {
 }
 function contentAddressedWebpPath(asset, bytes) {
   const digest4 = createHash19("sha256").update(bytes).digest("hex");
-  return `${dirname31(asset.packageRelPath)}/${digest4}.webp`;
+  return `${dirname32(asset.packageRelPath)}/${digest4}.webp`;
 }
 async function loadSharpProcessor(projectRoot) {
-  const requireFromWorkspace = createRequire4(join48(projectRoot, "package.json"));
+  const requireFromWorkspace = createRequire4(join49(projectRoot, "package.json"));
   let resolved;
   try {
     resolved = requireFromWorkspace.resolve("sharp");
@@ -85246,7 +85476,7 @@ async function git(projectRoot, args) {
   }
 }
 function repositoryPath(repoRoot, projectRoot, asset) {
-  const path4 = relative19(repoRoot, join49(projectRoot, asset.knowledgeRelPath)).split(sep4).join("/");
+  const path4 = relative19(repoRoot, join50(projectRoot, asset.knowledgeRelPath)).split(sep4).join("/");
   if (path4 === ".." || path4.startsWith("../") || path4.startsWith("/")) {
     throw new ContextError(ExitCode.WorkspaceStateError, "knowledge asset is outside the current Git repository", {
       category: ErrorCategory.WorkspaceStateInvalid,
@@ -85553,8 +85783,8 @@ async function writeRenderedPackageTemplate(input) {
       templateRelPath: renderedRelPath,
       logicalTemplateRelPath: renderedLogicalRelPath
     });
-    const outputPath = join50(input.projectRoot, input.pkg.outDir, renderedRelPath);
-    await mkdir26(dirname32(outputPath), { recursive: true });
+    const outputPath = join51(input.projectRoot, input.pkg.outDir, renderedRelPath);
+    await mkdir26(dirname33(outputPath), { recursive: true });
     await writeFile21(outputPath, renderTemplateText(file.content, contentVars), "utf8");
     written++;
   }
@@ -85580,7 +85810,7 @@ async function writeSelectedPackageKnowledge(input) {
   const { projectedPages, delivered } = input.prepared ?? await prepareSelectedPackageKnowledge(input);
   for (const projected of projectedPages) {
     assertSafeRenderedPath2(projected.pageOutputPath, "knowledge path");
-    const outputPath = join50(input.projectRoot, input.pkg.outDir, projected.pageOutputPath);
+    const outputPath = join51(input.projectRoot, input.pkg.outDir, projected.pageOutputPath);
     const rewritten = replaceMarkdownInlineLinkTargets(projected.content, (link2) => {
       for (const [inputPath, outputPath2] of delivered.targetByOriginal) {
         if (link2.target === packageMarkdownTarget(projected.pageOutputPath, inputPath)) {
@@ -85589,14 +85819,14 @@ async function writeSelectedPackageKnowledge(input) {
       }
       return;
     });
-    await mkdir26(dirname32(outputPath), { recursive: true });
+    await mkdir26(dirname33(outputPath), { recursive: true });
     await writeFile21(outputPath, projectPackageKnowledgeMarkdown(rewritten), "utf8");
   }
   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 = join50(input.projectRoot, input.pkg.outDir, asset.packageRelPath);
-    await mkdir26(dirname32(outputPath), { recursive: true });
+    const outputPath = join51(input.projectRoot, input.pkg.outDir, asset.packageRelPath);
+    await mkdir26(dirname33(outputPath), { recursive: true });
     await writeFile21(outputPath, asset.bytes);
   }
   return {
@@ -85609,8 +85839,8 @@ async function writeSelectedPackageKnowledge(input) {
 async function appendLlmsKnowledge(input) {
   if (packageKind2(input.pkg) !== "llms" || input.templateConsumesKnowledge || input.knowledgeCount === 0)
     return 0;
-  const outputPath = join50(input.projectRoot, input.pkg.outDir, "llms.txt");
-  const existed = existsSync33(outputPath);
+  const outputPath = join51(input.projectRoot, input.pkg.outDir, "llms.txt");
+  const existed = existsSync34(outputPath);
   const existing = existed ? await readFile40(outputPath, "utf8") : "";
   const content3 = existing.trim().length > 0 ? `${existing.trimEnd()}
 
@@ -85619,7 +85849,7 @@ async function appendLlmsKnowledge(input) {
 ${input.bundle}
 ` : `${input.bundle}
 `;
-  await mkdir26(dirname32(outputPath), { recursive: true });
+  await mkdir26(dirname33(outputPath), { recursive: true });
   await writeFile21(outputPath, content3, "utf8");
   return existed ? 0 : 1;
 }
@@ -85805,7 +86035,7 @@ function validateRenderedSkillDefinition(input) {
 init_workspace();
 init_packageTemplateReview();
 var KNOWLEDGE_ROOT4 = "knowledge";
-var PACKAGE_FINGERPRINT_ROOT = join51(".tmp", "context-runtime", "packages");
+var PACKAGE_FINGERPRINT_ROOT = join52(".tmp", "context-runtime", "packages");
 var PACKAGE_BUILDER_PROTOCOL_VERSION = "v14-git-asset-identity";
 function packageAssetDeliverySummary(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
@@ -85828,10 +86058,10 @@ function assertPackageOutputDir(pkg) {
 }
 function packageFingerprintPath(projectRoot, pkg) {
   assertSafeRenderedPath2(`${pkg.name}.json`, "package fingerprint path");
-  return join51(projectRoot, PACKAGE_FINGERPRINT_ROOT, `${pkg.name}.json`);
+  return join52(projectRoot, PACKAGE_FINGERPRINT_ROOT, `${pkg.name}.json`);
 }
 async function listApprovedKnowledge(projectRoot) {
-  const files = await walkPackageFiles(join51(projectRoot, KNOWLEDGE_ROOT4));
+  const files = await walkPackageFiles(join52(projectRoot, KNOWLEDGE_ROOT4));
   const knowledge = await Promise.all(files.filter((file) => file.relPath.endsWith(".md") && !file.relPath.startsWith("assets/")).map(async (file) => ({
     ...file,
     content: await readFile41(file.absPath, "utf8")
@@ -85852,7 +86082,7 @@ function isDeprecatedKnowledge(content3) {
 async function listTemplateFiles(projectRoot, templatePath) {
   assertSafeRenderedPath2(templatePath, "package template path");
   const templateRoot = resolve19(projectRoot, templatePath);
-  if (!existsSync34(templateRoot)) {
+  if (!existsSync35(templateRoot)) {
     throw new ContextError(ExitCode.WorkspaceStateError, `package template path is missing: ${templatePath}`, {
       category: ErrorCategory.WorkspaceStateInvalid,
       path: templatePath,
@@ -85914,7 +86144,7 @@ async function packageInputFingerprint(input) {
 }
 async function readPackageManifest(projectRoot, pkg) {
   const filePath = packageFingerprintPath(projectRoot, pkg);
-  if (!existsSync34(filePath))
+  if (!existsSync35(filePath))
     return null;
   try {
     const parsed = JSON.parse(await readFile41(filePath, "utf8"));
@@ -85947,7 +86177,7 @@ async function readPackageManifest(projectRoot, pkg) {
 }
 async function writePackageFingerprint(input) {
   const filePath = packageFingerprintPath(input.projectRoot, input.pkg);
-  await mkdir27(dirname33(filePath), { recursive: true });
+  await mkdir27(dirname34(filePath), { recursive: true });
   await writeFile22(filePath, `${JSON.stringify({
     package: input.pkg.name,
     kind: packageKind2(input.pkg),
@@ -85962,12 +86192,12 @@ async function writePackageFingerprint(input) {
 `, "utf8");
 }
 async function removeOrphanPackageDirs(projectRoot, packages) {
-  const distRoot = join51(projectRoot, "dist");
-  if (!existsSync34(distRoot))
+  const distRoot = join52(projectRoot, "dist");
+  if (!existsSync35(distRoot))
     return;
   const declaredNames = new Set(packages.map((pkg) => pkg.name));
   const entries = await readdir15(distRoot, { withFileTypes: true });
-  await Promise.all(entries.filter((entry) => entry.isDirectory() && !declaredNames.has(entry.name)).map((entry) => rm13(join51(distRoot, entry.name), { recursive: true, force: true, maxRetries: 3, retryDelay: 100 })));
+  await Promise.all(entries.filter((entry) => entry.isDirectory() && !declaredNames.has(entry.name)).map((entry) => rm13(join52(distRoot, entry.name), { recursive: true, force: true, maxRetries: 3, retryDelay: 100 })));
 }
 async function collectPackageFreshness(projectRoot, packages) {
   const approved = await listApprovedKnowledge(projectRoot);
@@ -85975,8 +86205,8 @@ async function collectPackageFreshness(projectRoot, packages) {
     assertPackageOutputDir(pkg);
     const selected = selectPackageKnowledge(approved, pkg);
     assertSafeRenderedPath2(pkg.template.path, "package template path");
-    const templateRoot = join51(projectRoot, pkg.template.path);
-    const templateExists = existsSync34(templateRoot);
+    const templateRoot = join52(projectRoot, pkg.template.path);
+    const templateExists = existsSync35(templateRoot);
     if (!templateExists) {
       throw new ContextError(ExitCode.WorkspaceStateError, `package template path is missing: ${pkg.template.path}`, {
         category: ErrorCategory.WorkspaceStateInvalid,
@@ -86110,8 +86340,8 @@ async function buildProjectPackages(projectRoot) {
       files: selected,
       ...assetProcessor === undefined ? {} : { assetProcessor }
     });
-    await rm13(join51(projectRoot, pkg.outDir), { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-    await mkdir27(join51(projectRoot, pkg.outDir), { recursive: true });
+    await rm13(join52(projectRoot, pkg.outDir), { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    await mkdir27(join52(projectRoot, pkg.outDir), { recursive: true });
     const rendered = await writeRenderedPackageTemplate({
       projectRoot,
       pkg,
@@ -86249,20 +86479,32 @@ async function runProjectBuildCommand(input) {
     return false;
   const result = await buildProjectPackages(found.projectRoot);
   process.stdout.write(formatProjectBuildResult(result, input.format ?? "text", input.verbose === true));
+  queueContextRuntimeEvent({
+    cwd: result.projectRoot,
+    kind: "package.build.completed",
+    properties: {
+      package_count: result.packages.length,
+      created_count: result.packages.filter((pkg) => pkg.state === "created").length,
+      updated_count: result.packages.filter((pkg) => pkg.state === "updated").length,
+      unchanged_count: result.packages.filter((pkg) => pkg.state === "unchanged").length,
+      output_file_count: result.packages.reduce((total, pkg) => total + pkg.files, 0),
+      resource_file_count: result.packages.reduce((total, pkg) => total + pkg.resources.files, 0)
+    }
+  });
   return true;
 }
 
 // src/project/statusReaders.ts
 init_workspace();
 async function countFiles(root2, predicate) {
-  if (!existsSync35(root2))
+  if (!existsSync36(root2))
     return 0;
   let count = 0;
   const visit3 = async (dir, prefix = "") => {
     const entries = await readdir16(dir, { withFileTypes: true });
     for (const entry of entries) {
       const rel = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
-      const abs = join52(dir, entry.name);
+      const abs = join53(dir, entry.name);
       if (entry.isDirectory())
         await visit3(abs, rel);
       else if (entry.isFile() && predicate(rel))
@@ -86304,14 +86546,14 @@ async function readDraftCandidateStatus(projectRoot) {
     throw error;
   }
 }
-function isRecord18(value) {
+function isRecord19(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function stagedStructureCounts(parsed) {
   const views = Array.isArray(parsed.views) ? parsed.views : [];
-  const sections = views.flatMap((view) => isRecord18(view) && Array.isArray(view.sections) ? view.sections : []);
+  const sections = views.flatMap((view) => isRecord19(view) && Array.isArray(view.sections) ? view.sections : []);
   const sourceRefs = new Set(sections.flatMap((section) => {
-    if (!isRecord18(section))
+    if (!isRecord19(section))
       return [];
     return [
       ...typeof section.source_ref === "string" ? [section.source_ref] : [],
@@ -86328,12 +86570,12 @@ function stagedStructureCounts(parsed) {
   };
 }
 function readStructureDraftStatus(projectRoot) {
-  const structurePath = join52(projectRoot, LIFECYCLE_STRUCTURE_FILE);
-  if (!existsSync35(structurePath))
+  const structurePath = join53(projectRoot, LIFECYCLE_STRUCTURE_FILE);
+  if (!existsSync36(structurePath))
     return { state: "missing", sourceKeys: [], collections: [], diagnostics: [] };
   try {
-    const parsed = import_yaml29.default.parse(readFileSync7(structurePath, "utf8"));
-    if (!isRecord18(parsed)) {
+    const parsed = import_yaml29.default.parse(readFileSync8(structurePath, "utf8"));
+    if (!isRecord19(parsed)) {
       return {
         state: "invalid",
         sourceKeys: [],
@@ -86341,7 +86583,7 @@ function readStructureDraftStatus(projectRoot) {
         diagnostics: [`${LIFECYCLE_STRUCTURE_FILE} must be a YAML object`]
       };
     }
-    const lifecycle = isRecord18(parsed.lifecycle) ? parsed.lifecycle : {};
+    const lifecycle = isRecord19(parsed.lifecycle) ? parsed.lifecycle : {};
     const lifecycleState = lifecycle.state;
     if (lifecycleState === "draft" || lifecycleState === "confirmed" || lifecycleState === "frozen") {
       const structureDigest = typeof parsed.structure_digest === "string" ? parsed.structure_digest : typeof lifecycle.structure_digest === "string" ? lifecycle.structure_digest : undefined;
@@ -86351,7 +86593,7 @@ function readStructureDraftStatus(projectRoot) {
         lifecycleState,
         ...typeof lifecycle.phase_collection === "string" ? { phaseCollection: lifecycle.phase_collection } : {},
         sourceKeys: Array.isArray(parsed.sources) ? parsed.sources.filter((item) => typeof item === "string") : [],
-        collections: Array.isArray(parsed.views) ? [...new Set(parsed.views.flatMap((view) => isRecord18(view) && typeof view.collection === "string" ? [view.collection] : []))].sort() : [],
+        collections: Array.isArray(parsed.views) ? [...new Set(parsed.views.flatMap((view) => isRecord19(view) && typeof view.collection === "string" ? [view.collection] : []))].sort() : [],
         ...structureDigest === undefined ? {} : { structureDigest },
         ...evidenceSnapshotHash === undefined ? {} : { evidenceSnapshotHash },
         ...stagedStructureCounts(parsed),
@@ -86528,8 +86770,8 @@ async function documentSourceSiteHint(input) {
   });
 }
 function documentSnapshotReadiness(input) {
-  const manifestPath = join52(input.projectRoot, input.manifest);
-  if (!existsSync35(manifestPath)) {
+  const manifestPath = join53(input.projectRoot, input.manifest);
+  if (!existsSync36(manifestPath)) {
     return {
       ready: false,
       diagnostics: [`snapshot is missing: ${input.manifest}`],
@@ -86537,7 +86779,7 @@ function documentSnapshotReadiness(input) {
     };
   }
   try {
-    const manifest = findDocumentSnapshotForSource(JSON.parse(readFileSync7(manifestPath, "utf8")), input.sourceName);
+    const manifest = findDocumentSnapshotForSource(JSON.parse(readFileSync8(manifestPath, "utf8")), input.sourceName);
     if (manifest === null) {
       return {
         ready: false,
@@ -86598,7 +86840,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((path4) => !existsSync35(join52(input.projectRoot, input.materializedAt, path4)));
+    ].filter((path4) => !existsSync36(join53(input.projectRoot, input.materializedAt, path4)));
     if (missingFiles.length > 0) {
       return {
         ready: false,
@@ -86845,9 +87087,9 @@ async function readActiveStructuresStatus(projectRoot, currentSnapshotHashes) {
 init_packageTemplateReview();
 
 // src/project/workflow/workflowProvider.ts
-import { existsSync as existsSync36 } from "node:fs";
-import { dirname as dirname34, resolve as resolve20 } from "node:path";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { existsSync as existsSync37 } from "node:fs";
+import { dirname as dirname35, resolve as resolve20 } from "node:path";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // src/project/workflow/verifyFacts.ts
 var CLOSE_REPAIRABLE_APPROVED_STRUCTURE_CODES = new Set([
@@ -87419,7 +87661,7 @@ function planForResolvedCommandPlan(commandPlan, observation) {
 
 // src/project/workflow/workflowEvidenceResources.ts
 import { createHash as createHash21 } from "node:crypto";
-import { join as join53 } from "node:path";
+import { join as join54 } from "node:path";
 function sourceKeysForRoute(node3, observation) {
   if (node3 === "classify-document") {
     return observation.unclassifiedDocumentTargets.map((target) => target.sourceKey);
@@ -87471,7 +87713,7 @@ async function currentSourceBodyResources(input) {
           kind: "context-view",
           media_type: "text/markdown",
           digest: document4.content_hash,
-          path: join53(input.observation.projectRoot, source2.materializedAt, document4.path),
+          path: join54(input.observation.projectRoot, source2.materializedAt, document4.path),
           read_state: isCurrent(id2, document4.content_hash, input.receipts) ? "current" : "read-required"
         });
       }
@@ -87483,7 +87725,7 @@ async function currentSourceBodyResources(input) {
 // src/project/workflow/workflowProvider.ts
 var providerPromise;
 function providerCandidates() {
-  const moduleDir2 = dirname34(fileURLToPath6(import.meta.url));
+  const moduleDir2 = dirname35(fileURLToPath7(import.meta.url));
   return [
     ...process.env.C4A_CONTEXT_WORKFLOW_PROVIDER ? [resolve20(process.env.C4A_CONTEXT_WORKFLOW_PROVIDER)] : [],
     resolve20(moduleDir2, "providers", "context", "manifest.json"),
@@ -87491,7 +87733,7 @@ function providerCandidates() {
   ];
 }
 function contextWorkflowProviderPath() {
-  const candidate = providerCandidates().find((path4) => existsSync36(path4));
+  const candidate = providerCandidates().find((path4) => existsSync37(path4));
   if (candidate === undefined) {
     throw new Error("Context workflow Provider is missing. Rebuild @c4a/context-cli or reinstall the published package.");
   }
@@ -88505,13 +88747,13 @@ async function collectProjectStatusSnapshot(projectRoot, options = {}) {
     requestedCollections: [...new Set(alignTargets.map((target) => target.collection))],
     requestedGroups: alignGroups
   });
-  const approvedPages = await countFiles(join54(projectRoot, "knowledge"), (rel) => rel.endsWith(".md") && !rel.startsWith("assets/"));
+  const approvedPages = await countFiles(join55(projectRoot, "knowledge"), (rel) => rel.endsWith(".md") && !rel.startsWith("assets/"));
   const approvedCollections = (await Promise.all(KNOWLEDGE_COLLECTIONS.map(async (collection) => ({
     collection,
-    count: await countFiles(join54(projectRoot, "knowledge", collection), (rel) => rel.endsWith(".md"))
+    count: await countFiles(join55(projectRoot, "knowledge", collection), (rel) => rel.endsWith(".md"))
   })))).filter((item) => item.count > 0).map((item) => item.collection);
   const closeStatus = await readCloseStatus(projectRoot);
-  const distFiles = await countFiles(join54(projectRoot, "dist"), () => true);
+  const distFiles = await countFiles(join55(projectRoot, "dist"), () => true);
   const sourceFreshness = phaseStatus.projectEntryValid ? await collectSourceFreshness({
     projectRoot,
     phases,
@@ -88875,6 +89117,7 @@ async function runProjectStatusCommand(input) {
   } else {
     process.stdout.write(formatProjectStatus(status));
   }
+  input.onSuccess?.(status);
   return true;
 }
 async function assertProjectWorkflowRevision(input) {
@@ -88931,11 +89174,11 @@ function shellQuote6(value) {
 }
 function receiptSetPath(receipts) {
   const token = digestText(JSON.stringify(receipts)).slice("sha256:".length);
-  return join55(".tmp", "context-runtime", "workflow", "read-receipts", `${token}.json`);
+  return join56(".tmp", "context-runtime", "workflow", "read-receipts", `${token}.json`);
 }
 async function writeReceiptContinuation(input) {
   const path4 = receiptSetPath(input.receipts);
-  await writeJsonAtomic(join55(input.projectRoot, path4), input.receipts);
+  await writeJsonAtomic(join56(input.projectRoot, path4), input.receipts);
   const command2 = input.managed ? [
     "context",
     "--workflow-resource-receipts",
@@ -88996,7 +89239,7 @@ async function materializeContextWorkflowResource(input) {
   }
   const content3 = renderContextWorkflowResource(resourceId2, status);
   const location = await materializeResource(await loadContextWorkflowProvider(), resourceId2, {
-    cache: join55(found.projectRoot, ".tmp", "context-runtime", "workflow", "resources"),
+    cache: join56(found.projectRoot, ".tmp", "context-runtime", "workflow", "resources"),
     workspace: found.projectRoot,
     revision: input.revision,
     input: {
@@ -89222,7 +89465,7 @@ function registerContextWorkflowResourceCommands(program2) {
 }
 
 // src/commands/runProject.ts
-import { fileURLToPath as fileURLToPath7 } from "node:url";
+import { fileURLToPath as fileURLToPath8 } from "node:url";
 init_cliFeedback();
 init_errors();
 
@@ -89233,11 +89476,11 @@ init_exitCode();
 
 // src/project/documentCaptureLark.ts
 import { readdir as readdir18, readFile as readFile44 } from "node:fs/promises";
-import { basename as basename8, extname as extname12, join as join58 } from "node:path";
+import { basename as basename8, extname as extname12, join as join59 } from "node:path";
 
 // src/lib/atomicFileBatch.ts
 import { lstat as lstat2, mkdir as mkdir28, mkdtemp, rename as rename4, rm as rm14, writeFile as writeFile23 } from "node:fs/promises";
-import { dirname as dirname35, join as join56, resolve as resolve22 } from "node:path";
+import { dirname as dirname36, join as join57, resolve as resolve22 } from "node:path";
 async function existingFileKind(path4) {
   try {
     const stats = await lstat2(path4);
@@ -89267,9 +89510,9 @@ async function applyAtomicFileBatch(input) {
   for (const path4 of writesByPath.keys())
     removalPaths.delete(path4);
   await mkdir28(input.transactionRoot, { recursive: true });
-  const transactionDir = await mkdtemp(join56(input.transactionRoot, "batch-"));
-  const stagedRoot = join56(transactionDir, "staged");
-  const backupRoot = join56(transactionDir, "backup");
+  const transactionDir = await mkdtemp(join57(input.transactionRoot, "batch-"));
+  const stagedRoot = join57(transactionDir, "staged");
+  const backupRoot = join57(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;
@@ -89279,20 +89522,20 @@ async function applyAtomicFileBatch(input) {
   try {
     await mkdir28(stagedRoot, { recursive: true });
     for (const [index2, write] of writes.entries()) {
-      const path4 = join56(stagedRoot, String(index2));
+      const path4 = join57(stagedRoot, String(index2));
       await writeFile23(path4, write.bytes);
       staged.set(write.path, path4);
     }
     for (const [index2, path4] of affectedPaths.entries()) {
       if (await existingFileKind(path4) === "missing")
         continue;
-      const backupPath = join56(backupRoot, String(index2));
-      await mkdir28(dirname35(backupPath), { recursive: true });
+      const backupPath = join57(backupRoot, String(index2));
+      await mkdir28(dirname36(backupPath), { recursive: true });
       await rename4(path4, backupPath);
       backups.set(path4, backupPath);
     }
     for (const write of writes) {
-      await mkdir28(dirname35(write.path), { recursive: true });
+      await mkdir28(dirname36(write.path), { recursive: true });
       await rename4(staged.get(write.path), write.path);
       installed.push(write.path);
     }
@@ -89304,7 +89547,7 @@ async function applyAtomicFileBatch(input) {
       });
     }
     for (const [path4, backupPath] of [...backups.entries()].reverse()) {
-      await mkdir28(dirname35(path4), { recursive: true });
+      await mkdir28(dirname36(path4), { recursive: true });
       await rename4(backupPath, path4).catch((rollbackError) => {
         rollbackFailures.push(`restore ${path4}: ${String(rollbackError)}`);
       });
@@ -89341,7 +89584,7 @@ function detectExternalEnvironmentIssue(value) {
 }
 
 // src/lib/feishu.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 
 // src/lib/larkDocxXml.ts
 import { createHash as createHash23 } from "node:crypto";
@@ -93626,7 +93869,7 @@ function projectLarkDocxXmlBlock(input) {
 // src/lib/larkResourceMaterialization.ts
 import { createHash as createHash24 } from "node:crypto";
 import { mkdtemp as mkdtemp2, readFile as readFile43, readdir as readdir17, rm as rm15 } from "node:fs/promises";
-import { extname as extname11, join as join57 } from "node:path";
+import { extname as extname11, join as join58 } from "node:path";
 import { tmpdir } from "node:os";
 
 // src/lib/larkResourceCommand.ts
@@ -93825,7 +94068,7 @@ function findBooleanField(value, name2) {
   return;
 }
 async function downloadedFile(input) {
-  const tempRoot = await mkdtemp2(join57(tmpdir(), "context-lark-resource-"));
+  const tempRoot = await mkdtemp2(join58(tmpdir(), "context-lark-resource-"));
   try {
     await runLarkResourceCommand(input.runner, [
       "docs",
@@ -93846,7 +94089,7 @@ async function downloadedFile(input) {
     if (entries.length !== 1)
       throw new Error(`media download produced ${entries.length} files, expected exactly one`);
     const path4 = entries[0]?.name ?? "resource.bin";
-    const bytes = await readFile43(join57(tempRoot, path4));
+    const bytes = await readFile43(join58(tempRoot, path4));
     return { path: path4, bytes, mediaType: mediaTypeFor(path4, bytes) };
   } finally {
     await rm15(tempRoot, { recursive: true, force: true });
@@ -93937,9 +94180,9 @@ async function sheetMaterialization(resource, runner2) {
   const sheetId = resource.attributes["sheet-id"];
   if (token === undefined || sheetId === undefined)
     throw new Error("embedded Sheet requires token and sheet-id");
-  const tempRoot = await mkdtemp2(join57(tmpdir(), "context-lark-sheet-"));
+  const tempRoot = await mkdtemp2(join58(tmpdir(), "context-lark-sheet-"));
   try {
-    const outputPath = join57(tempRoot, "sheet.json");
+    const outputPath = join58(tempRoot, "sheet.json");
     const stdout = await runLarkResourceCommand(runner2, [
       "sheets",
       "+csv-get",
@@ -94095,7 +94338,7 @@ async function whiteboardMaterialization(resource, runner2) {
   if (token === undefined)
     throw new Error(`${resource.kind} has no whiteboard token`);
   const preview = await downloadedFile({ runner: runner2, token, type: "whiteboard" });
-  const tempRoot = await mkdtemp2(join57(tmpdir(), "context-lark-whiteboard-"));
+  const tempRoot = await mkdtemp2(join58(tmpdir(), "context-lark-whiteboard-"));
   let rawPayload;
   try {
     await runLarkResourceCommand(runner2, [
@@ -94113,7 +94356,7 @@ async function whiteboardMaterialization(resource, runner2) {
       "--format",
       "json"
     ], { cwd: tempRoot });
-    rawPayload = JSON.parse(await readFile43(join57(tempRoot, "raw.json"), "utf8"));
+    rawPayload = JSON.parse(await readFile43(join58(tempRoot, "raw.json"), "utf8"));
   } finally {
     await rm15(tempRoot, { recursive: true, force: true });
   }
@@ -94386,7 +94629,7 @@ class LarkCliError extends Error {
   }
 }
 var defaultRunner = (args, options) => new Promise((resolve8, reject) => {
-  const child = spawn2(LARK_BIN, args, {
+  const child = spawn3(LARK_BIN, args, {
     ...options?.cwd === undefined ? {} : { cwd: options.cwd },
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -94793,7 +95036,7 @@ async function fileContentMatches(path4, content3) {
   }
 }
 function sourceManifestPath2(entry) {
-  return entry.snapshot?.manifest ?? join58(entry.materializedAt, "manifest.json");
+  return entry.snapshot?.manifest ?? join59(entry.materializedAt, "manifest.json");
 }
 function larkRuntimeError(message, detail) {
   return new ContextError(ExitCode.ExternalToolError, message, {
@@ -94919,7 +95162,7 @@ function assetManifestEntry(asset, assetRoot) {
   };
 }
 async function listSnapshotAssetFiles(root2, assetRoot) {
-  const assetsRoot = join58(root2, assetRoot);
+  const assetsRoot = join59(root2, assetRoot);
   const files = [];
   const visit3 = async (dir, prefix = assetRoot) => {
     let entries;
@@ -94932,7 +95175,7 @@ async function listSnapshotAssetFiles(root2, assetRoot) {
     }
     for (const entry of entries) {
       const relPath = `${prefix}/${entry.name}`;
-      const absolutePath = join58(dir, entry.name);
+      const absolutePath = join59(dir, entry.name);
       if (entry.isDirectory()) {
         await visit3(absolutePath, relPath);
         continue;
@@ -94947,7 +95190,7 @@ async function listSnapshotAssetFiles(root2, assetRoot) {
 }
 async function staleSnapshotAssetPaths(input) {
   const existingPaths = await listSnapshotAssetFiles(input.materializedAtAbsPath, input.assetRoot);
-  return existingPaths.filter((path4) => !input.currentPaths.has(path4)).map((path4) => join58(input.materializedAtAbsPath, path4));
+  return existingPaths.filter((path4) => !input.currentPaths.has(path4)).map((path4) => join59(input.materializedAtAbsPath, path4));
 }
 function normalizeLarkError(error, sourceName) {
   if (error instanceof ContextError)
@@ -95021,9 +95264,9 @@ async function runCaptureLarkPhaseUnlocked(input) {
     locator
   }];
   const manifestPath = sourceManifestPath2(entry);
-  const manifestAbsPath = join58(input.projectRoot, manifestPath);
+  const manifestAbsPath = join59(input.projectRoot, manifestPath);
   const materializedAt = entry.materializedAt;
-  const materializedAtAbsPath = join58(input.projectRoot, materializedAt);
+  const materializedAtAbsPath = join59(input.projectRoot, materializedAt);
   const manifest = createDocumentSnapshotManifest({
     sourceType: "lark",
     sourceName: resolved.sourceName,
@@ -95053,13 +95296,13 @@ async function runCaptureLarkPhaseUnlocked(input) {
   }));
   try {
     const requestedWrites = [{
-      path: join58(materializedAtAbsPath, documentPath),
+      path: join59(materializedAtAbsPath, documentPath),
       bytes: normalized
     }];
     for (const asset of assets) {
       if (asset.bytes !== undefined) {
         requestedWrites.push({
-          path: join58(materializedAtAbsPath, asset.entry.path),
+          path: join59(materializedAtAbsPath, asset.entry.path),
           bytes: asset.bytes
         });
       }
@@ -95076,7 +95319,7 @@ async function runCaptureLarkPhaseUnlocked(input) {
       currentPaths: new Set(assets.filter((asset) => asset.bytes !== undefined).map((asset) => asset.entry.path))
     });
     await applyAtomicFileBatch({
-      transactionRoot: join58(input.projectRoot, ".tmp", "context-runtime", "capture-transactions"),
+      transactionRoot: join59(input.projectRoot, ".tmp", "context-runtime", "capture-transactions"),
       writes,
       removals
     });
@@ -97499,7 +97742,7 @@ function compileDiagnostic(severity, code3, family, message, field, extra = {})
     ...extra
   };
 }
-function isRecord19(value) {
+function isRecord20(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
@@ -97894,7 +98137,7 @@ function compileActionFromFields(fields) {
   return action;
 }
 function parseCompileAction(raw, index2, diagnostics) {
-  if (!isRecord19(raw)) {
+  if (!isRecord20(raw)) {
     diagnostics.push(compileDiagnostic("error", "schema.action_object", "schema", "Each action must be an object.", `actions[${index2}]`));
     return;
   }
@@ -97906,7 +98149,7 @@ function parseCompileAction(raw, index2, diagnostics) {
 }
 function parseCompilePayload(value) {
   const diagnostics = [];
-  if (!isRecord19(value)) {
+  if (!isRecord20(value)) {
     return {
       diagnostics: [compileDiagnostic("error", "schema.payload_object", "schema", "Compile action payload must be an object.", "schema")]
     };
@@ -98869,9 +99112,9 @@ init_atomicWrite();
 init_cliFeedback();
 init_errors();
 init_exitCode();
-import { existsSync as existsSync37 } from "node:fs";
+import { existsSync as existsSync38 } from "node:fs";
 import { readFile as readFile46 } from "node:fs/promises";
-import { join as join59 } from "node:path";
+import { join as join60 } from "node:path";
 init_writeLock();
 var CUSTOM_PHASE_MANIFEST = ".tmp/context-runtime/extract/custom-phase-candidates.json";
 function customInputError(phaseId, message, detail = {}) {
@@ -99025,8 +99268,8 @@ function candidateFromCustom(input) {
   };
 }
 async function readManifest(projectRoot) {
-  const path4 = join59(projectRoot, CUSTOM_PHASE_MANIFEST);
-  if (!existsSync37(path4))
+  const path4 = join60(projectRoot, CUSTOM_PHASE_MANIFEST);
+  if (!existsSync38(path4))
     return { version: 2, phases: {} };
   try {
     const parsed = JSON.parse(await readFile46(path4, "utf8"));
@@ -99126,7 +99369,7 @@ async function runExtractCustomPhase(input) {
       symbols: built.flatMap((item) => item.symbols),
       removeSymbols: previousOwned?.symbols ?? []
     });
-    await atomicWriteFile(join59(input.projectRoot, CUSTOM_PHASE_MANIFEST), `${JSON.stringify({
+    await atomicWriteFile(join60(input.projectRoot, CUSTOM_PHASE_MANIFEST), `${JSON.stringify({
       version: 2,
       phases: {
         ...manifest.phases,
@@ -99186,7 +99429,7 @@ async function runExtractCustomPhase(input) {
 
 // src/project/reviewHtml.ts
 import { mkdir as mkdir29, writeFile as writeFile24 } from "node:fs/promises";
-import { dirname as dirname36, isAbsolute as isAbsolute9, join as join61, resolve as resolve23 } from "node:path";
+import { dirname as dirname37, isAbsolute as isAbsolute9, join as join62, resolve as resolve23 } from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 
 // src/project/reviewSourceExcerpts.ts
@@ -99296,9 +99539,9 @@ async function collectReviewSourceExcerpts(projectRoot, candidates) {
 }
 
 // src/project/reviewHtmlPresentation.ts
-import { existsSync as existsSync38 } from "node:fs";
+import { existsSync as existsSync39 } from "node:fs";
 import { readFile as readFile47 } from "node:fs/promises";
-import { join as join60 } from "node:path";
+import { join as join61 } from "node:path";
 var import_yaml31 = __toESM(require_dist3(), 1);
 function escapeHtml3(value) {
   return value.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;").replace(/"/gu, "&quot;");
@@ -99379,8 +99622,8 @@ function filterEdgePreviewForCandidate(record, edges) {
   return edges.filter((edge2) => endpoints.has(edge2.from) || endpoints.has(edge2.to));
 }
 async function readEdgePreview(projectRoot) {
-  const filePath = join60(projectRoot, LIFECYCLE_STRUCTURE_FILE);
-  if (!existsSync38(filePath))
+  const filePath = join61(projectRoot, LIFECYCLE_STRUCTURE_FILE);
+  if (!existsSync39(filePath))
     return [];
   try {
     const parsed = import_yaml31.default.parse(await readFile47(filePath, "utf8"));
@@ -99557,7 +99800,7 @@ var REVIEW_HTML_STYLES = `
 `;
 
 // src/project/reviewHtml.ts
-var REVIEW_HTML_ROOT = join61(".tmp", "context-runtime", "review");
+var REVIEW_HTML_ROOT = join62(".tmp", "context-runtime", "review");
 function decodedLinkTarget(value) {
   try {
     return decodeURIComponent(value);
@@ -99571,7 +99814,7 @@ function linkedResourcePreviews(input) {
     const target = link2.target;
     if (/^[a-z][a-z0-9+.-]*:/iu.test(target) || target.startsWith("/"))
       continue;
-    const assetPath = join61(dirname36(input.documentPath), decodedLinkTarget(target)).split("\\").join("/");
+    const assetPath = join62(dirname37(input.documentPath), decodedLinkTarget(target)).split("\\").join("/");
     const asset = input.assetsByPath.get(assetPath);
     if (asset?.content_hash === undefined || asset.role === "audit")
       continue;
@@ -99579,7 +99822,7 @@ function linkedResourcePreviews(input) {
       label: link2.label || "Resource",
       kind: asset.source?.kind ?? "resource",
       status: "materialized",
-      url: pathToFileURL3(join61(input.projectRoot, input.materializedAt, asset.path)).href,
+      url: pathToFileURL3(join62(input.projectRoot, input.materializedAt, asset.path)).href,
       media_type: asset.media_type ?? "application/octet-stream",
       image: asset.media_type?.startsWith("image/") === true
     });
@@ -99588,7 +99831,7 @@ function linkedResourcePreviews(input) {
 }
 function materializationPreview(input) {
   const linkedAsset = input.item.asset_paths.flatMap((path4) => [path4, path4.startsWith("assets/") ? path4 : `assets/${path4}`]).map((path4) => input.assetsByPath.get(path4)).find((asset) => asset !== undefined && asset.role !== "audit");
-  const url = input.existing?.url ?? (linkedAsset?.content_hash === undefined ? undefined : pathToFileURL3(join61(input.projectRoot, input.materializedAt, linkedAsset.path)).href);
+  const url = input.existing?.url ?? (linkedAsset?.content_hash === undefined ? undefined : pathToFileURL3(join62(input.projectRoot, input.materializedAt, linkedAsset.path)).href);
   return {
     key: linkedAsset?.path ?? input.item.locator,
     preview: {
@@ -100132,7 +100375,7 @@ function renderReviewHtml(candidates, reviewScope, edgePreview, sourceExcerpts,
 }
 function resolveOutputPath(projectRoot, outPath, reviewScope) {
   if (outPath === undefined)
-    return join61(projectRoot, REVIEW_HTML_ROOT, `${reviewScope}.html`);
+    return join62(projectRoot, REVIEW_HTML_ROOT, `${reviewScope}.html`);
   return isAbsolute9(outPath) ? outPath : resolve23(projectRoot, outPath);
 }
 async function writeReviewHtml(input) {
@@ -100145,7 +100388,7 @@ async function writeReviewHtml(input) {
   const sourceExcerpts = await collectReviewSourceExcerpts(input.projectRoot, candidates);
   const resourcePreviews = await collectReviewResourcePreviews(input.projectRoot, candidates);
   const outPath = resolveOutputPath(input.projectRoot, input.out, reviewScope);
-  await mkdir29(dirname36(outPath), { recursive: true });
+  await mkdir29(dirname37(outPath), { recursive: true });
   await writeFile24(outPath, renderReviewHtml(candidates, reviewScope, edgePreview, sourceExcerpts, resourcePreviews), "utf8");
   return {
     path: outPath,
@@ -100560,17 +100803,17 @@ function compactJsonResult(result, verbose) {
 }
 
 // src/project/runLog.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { mkdir as mkdir30, writeFile as writeFile25 } from "node:fs/promises";
-import { dirname as dirname37, join as join62 } from "node:path";
+import { dirname as dirname38, join as join63 } from "node:path";
 var createPhaseRunId = () => {
   const timestamp = new Date().toISOString().replace(/[-:.TZ]/gu, "");
-  return `run_${timestamp}_${randomUUID2().slice(0, 8)}`;
+  return `run_${timestamp}_${randomUUID3().slice(0, 8)}`;
 };
 async function writePhaseRunLog(input) {
-  const relPath = join62(".tmp", "context-runtime", "runs", `${input.runId}.json`);
-  const absPath = join62(input.projectRoot, relPath);
-  await mkdir30(dirname37(absPath), { recursive: true });
+  const relPath = join63(".tmp", "context-runtime", "runs", `${input.runId}.json`);
+  const absPath = join63(input.projectRoot, relPath);
+  await mkdir30(dirname38(absPath), { recursive: true });
   await writeFile25(absPath, `${JSON.stringify({
     run_id: input.runId,
     phase_id: input.phase.id,
@@ -101271,14 +101514,14 @@ init_exitCode();
 import { resolve as resolve24 } from "node:path";
 init_workspace();
 var PROSE_STRUCTURE_BATCH_SCHEMA = "context.prose.structure-batch.v1";
-function isRecord20(value) {
+function isRecord21(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function shellQuote8(value) {
   return /^[A-Za-z0-9._/=-]+$/u.test(value) ? value : `'${value.replace(/'/gu, `'"'"'`)}'`;
 }
 function parseBatchPayload(value) {
-  if (!isRecord20(value) || value.schema !== PROSE_STRUCTURE_BATCH_SCHEMA || !Array.isArray(value.items)) {
+  if (!isRecord21(value) || value.schema !== PROSE_STRUCTURE_BATCH_SCHEMA || !Array.isArray(value.items)) {
     throw new ContextError(ExitCode.UserError, `batch input must match ${PROSE_STRUCTURE_BATCH_SCHEMA}`, {
       category: ErrorCategory.UserInputInvalid,
       next: "Read the current Route action input_schema and provide one phase_id/input pair per pending structure slot."
@@ -101291,7 +101534,7 @@ function parseBatchPayload(value) {
   }
   const seen = new Set;
   return value.items.map((item, index2) => {
-    if (!isRecord20(item) || typeof item.phase_id !== "string" || typeof item.input !== "string") {
+    if (!isRecord21(item) || typeof item.phase_id !== "string" || typeof item.input !== "string") {
       throw new ContextError(ExitCode.UserError, `structure batch items[${index2}] requires phase_id and input`, {
         category: ErrorCategory.UserInputInvalid
       });
@@ -101323,7 +101566,7 @@ function alignPhase(phases, phaseId) {
   return phase;
 }
 function validationSummary(phaseId, input, result) {
-  const counts2 = result.structure_summary_compact !== undefined && isRecord20(result.structure_summary_compact.counts) ? result.structure_summary_compact.counts : undefined;
+  const counts2 = result.structure_summary_compact !== undefined && isRecord21(result.structure_summary_compact.counts) ? result.structure_summary_compact.counts : undefined;
   return {
     phase_id: phaseId,
     input,
@@ -101817,7 +102060,7 @@ init_debugTrace();
 // src/project/workflow/workflowExecutionRuntime.ts
 init_debugTrace();
 import { createHash as createHash26 } from "node:crypto";
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 function digestText2(value, includeTail) {
   const bytes = Buffer.byteLength(value);
   return {
@@ -101967,7 +102210,7 @@ execution scope cleanup failed`, true)
     try {
       receipt = await new Promise((resolve8, reject) => {
         let settled = false;
-        const child = spawn3(process.execPath, [this.cliEntryPath, ...args], {
+        const child = spawn4(process.execPath, [this.cliEntryPath, ...args], {
           cwd: input.cwd,
           env: { ...process.env, ...debugChildEnvironment() },
           stdio: ["ignore", "pipe", "pipe"],
@@ -102332,7 +102575,7 @@ function requirePayloadHeaderField(value, field) {
   return value;
 }
 function parsePayloadLineDecision(value, index2) {
-  if (!isRecord16(value) || typeof value.candidate_id !== "string") {
+  if (!isRecord17(value) || typeof value.candidate_id !== "string") {
     throw new ContextError(ExitCode.UserError, `review payload line ${index2} must contain candidate_id and status`, {
       category: ErrorCategory.UserInputInvalid
     });
@@ -102345,7 +102588,7 @@ function parsePayloadLineDecision(value, index2) {
 function parsePayloadScope(value) {
   if (value === undefined)
     return;
-  if (!isRecord16(value) || typeof value.count !== "number" || !Number.isInteger(value.count) || value.count < 0 || typeof value.ids_sha256 !== "string" || !/^[a-f0-9]{64}$/iu.test(value.ids_sha256)) {
+  if (!isRecord17(value) || typeof value.count !== "number" || !Number.isInteger(value.count) || value.count < 0 || typeof value.ids_sha256 !== "string" || !/^[a-f0-9]{64}$/iu.test(value.ids_sha256)) {
     throw new ContextError(ExitCode.UserError, "review payload scope must contain count and ids_sha256", {
       category: ErrorCategory.UserInputInvalid
     });
@@ -102384,7 +102627,7 @@ function parsePayloadScope(value) {
 }
 function parsePayloadValues(parsed) {
   const first = parsed[0];
-  if (!isRecord16(first)) {
+  if (!isRecord17(first)) {
     throw new ContextError(ExitCode.UserError, "review payload header must be a JSON object", {
       category: ErrorCategory.UserInputInvalid
     });
@@ -103296,7 +103539,7 @@ async function runManagedUntil(input) {
   const resourceReceipts = input.resourceReceiptsReference === undefined ? undefined : await parseWorkflowResourceReceipts(input.resourceReceiptsReference, found.projectRoot);
   const runtime = new WorkspaceExecutionRuntime({
     projectRoot: found.projectRoot,
-    cliEntryPath: fileURLToPath7(input.cliModuleUrl),
+    cliEntryPath: fileURLToPath8(input.cliModuleUrl),
     inProcess: createWorkflowInProcessExecutor()
   });
   let result;
@@ -103441,10 +103684,10 @@ function registerDebugCommands(program2) {
 
 // src/commands/cleanClaudePluginCache.ts
 init_cliFeedback();
-import { existsSync as existsSync39 } from "node:fs";
+import { existsSync as existsSync40 } from "node:fs";
 import { readdir as readdir19, rm as rm16 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join as join63 } from "node:path";
+import { join as join64 } 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";
@@ -103453,7 +103696,7 @@ async function cleanClaudePluginCache(opts = {}) {
   const lines = [];
   let removed = 0;
   let scanned = 0;
-  if (!existsSync39(cacheRoot)) {
+  if (!existsSync40(cacheRoot)) {
     lines.push("· claude plugin cache: missing — nothing to clean");
     return { lines, removed, scanned };
   }
@@ -103461,20 +103704,20 @@ async function cleanClaudePluginCache(opts = {}) {
   for (const mp of marketplaces) {
     if (!mp.isDirectory())
       continue;
-    const mpDir = join63(cacheRoot, mp.name);
+    const mpDir = join64(cacheRoot, mp.name);
     const plugins = await readdir19(mpDir, { withFileTypes: true });
     for (const pl of plugins) {
       if (!pl.isDirectory())
         continue;
-      const plDir = join63(mpDir, pl.name);
+      const plDir = join64(mpDir, pl.name);
       const versions = await readdir19(plDir, { withFileTypes: true });
       for (const ver of versions) {
         if (!ver.isDirectory())
           continue;
         scanned += 1;
-        const verDir = join63(plDir, ver.name);
-        const markerPath = join63(verDir, ORPHAN_MARKER);
-        if (!existsSync39(markerPath))
+        const verDir = join64(plDir, ver.name);
+        const markerPath = join64(verDir, ORPHAN_MARKER);
+        if (!existsSync40(markerPath))
           continue;
         const label3 = `${mp.name}/${pl.name}/${ver.name}`;
         if (opts.dryRun) {
@@ -103505,7 +103748,7 @@ function resolveClaudePluginCacheRoot(opts) {
   if (explicitRoot)
     return explicitRoot;
   const home = opts.home ?? process.env[CLAUDE_PLUGIN_CACHE_HOME_ENV] ?? homedir();
-  return join63(home, ".claude", "plugins", "cache");
+  return join64(home, ".claude", "plugins", "cache");
 }
 async function isEmptyDir(dir) {
   try {
@@ -103531,17 +103774,17 @@ async function runDoctorCleanClaudePluginCache(opts = {}) {
 }
 
 // src/commands/cleanCache.ts
-import { existsSync as existsSync41 } from "node:fs";
+import { existsSync as existsSync42 } from "node:fs";
 import { readdir as readdir20, rm as rm17 } from "node:fs/promises";
-import { join as join67 } from "node:path";
+import { join as join68 } from "node:path";
 
 // src/incremental/cache.ts
-import { basename as basename10, dirname as dirname39, isAbsolute as isAbsolute11, join as join66, resolve as resolve27 } from "node:path";
+import { basename as basename10, dirname as dirname40, isAbsolute as isAbsolute11, join as join67, resolve as resolve27 } from "node:path";
 
 // src/lib/workspaceLayout.ts
 var import_yaml32 = __toESM(require_dist3(), 1);
-import { existsSync as existsSync40, readFileSync as readFileSync8, statSync as statSync2 } from "node:fs";
-import { dirname as dirname38, join as join64, parse as parse7, resolve as resolve26 } from "node:path";
+import { existsSync as existsSync41, readFileSync as readFileSync9, statSync as statSync2 } from "node:fs";
+import { dirname as dirname39, join as join65, parse as parse7, resolve as resolve26 } from "node:path";
 function isDirectorySafe(path4) {
   try {
     return statSync2(path4).isDirectory();
@@ -103550,11 +103793,11 @@ function isDirectorySafe(path4) {
   }
 }
 function hasRootLayoutMarker(dir) {
-  const configPath = join64(dir, "config.yaml");
-  if (!existsSync40(configPath))
+  const configPath = join65(dir, "config.yaml");
+  if (!existsSync41(configPath))
     return false;
   try {
-    const parsed = import_yaml32.default.parse(readFileSync8(configPath, "utf8"));
+    const parsed = import_yaml32.default.parse(readFileSync9(configPath, "utf8"));
     if (!parsed || typeof parsed !== "object")
       return false;
     const workspace = parsed.workspace;
@@ -103567,8 +103810,8 @@ function hasRootLayoutMarker(dir) {
 }
 function findWorkspaceAt(dir) {
   const root2 = resolve26(dir);
-  const embedded = join64(root2, ".context");
-  if (existsSync40(join64(embedded, "config.yaml")) && isDirectorySafe(embedded)) {
+  const embedded = join65(root2, ".context");
+  if (existsSync41(join65(embedded, "config.yaml")) && isDirectorySafe(embedded)) {
     return { ctxDir: embedded, workspaceRoot: root2, layout: "embedded" };
   }
   if (hasRootLayoutMarker(root2)) {
@@ -103585,7 +103828,7 @@ function findNearestWorkspace(startDir = process.cwd()) {
       return found;
     if (dir === root2)
       return null;
-    const parent = dirname38(dir);
+    const parent = dirname39(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -103593,9 +103836,9 @@ function findNearestWorkspace(startDir = process.cwd()) {
 }
 
 // src/lib/userCache.ts
-import { basename as basename9, join as join65 } from "node:path";
+import { basename as basename9, join as join66 } from "node:path";
 function workspaceLocalUserCacheRoot(ctxDir) {
-  return join65(ctxDir, ".tmp", "context-cli");
+  return join66(ctxDir, ".tmp", "context-cli");
 }
 
 // src/incremental/cache.ts
@@ -103605,7 +103848,7 @@ function resolveCachePath(value) {
 }
 function workspaceCacheHome(workspaceRoot) {
   const location = findWorkspaceAt(workspaceRoot);
-  return workspaceLocalUserCacheRoot(location?.ctxDir ?? join66(workspaceRoot, ".context"));
+  return workspaceLocalUserCacheRoot(location?.ctxDir ?? join67(workspaceRoot, ".context"));
 }
 function resolveCacheHome(input = {}) {
   const explicit = input.cacheHome ?? process.env.C4A_CONTEXT_CACHE_HOME;
@@ -103614,24 +103857,24 @@ function resolveCacheHome(input = {}) {
   if (input.workspaceRoot !== undefined)
     return workspaceCacheHome(resolveCachePath(input.workspaceRoot));
   const nearest = findNearestWorkspace(process.cwd());
-  return workspaceLocalUserCacheRoot(nearest?.ctxDir ?? join66(process.cwd(), ".context"));
+  return workspaceLocalUserCacheRoot(nearest?.ctxDir ?? join67(process.cwd(), ".context"));
 }
 
 // src/commands/cleanCache.ts
 async function countFiles2(dir) {
-  if (!existsSync41(dir))
+  if (!existsSync42(dir))
     return 0;
   let count = 0;
   for (const entry of await readdir20(dir, { withFileTypes: true })) {
-    const full = join67(dir, entry.name);
+    const full = join68(dir, entry.name);
     count += entry.isDirectory() ? await countFiles2(full) : 1;
   }
   return count;
 }
 async function inspectAllRetrievalCache() {
   const cacheHome = resolveCacheHome();
-  const cacheRoot = join67(cacheHome, "retrieval");
-  const projectIds = existsSync41(cacheRoot) ? (await readdir20(cacheRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort() : [];
+  const cacheRoot = join68(cacheHome, "retrieval");
+  const projectIds = existsSync42(cacheRoot) ? (await readdir20(cacheRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort() : [];
   const files = await countFiles2(cacheRoot);
   return { cacheRoot, projects: projectIds.length, files, projectIds };
 }
@@ -103649,8 +103892,6 @@ async function cleanAllRetrievalCache() {
 init_errors();
 init_cliFeedback();
 init_exitCode();
-init_workspace();
-init_packageTemplateReview();
 
 // src/project/sourceCommands.ts
 import { readFile as readFile54 } from "node:fs/promises";
@@ -103665,9 +103906,9 @@ init_cliFeedback();
 init_errors();
 init_exitCode();
 import { execFile as execFile6 } from "node:child_process";
-import { existsSync as existsSync42 } from "node:fs";
+import { existsSync as existsSync43 } from "node:fs";
 import { lstat as lstat3, mkdir as mkdir31, readlink as readlink2, realpath as realpath4, rm as rm18, symlink as symlink2 } from "node:fs/promises";
-import { basename as basename11, dirname as dirname40, isAbsolute as isAbsolute12, relative as relative20, resolve as resolve28 } from "node:path";
+import { basename as basename11, dirname as dirname41, isAbsolute as isAbsolute12, relative as relative20, resolve as resolve28 } from "node:path";
 import { promisify as promisify6 } from "node:util";
 init_writeLock();
 var execFileAsync6 = promisify6(execFile6);
@@ -103809,7 +104050,7 @@ async function git2(cwd, args) {
 }
 async function resolveGitRoot2(path4) {
   const root2 = await git2(path4, ["rev-parse", "--show-toplevel"]);
-  if (root2.length === 0 || !existsSync42(root2)) {
+  if (root2.length === 0 || !existsSync43(root2)) {
     throw userInputError3(`local repository path is not a Git checkout: ${path4}`, { path: path4 });
   }
   return realpath4(root2);
@@ -103830,13 +104071,13 @@ async function verifyCheckout(input) {
 }
 async function cloneCheckout(input) {
   const target = resolve28(input.projectRoot, input.target ?? `.tmp/repo/${repositorySlug(input.remote)}-${input.ref.slice(0, 12)}`);
-  if (existsSync42(target)) {
+  if (existsSync43(target)) {
     throw userInputError3(`clone target already exists: ${target}`, {
       target,
       next: `Use local mode with path ${JSON.stringify(target)} after inspecting the existing checkout.`
     });
   }
-  await mkdir31(dirname40(target), { recursive: true });
+  await mkdir31(dirname41(target), { recursive: true });
   const cloneArgs = ["clone", "--no-checkout", "--depth=1", "--filter=blob:none", input.remote, target];
   try {
     await execFileAsync6("git", cloneArgs, { encoding: "utf8", maxBuffer: 4 * 1024 * 1024 });
@@ -103885,7 +104126,7 @@ async function bindLocalAlias(input) {
   const stats = await lstat3(alias).catch(() => null);
   if (stats !== null) {
     if (stats.isSymbolicLink()) {
-      const actual = resolve28(dirname40(alias), await readlink2(alias));
+      const actual = resolve28(dirname41(alias), await readlink2(alias));
       const actualReal = await realpath4(actual).catch(() => null);
       if (actualReal !== null && actualReal === await realpath4(input.checkout))
         return;
@@ -103901,8 +104142,8 @@ async function bindLocalAlias(input) {
       });
     }
   }
-  await mkdir31(dirname40(alias), { recursive: true });
-  await symlink2(relative20(dirname40(alias), input.checkout) || ".", alias);
+  await mkdir31(dirname41(alias), { recursive: true });
+  await symlink2(relative20(dirname41(alias), input.checkout) || ".", alias);
 }
 function selectPhysicalGroup(sources, selector) {
   const direct = selectRepoSources(sources, selector);
@@ -103989,13 +104230,13 @@ async function restoreRepositorySources(input) {
 }
 
 // src/project/sourceDocumentStatus.ts
-import { existsSync as existsSync43 } from "node:fs";
+import { existsSync as existsSync44 } from "node:fs";
 import { readFile as readFile51 } from "node:fs/promises";
-import { join as join69 } from "node:path";
+import { join as join70 } from "node:path";
 
 // src/project/sourceCommandViews.ts
 import { readFile as readFile50 } from "node:fs/promises";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 init_workspace();
 function repoSourceAgentView(source2) {
   return {
@@ -104057,7 +104298,7 @@ async function fileSourceAgentViewWithNextAction(input) {
   };
 }
 function documentSourceManifestPath(source2) {
-  return source2.snapshot?.manifest ?? join68(source2.materializedAt, "manifest.json");
+  return source2.snapshot?.manifest ?? join69(source2.materializedAt, "manifest.json");
 }
 async function fileSourceDocumentSiteHint(input) {
   const detection = await detectDocumentSiteFiles({
@@ -104067,7 +104308,7 @@ async function fileSourceDocumentSiteHint(input) {
   let snapshotConfigured = false;
   const manifest = documentSourceManifestPath(input.source);
   try {
-    const parsed = parseDocumentSnapshotForSource(JSON.parse(await readFile50(join68(input.projectRoot, manifest), "utf8")), input.source.name);
+    const parsed = parseDocumentSnapshotForSource(JSON.parse(await readFile50(join69(input.projectRoot, manifest), "utf8")), input.source.name);
     snapshotConfigured = manifestUsesMdxJsonDocs(parsed);
   } catch {
     snapshotConfigured = false;
@@ -104098,12 +104339,12 @@ async function larkSourceAgentViewWithNextAction(input) {
 
 // src/project/sourceDocumentStatus.ts
 function documentSourceManifestPath2(source2) {
-  return source2.snapshot?.manifest ?? join69(source2.materializedAt, "manifest.json");
+  return source2.snapshot?.manifest ?? join70(source2.materializedAt, "manifest.json");
 }
 async function documentSnapshotState(input) {
   const manifest = documentSourceManifestPath2(input.source);
-  const manifestPath = join69(input.projectRoot, manifest);
-  if (!existsSync43(manifestPath)) {
+  const manifestPath = join70(input.projectRoot, manifest);
+  if (!existsSync44(manifestPath)) {
     return {
       snapshotReady: false,
       state: "needs-capture",
@@ -104181,7 +104422,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((path4) => !existsSync43(join69(input.projectRoot, input.source.materializedAt, path4)));
+    ].find((path4) => !existsSync44(join70(input.projectRoot, input.source.materializedAt, path4)));
     if (missing !== undefined) {
       return {
         snapshotReady: false,
@@ -104253,7 +104494,7 @@ async function inspectDocumentSources(input) {
 // src/project/documentSourceRegistration.ts
 import { createHash as createHash27 } from "node:crypto";
 import { readFile as readFile52, realpath as realpath5 } from "node:fs/promises";
-import { basename as basename12, extname as extname13, isAbsolute as isAbsolute13, join as join70, relative as relative21, resolve as resolve29 } from "node:path";
+import { basename as basename12, extname as extname13, isAbsolute as isAbsolute13, join as join71, relative as relative21, resolve as resolve29 } from "node:path";
 init_atomicWrite();
 init_cliFeedback();
 init_errors();
@@ -104354,7 +104595,7 @@ function assertSafeFileInclude(value) {
 }
 async function readRegistryDocument(projectRoot, registryPath2) {
   try {
-    const content3 = await readFile52(join70(projectRoot, registryPath2), "utf8");
+    const content3 = await readFile52(join71(projectRoot, registryPath2), "utf8");
     return content3.trim().length === 0 ? { sources: [] } : import_yaml33.default.parse(content3);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
@@ -104472,7 +104713,7 @@ async function addFileSourceUnlocked(input) {
     const record2 = entry2;
     return record2.name !== input.name && record2.id !== input.name;
   }), nextEntry];
-  await atomicWriteFile(join70(input.projectRoot, DEFAULT_FILE_SOURCES_REGISTRY_PATH), import_yaml33.default.stringify({ sources: nextSources }));
+  await atomicWriteFile(join71(input.projectRoot, DEFAULT_FILE_SOURCES_REGISTRY_PATH), import_yaml33.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) {
@@ -104528,7 +104769,7 @@ async function addLarkSourceUnlocked(input) {
     const record2 = entry2;
     return record2.name !== input.name && record2.id !== input.name;
   }), nextEntry];
-  await atomicWriteFile(join70(input.projectRoot, DEFAULT_LARK_SOURCES_REGISTRY_PATH), import_yaml33.default.stringify({ sources: nextSources }));
+  await atomicWriteFile(join71(input.projectRoot, DEFAULT_LARK_SOURCES_REGISTRY_PATH), import_yaml33.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) {
@@ -104716,10 +104957,10 @@ async function registerSourceBatch(input) {
 }
 
 // src/project/sourceRemoval.ts
-import { existsSync as existsSync44 } from "node:fs";
+import { existsSync as existsSync45 } from "node:fs";
 import { createHash as createHash28 } from "node:crypto";
 import { readFile as readFile53, readdir as readdir21, rm as rm19 } from "node:fs/promises";
-import { isAbsolute as isAbsolute14, join as join71, relative as relative22, resolve as resolve30, sep as sep6 } from "node:path";
+import { isAbsolute as isAbsolute14, join as join72, relative as relative22, resolve as resolve30, sep as sep6 } from "node:path";
 var import_yaml34 = __toESM(require_dist3(), 1);
 init_atomicWrite();
 init_cliFeedback();
@@ -104758,8 +104999,8 @@ function collectStrings(value, output) {
   }
 }
 async function yamlReferences(input) {
-  const absolutePath = join71(input.projectRoot, input.path);
-  if (!existsSync44(absolutePath))
+  const absolutePath = join72(input.projectRoot, input.path);
+  if (!existsSync45(absolutePath))
     return false;
   const parsed = import_yaml34.default.parse(await readFile53(absolutePath, "utf8"));
   const strings = [];
@@ -104866,8 +105107,8 @@ function removeDocumentEntry(document4, source2) {
 }
 async function registryRemovalWrite(projectRoot, source2) {
   const path4 = registryPath2(source2.type);
-  const absolutePath = join71(projectRoot, path4);
-  const document4 = existsSync44(absolutePath) ? import_yaml34.default.parse(await readFile53(absolutePath, "utf8")) : { sources: [] };
+  const absolutePath = join72(projectRoot, path4);
+  const document4 = existsSync45(absolutePath) ? import_yaml34.default.parse(await readFile53(absolutePath, "utf8")) : { sources: [] };
   return {
     path: absolutePath,
     bytes: import_yaml34.default.stringify(removeDocumentEntry(document4, source2))
@@ -104885,7 +105126,7 @@ function safeManagedMaterializedPath(projectRoot, source2) {
   return absolute;
 }
 function safeManagedManifestPath(projectRoot, source2) {
-  const manifest = source2.manifest ?? join71(source2.materializedAt, "manifest.json");
+  const manifest = source2.manifest ?? join72(source2.materializedAt, "manifest.json");
   if (isAbsolute14(manifest))
     throw unsafeOwnership(source2, manifest);
   const absolute = resolve30(projectRoot, manifest);
@@ -104991,7 +105232,7 @@ async function createRemovalPlan(projectRoot, selector) {
     }
   } else {
     const materializedPath = safeManagedMaterializedPath(projectRoot, source2);
-    if (materializedPath !== undefined && sharedMaterializedBy.length === 0 && existsSync44(materializedPath)) {
+    if (materializedPath !== undefined && sharedMaterializedBy.length === 0 && existsSync45(materializedPath)) {
       absoluteRemovals.push(materializedPath);
       cleanup = {
         mode: "exclusive-materialization",
@@ -105037,9 +105278,9 @@ function publicRemovalResult(plan, action) {
   };
 }
 async function pruneExtractRuntime(projectRoot, source2) {
-  const fingerprintPath = join71(projectRoot, ".tmp/context-runtime/extract/source-fingerprints.json");
+  const fingerprintPath = join72(projectRoot, ".tmp/context-runtime/extract/source-fingerprints.json");
   const removedPhaseIds = new Set;
-  if (existsSync44(fingerprintPath)) {
+  if (existsSync45(fingerprintPath)) {
     const parsed = JSON.parse(await readFile53(fingerprintPath, "utf8"));
     const phases = parsed.phases ?? {};
     const next = Object.fromEntries(Object.entries(phases).filter(([phaseId, raw]) => {
@@ -105054,20 +105295,20 @@ async function pruneExtractRuntime(projectRoot, source2) {
     await atomicWriteFile(fingerprintPath, `${JSON.stringify({ ...parsed, phases: next }, null, 2)}
 `);
   }
-  const symbolPath = join71(projectRoot, ".tmp/context-runtime/extract/source-symbols.json");
-  if (existsSync44(symbolPath)) {
+  const symbolPath = join72(projectRoot, ".tmp/context-runtime/extract/source-symbols.json");
+  if (existsSync45(symbolPath)) {
     const parsed = JSON.parse(await readFile53(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 = join71(projectRoot, ".tmp/context-runtime/extract/candidates");
+  const snapshotRoot = join72(projectRoot, ".tmp/context-runtime/extract/candidates");
   const visit3 = async (directory) => {
-    if (!existsSync44(directory))
+    if (!existsSync45(directory))
       return;
     for (const entry of await readdir21(directory, { withFileTypes: true })) {
-      const path4 = join71(directory, entry.name);
+      const path4 = join72(directory, entry.name);
       if (entry.isDirectory()) {
         await visit3(path4);
         continue;
@@ -105117,7 +105358,7 @@ async function removeProjectSource(input) {
       });
     }
     await applyAtomicFileBatch({
-      transactionRoot: join71(input.projectRoot, ".tmp", "context-runtime", "source-remove-transactions"),
+      transactionRoot: join72(input.projectRoot, ".tmp", "context-runtime", "source-remove-transactions"),
       writes: [plan.registryWrite, ...plan.manifestWrite !== undefined ? [plan.manifestWrite] : []],
       removals: plan.absoluteRemovals
     });
@@ -105515,16 +105756,147 @@ the CLI derives a lowercase path-safe module and rejects duplicate batch identit
   });
 }
 
+// src/cli.ts
+init_debugTrace();
+
+// src/registerProjectLifecycleCommands.ts
+init_cliFeedback();
+init_errors();
+init_workspace();
+init_exitCode();
+function registerProjectInitCommand(program2) {
+  program2.command("init [project-dir]").description("Initialize a project-local context workspace").option("--name <name>", "display/package name override").option("--language <language>", "workspace and starter-template language: en | zh-CN").option("--dev", "initialize with the locally linked @c4a/context SDK").option("--debug", "enable workspace-local command and Agent Graph tracing").option("--allow-nonempty", "after explicit confirmation, preserve existing files and initialize inside a non-empty non-Context directory").action(async (projectDir, options) => {
+    const targetRoot = resolveContextProjectInitTarget(process.cwd(), projectDir);
+    const wasContextWorkspace = isContextProjectRoot(targetRoot);
+    const result = await initContextProject({
+      cwd: process.cwd(),
+      ...projectDir !== undefined ? { projectDir } : {},
+      ...typeof options.name === "string" ? { name: options.name } : {},
+      ...typeof options.language === "string" ? { language: projectLanguage(options.language) } : {},
+      ...options.dev === true ? { dev: true } : {},
+      ...options.debug === true ? { debug: true } : {},
+      ...options.allowNonempty === true ? { allowNonempty: true } : {}
+    });
+    process.stdout.write(formatProjectInitResult(result));
+    if (!wasContextWorkspace) {
+      queueContextRuntimeEvent({
+        cwd: result.projectRoot,
+        kind: "workspace.initialized",
+        properties: {
+          init_mode: result.kept.length > 0 ? "nonempty_existing" : "new",
+          language: result.language,
+          created_file_count: result.created.length
+        }
+      });
+    }
+  });
+}
+function registerProjectStatusCommand(program2) {
+  program2.command("status").description("Print workspace overview and suggested next actions").option("--format <format>", "output format: table | json", "table").option("--view <view>", "with --format json, output view: summary | full", "summary").option("--managed", "use explicit current-conversation managed approval for this status loop").option("--resource-receipts <json-or-@file>", "current-conversation Agent Graph resource read receipts").addOption(new Option("--authority <authority>", "current-conversation scoped authority granted by the user; repeatable").argParser(collectWorkflowAuthorityOption).default([])).action(async (options) => {
+    const rootOptions = program2.opts();
+    const resourceReceiptsReference = typeof options.resourceReceipts === "string" ? options.resourceReceipts : typeof rootOptions.workflowResourceReceipts === "string" ? rootOptions.workflowResourceReceipts : undefined;
+    const resourceReceipts = resourceReceiptsReference !== undefined ? await parseWorkflowResourceReceipts(resourceReceiptsReference, process.cwd()) : undefined;
+    if (await runProjectStatusCommand({
+      cwd: process.cwd(),
+      format: options.format === "json" ? "json" : "table",
+      view: options.view === "full" ? "full" : "summary",
+      managed: options.managed === true,
+      authorities: workflowAuthorities(options.authority),
+      ...resourceReceipts === undefined ? {} : { resourceReceipts },
+      ...resourceReceiptsReference === undefined ? {} : { resourceReceiptsReference },
+      onSuccess: (status) => {
+        queueContextRuntimeEvent({
+          cwd: status.projectRoot,
+          kind: "workspace.active",
+          properties: { workflow_status: status.workflow.status }
+        });
+      }
+    })) {
+      return;
+    }
+    throw new ContextError(ExitCode.WorkspaceStateError, "status requires a context project workspace", {
+      category: ErrorCategory.WorkspaceNotFound
+    });
+  });
+}
+function registerProjectCloseAndBuildCommands(program2) {
+  program2.command("close").description("Close approved project knowledge by deriving structure and running final verification").option("--format <format>", "output format: text | json", "text").action(async (options) => {
+    if (options.format !== "text" && options.format !== "json") {
+      throw new ContextError(ExitCode.UserError, "--format must be text or json", {
+        category: ErrorCategory.UserInputInvalid
+      });
+    }
+    if (await runProjectCloseCommand({
+      cwd: process.cwd(),
+      format: options.format === "json" ? "json" : "text"
+    })) {
+      return;
+    }
+    throw new ContextError(ExitCode.WorkspaceStateError, "close requires a context project workspace", {
+      category: ErrorCategory.WorkspaceNotFound
+    });
+  });
+  program2.command("build").description("Build declared project packages").option("--format <format>", "output format: text | json", "text").option("--verbose", "include per-file build changes in JSON output").action(async (options) => {
+    if (options.format !== "text" && options.format !== "json") {
+      throw new ContextError(ExitCode.UserError, "--format must be text or json", {
+        category: ErrorCategory.UserInputInvalid
+      });
+    }
+    if (await runProjectBuildCommand({
+      cwd: process.cwd(),
+      format: options.format === "json" ? "json" : "text",
+      verbose: options.verbose === true
+    })) {
+      return;
+    }
+    throw new ContextError(ExitCode.WorkspaceStateError, "build requires a context project workspace", {
+      category: ErrorCategory.WorkspaceNotFound
+    });
+  });
+}
+function registerProjectVerifyCommand(program2) {
+  program2.command("verify").description("Validate knowledge workspace").option("--format <format>", "output format: table | json", "table").option("--compact", "return grouped diagnostics without the complete issue list").option("--view <view>", "read a verification view: diagnostics").option("--page-size <n>", "with --view diagnostics, limit returned issues").option("--page-token <token>", "with --view diagnostics, continue pagination").action(async (options) => {
+    if (options.format !== "table" && options.format !== "json") {
+      throw new ContextError(ExitCode.UserError, "--format must be table or json", {
+        category: ErrorCategory.UserInputInvalid
+      });
+    }
+    if (options.view !== undefined && options.view !== "diagnostics") {
+      throw new ContextError(ExitCode.UserError, "--view must be diagnostics", {
+        category: ErrorCategory.UserInputInvalid
+      });
+    }
+    if (options.view === "diagnostics" && options.format !== "json") {
+      throw new ContextError(ExitCode.UserError, "--view diagnostics requires --format json", {
+        category: ErrorCategory.UserInputInvalid
+      });
+    }
+    if (await runProjectVerifyCommand({
+      cwd: process.cwd(),
+      format: options.format === "json" ? "json" : "table",
+      ...options.compact === true ? { compact: true } : {},
+      ...options.view === "diagnostics" ? { view: "diagnostics" } : {},
+      ...typeof options.pageSize === "string" ? { pageSize: options.pageSize } : {},
+      ...typeof options.pageToken === "string" ? { pageToken: options.pageToken } : {}
+    })) {
+      return;
+    }
+    throw new ContextError(ExitCode.WorkspaceStateError, "verify requires a context project workspace", {
+      category: ErrorCategory.WorkspaceNotFound
+    });
+  });
+}
+
 // src/project/pluginInstall.ts
 init_cliFeedback();
 init_errors();
 init_exitCode();
-import { existsSync as existsSync45 } from "node:fs";
+import { existsSync as existsSync46 } from "node:fs";
 import { cp, mkdir as mkdir32, readdir as readdir22, readFile as readFile55, rename as rename5, rm as rm20, writeFile as writeFile27 } from "node:fs/promises";
 import { execFile as execFile7 } from "node:child_process";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname41, join as join72, resolve as resolve32 } from "node:path";
-import { fileURLToPath as fileURLToPath8 } from "node:url";
+import { dirname as dirname42, join as join73, resolve as resolve32 } from "node:path";
+import { fileURLToPath as fileURLToPath9 } from "node:url";
 import { promisify as promisify7 } from "node:util";
 var execFileAsync7 = promisify7(execFile7);
 var MARKETPLACE_NAME = "c4a";
@@ -105563,10 +105935,10 @@ function pluginAgentOption(value) {
 }
 function packageCandidateDirs() {
   const dirs = [];
-  let dir = dirname41(fileURLToPath8(import.meta.url));
+  let dir = dirname42(fileURLToPath9(import.meta.url));
   for (let index2 = 0;index2 < 8; index2++) {
     dirs.push(dir);
-    const parent = dirname41(dir);
+    const parent = dirname42(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -105579,13 +105951,13 @@ function pluginRootCandidates() {
     return [resolve32(envRoot)];
   const candidates = [];
   for (const dir of packageCandidateDirs()) {
-    candidates.push(join72(dir, "plugins"));
-    candidates.push(join72(dir, "dist", "plugins"));
+    candidates.push(join73(dir, "plugins"));
+    candidates.push(join73(dir, "dist", "plugins"));
   }
   return [...new Set(candidates)];
 }
 function isInstallablePluginRoot(root2) {
-  return existsSync45(join72(root2, ".claude-plugin", "marketplace.json")) && existsSync45(join72(root2, ".agents", "plugins", "marketplace.json")) && existsSync45(join72(root2, "claude", ".claude-plugin", "plugin.json")) && existsSync45(join72(root2, "codex", ".codex-plugin", "plugin.json"));
+  return existsSync46(join73(root2, ".claude-plugin", "marketplace.json")) && existsSync46(join73(root2, ".agents", "plugins", "marketplace.json")) && existsSync46(join73(root2, "claude", ".claude-plugin", "plugin.json")) && existsSync46(join73(root2, "codex", ".codex-plugin", "plugin.json"));
 }
 function resolveBundledPluginsRoot() {
   const candidates = pluginRootCandidates();
@@ -105650,14 +106022,14 @@ function failedAgentResult(agent, error) {
   };
 }
 function codexHome() {
-  return process.env.CODEX_HOME?.trim() || join72(homedir2(), ".codex");
+  return process.env.CODEX_HOME?.trim() || join73(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 join72(home, ".claude", "plugins", "cache");
+  return join73(home, ".claude", "plugins", "cache");
 }
 function blockHeader(line) {
   const match = line.match(/^\s*\[([^\]]+)\]\s*$/u);
@@ -105708,7 +106080,7 @@ function pruneLegacyCodexConfigContent(content3) {
 `), removed };
 }
 async function pruneLegacyCodexConfig(dryRun, steps) {
-  const configPath = join72(codexHome(), "config.toml");
+  const configPath = join73(codexHome(), "config.toml");
   const current2 = await readFile55(configPath, "utf8").catch(() => "");
   if (!current2)
     return;
@@ -105725,8 +106097,8 @@ async function pruneLegacyCodexConfig(dryRun, steps) {
   }
 }
 async function pruneCodexPluginCacheForName(pluginName, keepVersion, dryRun, steps) {
-  const cacheRoot = join72(codexHome(), "plugins", "cache", MARKETPLACE_NAME, pluginName);
-  if (!existsSync45(cacheRoot))
+  const cacheRoot = join73(codexHome(), "plugins", "cache", MARKETPLACE_NAME, pluginName);
+  if (!existsSync46(cacheRoot))
     return;
   const versions = (await readdir22(cacheRoot, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory() && entry.name !== keepVersion).map((entry) => entry.name).sort();
   if (versions.length === 0)
@@ -105737,7 +106109,7 @@ async function pruneCodexPluginCacheForName(pluginName, keepVersion, dryRun, ste
     status: dryRun ? "planned" : "ran"
   });
   if (!dryRun)
-    await Promise.all(versions.map((version3) => rm20(join72(cacheRoot, version3), { recursive: true, force: true })));
+    await Promise.all(versions.map((version3) => rm20(join73(cacheRoot, version3), { recursive: true, force: true })));
 }
 async function pruneCodexPluginCache(currentVersion, dryRun, steps) {
   await pruneCodexPluginCacheForName(PLUGIN_NAME, currentVersion, dryRun, steps);
@@ -105754,22 +106126,22 @@ async function isEmptyDir2(dir) {
 }
 async function pruneClaudeOrphanContextCache(dryRun, steps) {
   const cacheRoot = claudePluginCacheRoot();
-  if (!existsSync45(cacheRoot))
+  if (!existsSync46(cacheRoot))
     return;
   const removed = [];
   const marketplaces = await readdir22(cacheRoot, { withFileTypes: true }).catch(() => []);
   for (const marketplace of marketplaces) {
     if (!marketplace.isDirectory())
       continue;
-    const pluginDir = join72(cacheRoot, marketplace.name, PLUGIN_NAME);
-    if (!existsSync45(pluginDir))
+    const pluginDir = join73(cacheRoot, marketplace.name, PLUGIN_NAME);
+    if (!existsSync46(pluginDir))
       continue;
     const versions = await readdir22(pluginDir, { withFileTypes: true }).catch(() => []);
     for (const version3 of versions) {
       if (!version3.isDirectory())
         continue;
-      const versionDir = join72(pluginDir, version3.name);
-      if (!existsSync45(join72(versionDir, ORPHAN_MARKER2)))
+      const versionDir = join73(pluginDir, version3.name);
+      if (!existsSync46(join73(versionDir, ORPHAN_MARKER2)))
         continue;
       removed.push(`${marketplace.name}/${PLUGIN_NAME}/${version3.name}`);
       if (!dryRun) {
@@ -105779,7 +106151,7 @@ async function pruneClaudeOrphanContextCache(dryRun, steps) {
     if (!dryRun && await isEmptyDir2(pluginDir)) {
       await rm20(pluginDir, { recursive: true, force: true });
     }
-    const marketplaceDir = join72(cacheRoot, marketplace.name);
+    const marketplaceDir = join73(cacheRoot, marketplace.name);
     if (!dryRun && await isEmptyDir2(marketplaceDir)) {
       await rm20(marketplaceDir, { recursive: true, force: true });
     }
@@ -105796,12 +106168,12 @@ async function pruneClaudeLegacyPluginCache(dryRun, steps) {
   if (LEGACY_PLUGIN_NAMES.length === 0)
     return;
   const cacheRoot = claudePluginCacheRoot();
-  if (!existsSync45(cacheRoot))
+  if (!existsSync46(cacheRoot))
     return;
   const removed = [];
   for (const pluginName of LEGACY_PLUGIN_NAMES) {
-    const pluginDir = join72(cacheRoot, MARKETPLACE_NAME, pluginName);
-    if (!existsSync45(pluginDir))
+    const pluginDir = join73(cacheRoot, MARKETPLACE_NAME, pluginName);
+    if (!existsSync46(pluginDir))
       continue;
     removed.push(`${MARKETPLACE_NAME}/${pluginName}`);
     if (!dryRun) {
@@ -105817,11 +106189,11 @@ async function pruneClaudeLegacyPluginCache(dryRun, steps) {
   }
 }
 async function pruneClaudeSupersededContextCache(root2, dryRun, steps) {
-  const manifest = await readFile55(join72(root2, "claude", ".claude-plugin", "plugin.json"), "utf8").then((content3) => JSON.parse(content3)).catch(() => null);
+  const manifest = await readFile55(join73(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 = join72(claudePluginCacheRoot(), MARKETPLACE_NAME, PLUGIN_NAME);
+  const pluginDir = join73(claudePluginCacheRoot(), MARKETPLACE_NAME, PLUGIN_NAME);
   const staleVersions = (await readdir22(pluginDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory() && entry.name !== currentVersion).map((entry) => entry.name);
   if (staleVersions.length === 0)
     return;
@@ -105831,7 +106203,7 @@ async function pruneClaudeSupersededContextCache(root2, dryRun, steps) {
     status: dryRun ? "planned" : "ran"
   });
   if (!dryRun) {
-    await Promise.all(staleVersions.map((version3) => rm20(join72(pluginDir, version3), { recursive: true, force: true })));
+    await Promise.all(staleVersions.map((version3) => rm20(join73(pluginDir, version3), { recursive: true, force: true })));
   }
 }
 function enableCodexPluginConfig(content3) {
@@ -105895,8 +106267,8 @@ source = ${JSON.stringify(root2)}
 `;
 }
 async function ensureCodexPluginEnabled() {
-  const configPath = join72(codexHome(), "config.toml");
-  await mkdir32(dirname41(configPath), { recursive: true });
+  const configPath = join73(codexHome(), "config.toml");
+  await mkdir32(dirname42(configPath), { recursive: true });
   const current2 = await readFile55(configPath, "utf8").catch(() => "");
   const next = enableCodexPluginConfig(current2);
   if (next !== current2) {
@@ -105904,8 +106276,8 @@ async function ensureCodexPluginEnabled() {
   }
 }
 async function ensureCodexLocalMarketplace(root2) {
-  const configPath = join72(codexHome(), "config.toml");
-  await mkdir32(dirname41(configPath), { recursive: true });
+  const configPath = join73(codexHome(), "config.toml");
+  await mkdir32(dirname42(configPath), { recursive: true });
   const current2 = await readFile55(configPath, "utf8").catch(() => "");
   const next = upsertCodexLocalMarketplaceConfig(current2, root2);
   if (next !== current2) {
@@ -105913,7 +106285,7 @@ async function ensureCodexLocalMarketplace(root2) {
   }
 }
 async function codexPluginVersion(root2) {
-  const manifestPath = join72(root2, "codex", ".codex-plugin", "plugin.json");
+  const manifestPath = join73(root2, "codex", ".codex-plugin", "plugin.json");
   const manifest = JSON.parse(await readFile55(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}`);
@@ -105921,10 +106293,10 @@ async function codexPluginVersion(root2) {
   return manifest.version;
 }
 function codexPluginCacheDir(version3) {
-  return join72(codexHome(), "plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME, version3);
+  return join73(codexHome(), "plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME, version3);
 }
 async function materializeCodexPluginCache(root2, version3, dryRun, steps) {
-  const source2 = join72(root2, "codex");
+  const source2 = join73(root2, "codex");
   const target = codexPluginCacheDir(version3);
   steps.push({
     agent: "codex",
@@ -105933,12 +106305,12 @@ async function materializeCodexPluginCache(root2, version3, dryRun, steps) {
   });
   if (dryRun)
     return;
-  await mkdir32(dirname41(target), { recursive: true });
+  await mkdir32(dirname42(target), { recursive: true });
   const temporary = `${target}.tmp-${process.pid}-${Date.now()}`;
   const previous3 = `${target}.previous-${process.pid}-${Date.now()}`;
   await rm20(temporary, { recursive: true, force: true });
   await cp(source2, temporary, { recursive: true, force: true });
-  const hadPrevious = existsSync45(target);
+  const hadPrevious = existsSync46(target);
   try {
     if (hadPrevious)
       await rename5(target, previous3);
@@ -105947,7 +106319,7 @@ async function materializeCodexPluginCache(root2, version3, dryRun, steps) {
       await rm20(previous3, { recursive: true, force: true });
   } catch (error) {
     await rm20(temporary, { recursive: true, force: true });
-    if (hadPrevious && !existsSync45(target) && existsSync45(previous3))
+    if (hadPrevious && !existsSync46(target) && existsSync46(previous3))
       await rename5(previous3, target);
     throw error;
   }
@@ -105982,12 +106354,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 ${shellQuote9(join72(codexHome(), "config.toml"))} registers local marketplace ${shellQuote9(MARKETPLACE_NAME)}`,
+    command: `ensure ${shellQuote9(join73(codexHome(), "config.toml"))} registers local marketplace ${shellQuote9(MARKETPLACE_NAME)}`,
     status: dryRun ? "planned" : "ran"
   });
   steps.push({
     agent: "codex",
-    command: `ensure ${shellQuote9(join72(codexHome(), "config.toml"))} enables ${shellQuote9(PLUGIN_ID)}`,
+    command: `ensure ${shellQuote9(join73(codexHome(), "config.toml"))} enables ${shellQuote9(PLUGIN_ID)}`,
     status: dryRun ? "planned" : "ran"
   });
   if (dryRun) {
@@ -106098,8 +106470,75 @@ function formatPluginInstallResult(result) {
   });
 }
 
+// src/registerPluginCommands.ts
+function registerPluginCommands(program2) {
+  const plugin = program2.command("plugin").description("Install or inspect global Context agent plugins");
+  plugin.command("path").description("Print the bundled plugin marketplace root used by `context plugin install`").action(async () => {
+    process.stdout.write(formatPluginPathResult(await runPluginPathCommand()));
+  });
+  plugin.command("status").description("Inspect the bundled plugin marketplace root and global agent availability").option("--agent <agent>", "agent target: claude | codex | all", "all").action(async (options) => {
+    const agent = pluginAgentOption(options.agent);
+    process.stdout.write(formatPluginStatusResult(await runPluginStatusCommand({ agent })));
+  });
+  plugin.command("install").description("Install the bundled Context plugin globally for Claude and/or Codex").option("--agent <agent>", "agent target: claude | codex | all", "all").option("--dry-run", "Print install commands without mutating global agent config").action(async (options) => {
+    const agent = pluginAgentOption(options.agent);
+    const result = await runPluginInstallCommand({
+      agent,
+      dryRun: options.dryRun === true
+    });
+    process.stdout.write(formatPluginInstallResult(result));
+  });
+}
+
+// src/registerPackageCommands.ts
+init_cliFeedback();
+init_errors();
+init_packageTemplateReview();
+init_workspace();
+init_exitCode();
+function registerPackageCommands(program2) {
+  const packageCommand = program2.command("package").description("Inspect or resolve package output configuration");
+  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)) {
+      throw new ContextError(ExitCode.UserError, "provide one package name or --all", { category: ErrorCategory.UserInputInvalid });
+    }
+    if (options.format !== "text" && options.format !== "json") {
+      throw new ContextError(ExitCode.UserError, "--format must be text or json", {
+        category: ErrorCategory.UserInputInvalid
+      });
+    }
+    const found = findContextProjectRoot(process.cwd());
+    if (!found) {
+      throw new ContextError(ExitCode.WorkspaceStateError, "package template acceptance requires a context project workspace", { category: ErrorCategory.WorkspaceNotFound });
+    }
+    const result = await acceptStarterPackageTemplates({
+      projectRoot: found.projectRoot,
+      ...packageName === undefined ? {} : { packageNames: [packageName] }
+    });
+    if (options.format === "json") {
+      process.stdout.write(`${JSON.stringify({
+        action: "package-template-accepted",
+        ...result,
+        next_action: {
+          kind: "reevaluate-workspace",
+          command: "context status --format json"
+        }
+      }, null, 2)}
+`);
+    } else {
+      process.stdout.write(formatFeedback({
+        symbol: "✓",
+        action: "accepted",
+        subject: result.accepted.join(", ") || "package templates",
+        headline: "starter package template",
+        body: result.alreadyResolved.length === 0 ? [] : [`already resolved: ${result.alreadyResolved.join(", ")}`]
+      }));
+    }
+  });
+}
+
 // src/cli.ts
-init_debugTrace();
 var TOP_LEVEL_COMMANDS = new Set([
   "init",
   "plugin",
@@ -106135,14 +106574,14 @@ function inferErrorCategory(message) {
 }
 function readPackageVersion() {
   try {
-    let dir = dirname42(fileURLToPath9(import.meta.url));
+    let dir = dirname43(fileURLToPath10(import.meta.url));
     for (let i2 = 0;i2 < 8; i2++) {
-      const pkg = join73(dir, "package.json");
-      if (existsSync46(pkg)) {
-        const parsed = JSON.parse(readFileSync9(pkg, "utf8"));
+      const pkg = join74(dir, "package.json");
+      if (existsSync47(pkg)) {
+        const parsed = JSON.parse(readFileSync10(pkg, "utf8"));
         return parsed.version ?? "unknown";
       }
-      const parent = dirname42(dir);
+      const parent = dirname43(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -106152,21 +106591,21 @@ function readPackageVersion() {
 }
 function readQuickstartPath() {
   try {
-    let dir = dirname42(fileURLToPath9(import.meta.url));
+    let dir = dirname43(fileURLToPath10(import.meta.url));
     for (let i2 = 0;i2 < 8; i2++) {
-      const candidate = join73(dir, "docs", "quickstart.md");
-      if (existsSync46(candidate))
+      const candidate = join74(dir, "docs", "quickstart.md");
+      if (existsSync47(candidate))
         return candidate;
-      const pkg = join73(dir, "package.json");
-      if (existsSync46(pkg))
+      const pkg = join74(dir, "package.json");
+      if (existsSync47(pkg))
         return candidate;
-      const parent = dirname42(dir);
+      const parent = dirname43(dir);
       if (parent === dir)
         break;
       dir = parent;
     }
   } catch {}
-  return join73(dirname42(fileURLToPath9(import.meta.url)), "docs", "quickstart.md");
+  return join74(dirname43(fileURLToPath10(import.meta.url)), "docs", "quickstart.md");
 }
 var GREEN = "\x1B[32m";
 var RESET = "\x1B[0m";
@@ -106251,94 +106690,12 @@ function createCliProgram() {
   });
   const baseHelpInformation = program2.helpInformation.bind(program2);
   program2.helpInformation = () => `${headerHelpText()}${baseHelpInformation()}${quickstartHelpText()}`;
-  program2.command("init [project-dir]").description("Initialize a project-local context workspace").option("--name <name>", "display/package name override").option("--language <language>", "workspace and starter-template language: en | zh-CN").option("--dev", "initialize with the locally linked @c4a/context SDK").option("--debug", "enable workspace-local command and Agent Graph tracing").option("--allow-nonempty", "after explicit confirmation, preserve existing files and initialize inside a non-empty non-Context directory").action(async (projectDir, options) => {
-    const result = await initContextProject({
-      cwd: process.cwd(),
-      ...projectDir !== undefined ? { projectDir } : {},
-      ...typeof options.name === "string" ? { name: options.name } : {},
-      ...typeof options.language === "string" ? { language: projectLanguage(options.language) } : {},
-      ...options.dev === true ? { dev: true } : {},
-      ...options.debug === true ? { debug: true } : {},
-      ...options.allowNonempty === true ? { allowNonempty: true } : {}
-    });
-    process.stdout.write(formatProjectInitResult(result));
-  });
-  const plugin = program2.command("plugin").description("Install or inspect global Context agent plugins");
+  registerProjectInitCommand(program2);
+  registerPluginCommands(program2);
   registerDebugCommands(program2);
-  plugin.command("path").description("Print the bundled plugin marketplace root used by `context plugin install`").action(async () => {
-    process.stdout.write(formatPluginPathResult(await runPluginPathCommand()));
-  });
-  plugin.command("status").description("Inspect the bundled plugin marketplace root and global agent availability").option("--agent <agent>", "agent target: claude | codex | all", "all").action(async (options) => {
-    const agent = pluginAgentOption(options.agent);
-    process.stdout.write(formatPluginStatusResult(await runPluginStatusCommand({ agent })));
-  });
-  plugin.command("install").description("Install the bundled Context plugin globally for Claude and/or Codex").option("--agent <agent>", "agent target: claude | codex | all", "all").option("--dry-run", "Print install commands without mutating global agent config").action(async (options) => {
-    const agent = pluginAgentOption(options.agent);
-    const result = await runPluginInstallCommand({
-      agent,
-      dryRun: options.dryRun === true
-    });
-    process.stdout.write(formatPluginInstallResult(result));
-  });
   registerContextWorkflowResourceCommands(program2);
-  const packageCommand = program2.command("package").description("Inspect or resolve package output configuration");
-  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)) {
-      throw new ContextError(ExitCode.UserError, "provide one package name or --all", { category: ErrorCategory.UserInputInvalid });
-    }
-    if (options.format !== "text" && options.format !== "json") {
-      throw new ContextError(ExitCode.UserError, "--format must be text or json", {
-        category: ErrorCategory.UserInputInvalid
-      });
-    }
-    const found = findContextProjectRoot(process.cwd());
-    if (!found) {
-      throw new ContextError(ExitCode.WorkspaceStateError, "package template acceptance requires a context project workspace", { category: ErrorCategory.WorkspaceNotFound });
-    }
-    const result = await acceptStarterPackageTemplates({
-      projectRoot: found.projectRoot,
-      ...packageName === undefined ? {} : { packageNames: [packageName] }
-    });
-    if (options.format === "json") {
-      process.stdout.write(`${JSON.stringify({
-        action: "package-template-accepted",
-        ...result,
-        next_action: {
-          kind: "reevaluate-workspace",
-          command: "context status --format json"
-        }
-      }, null, 2)}
-`);
-    } else {
-      process.stdout.write(formatFeedback({
-        symbol: "✓",
-        action: "accepted",
-        subject: result.accepted.join(", ") || "package templates",
-        headline: "starter package template",
-        body: result.alreadyResolved.length === 0 ? [] : [`already resolved: ${result.alreadyResolved.join(", ")}`]
-      }));
-    }
-  });
-  program2.command("status").description("Print workspace overview and suggested next actions").option("--format <format>", "output format: table | json", "table").option("--view <view>", "with --format json, output view: summary | full", "summary").option("--managed", "use explicit current-conversation managed approval for this status loop").option("--resource-receipts <json-or-@file>", "current-conversation Agent Graph resource read receipts").addOption(new Option("--authority <authority>", "current-conversation scoped authority granted by the user; repeatable").argParser(collectWorkflowAuthorityOption).default([])).action(async (options) => {
-    const rootOptions = program2.opts();
-    const resourceReceiptsReference = typeof options.resourceReceipts === "string" ? options.resourceReceipts : typeof rootOptions.workflowResourceReceipts === "string" ? rootOptions.workflowResourceReceipts : undefined;
-    const resourceReceipts = resourceReceiptsReference !== undefined ? await parseWorkflowResourceReceipts(resourceReceiptsReference, process.cwd()) : undefined;
-    if (await runProjectStatusCommand({
-      cwd: process.cwd(),
-      format: options.format === "json" ? "json" : "table",
-      view: options.view === "full" ? "full" : "summary",
-      managed: options.managed === true,
-      authorities: workflowAuthorities(options.authority),
-      ...resourceReceipts === undefined ? {} : { resourceReceipts },
-      ...resourceReceiptsReference === undefined ? {} : { resourceReceiptsReference }
-    })) {
-      return;
-    }
-    throw new ContextError(ExitCode.WorkspaceStateError, "status requires a context project workspace", {
-      category: ErrorCategory.WorkspaceNotFound
-    });
-  });
+  registerPackageCommands(program2);
+  registerProjectStatusCommand(program2);
   registerProjectRunCommand(program2, import.meta.url);
   const review = program2.command("review").description("Review draft project candidates and apply approval decisions");
   review.command("html [collection]").description("Render a self-contained local review HTML page").option("--all", "review all draft candidates across internal collections").option("--out <file>", "output HTML path, defaults to .tmp/context-runtime/review/<collection>.html").option("--open", "open the generated HTML with the system default browser").option("--format <format>", "output format: text | json", "text").action(async (collection, options) => {
@@ -106486,70 +106843,9 @@ function createCliProgram() {
       format: options.format === "json" ? "json" : "text"
     });
   });
-  program2.command("close").description("Close approved project knowledge by deriving structure and running final verification").option("--format <format>", "output format: text | json", "text").action(async (options) => {
-    if (options.format !== "text" && options.format !== "json") {
-      throw new ContextError(ExitCode.UserError, "--format must be text or json", {
-        category: ErrorCategory.UserInputInvalid
-      });
-    }
-    if (await runProjectCloseCommand({
-      cwd: process.cwd(),
-      format: options.format === "json" ? "json" : "text"
-    })) {
-      return;
-    }
-    throw new ContextError(ExitCode.WorkspaceStateError, "close requires a context project workspace", {
-      category: ErrorCategory.WorkspaceNotFound
-    });
-  });
-  program2.command("build").description("Build declared project packages").option("--format <format>", "output format: text | json", "text").option("--verbose", "include per-file build changes in JSON output").action(async (options) => {
-    if (options.format !== "text" && options.format !== "json") {
-      throw new ContextError(ExitCode.UserError, "--format must be text or json", {
-        category: ErrorCategory.UserInputInvalid
-      });
-    }
-    if (await runProjectBuildCommand({
-      cwd: process.cwd(),
-      format: options.format === "json" ? "json" : "text",
-      verbose: options.verbose === true
-    })) {
-      return;
-    }
-    throw new ContextError(ExitCode.WorkspaceStateError, "build requires a context project workspace", {
-      category: ErrorCategory.WorkspaceNotFound
-    });
-  });
+  registerProjectCloseAndBuildCommands(program2);
   registerProjectSourceCommands(program2);
-  program2.command("verify").description("Validate knowledge workspace").option("--format <format>", "output format: table | json", "table").option("--compact", "return grouped diagnostics without the complete issue list").option("--view <view>", "read a verification view: diagnostics").option("--page-size <n>", "with --view diagnostics, limit returned issues").option("--page-token <token>", "with --view diagnostics, continue pagination").action(async (options) => {
-    if (options.format !== "table" && options.format !== "json") {
-      throw new ContextError(ExitCode.UserError, "--format must be table or json", {
-        category: ErrorCategory.UserInputInvalid
-      });
-    }
-    if (options.view !== undefined && options.view !== "diagnostics") {
-      throw new ContextError(ExitCode.UserError, "--view must be diagnostics", {
-        category: ErrorCategory.UserInputInvalid
-      });
-    }
-    if (options.view === "diagnostics" && options.format !== "json") {
-      throw new ContextError(ExitCode.UserError, "--view diagnostics requires --format json", {
-        category: ErrorCategory.UserInputInvalid
-      });
-    }
-    if (await runProjectVerifyCommand({
-      cwd: process.cwd(),
-      format: options.format === "json" ? "json" : "table",
-      ...options.compact === true ? { compact: true } : {},
-      ...options.view === "diagnostics" ? { view: "diagnostics" } : {},
-      ...typeof options.pageSize === "string" ? { pageSize: options.pageSize } : {},
-      ...typeof options.pageToken === "string" ? { pageToken: options.pageToken } : {}
-    })) {
-      return;
-    }
-    throw new ContextError(ExitCode.WorkspaceStateError, "verify requires a context project workspace", {
-      category: ErrorCategory.WorkspaceNotFound
-    });
-  });
+  registerProjectVerifyCommand(program2);
   const cleanCacheAction = async (options) => {
     const dryRun = options.dryRun === true;
     await runDoctorCleanClaudePluginCache({ dryRun });
@@ -106581,10 +106877,12 @@ function createCliProgram() {
   return program2;
 }
 async function cli_main(argv = process.argv) {
-  await withDebugCliInvocation(argv, async () => {
-    assertKnownTopLevelCommand(argv);
-    const program2 = createCliProgram();
-    await program2.parseAsync(argv);
+  await withContextRuntimeEventDelivery(async () => {
+    await withDebugCliInvocation(argv, async () => {
+      assertKnownTopLevelCommand(argv);
+      const program2 = createCliProgram();
+      await program2.parseAsync(argv);
+    });
   });
 }
 function isDirectCliInvocation(metaUrl, argv1) {