@mrciphersmith/keryx 0.3.132 → 0.3.133

package/dist/core.js

@@ -16164,7 +16164,7 @@ var init_guard = __esm(() => {
 
 // src/lib/keryx-home.ts
 import os2 from "os";
-import path58 from "path";
+import path59 from "path";
 function resolveKeryxHomeDir(env, homeDir) {
   if (homeDir !== undefined)
     return homeDir;
@@ -16173,24 +16173,24 @@ function resolveKeryxHomeDir(env, homeDir) {
 }
 function userStoreRoot(env = process.env, homeDir) {
   const home = resolveKeryxHomeDir(env, homeDir);
-  return path58.join(home, USER_STORE_DIRNAME);
+  return path59.join(home, USER_STORE_DIRNAME);
 }
 function userStorePaths(env = process.env, homeDir) {
   const root = userStoreRoot(env, homeDir);
-  const state = path58.join(root, "state");
+  const state = path59.join(root, "state");
   return {
     root,
-    skills: path58.join(root, "skills"),
-    agents: path58.join(root, "agents"),
-    memory: path58.join(root, "memory"),
-    learning: path58.join(root, "learning"),
-    learningPatterns: path58.join(root, "learning", "patterns"),
-    bundles: path58.join(root, "bundles"),
-    appliedState: path58.join(root, "bundles", "applied-state.json"),
-    hooksJson: path58.join(root, "hooks.json"),
-    externalSkillImports: path58.join(root, "skills", "external-imports.json"),
+    skills: path59.join(root, "skills"),
+    agents: path59.join(root, "agents"),
+    memory: path59.join(root, "memory"),
+    learning: path59.join(root, "learning"),
+    learningPatterns: path59.join(root, "learning", "patterns"),
+    bundles: path59.join(root, "bundles"),
+    appliedState: path59.join(root, "bundles", "applied-state.json"),
+    hooksJson: path59.join(root, "hooks.json"),
+    externalSkillImports: path59.join(root, "skills", "external-imports.json"),
     state,
-    externalImportsKey: path58.join(state, "external-imports.key")
+    externalImportsKey: path59.join(state, "external-imports.key")
   };
 }
 var USER_STORE_DIRNAME = ".keryx";
@@ -16297,12 +16297,12 @@ var init_types2 = __esm(() => {
 
 // src/memory/store.ts
 import { lstat as lstat8, readdir as readdir13, readFile as readFile28 } from "fs/promises";
-import path59 from "path";
+import path60 from "path";
 function decodeStrictUtf8(bytes) {
   return STRICT_UTF8_DECODER.decode(bytes);
 }
 function memoryRoot(cwd) {
-  return path59.join(cwd, ".metaproject", "memory");
+  return path60.join(cwd, ".metaproject", "memory");
 }
 function memoryRootFor(scope, cwd, env = process.env, homeDir) {
   return scope === "user" ? userStorePaths(env, homeDir).memory : memoryRoot(cwd);
@@ -16311,7 +16311,7 @@ async function collectEntries(cwd) {
   const root = memoryRoot(cwd);
   const entries = [];
   for (const { type, folder } of MEMORY_TYPES) {
-    const dir = path59.join(root, folder);
+    const dir = path60.join(root, folder);
     let dirStats;
     try {
       dirStats = await lstat8(dir);
@@ -16325,7 +16325,7 @@ async function collectEntries(cwd) {
       if (!name.endsWith(".md")) {
         continue;
       }
-      const abs = path59.join(dir, name);
+      const abs = path60.join(dir, name);
       let stats;
       try {
         stats = await lstat8(abs);
@@ -16360,7 +16360,7 @@ async function collectEntriesStrict(root) {
     return { status: "incomplete", entries: [], problems: [{ path: ".", reason: "not-a-regular-file" }] };
   }
   for (const { type, folder } of MEMORY_TYPES) {
-    const dir = path59.join(root, folder);
+    const dir = path60.join(root, folder);
     let dirStats;
     try {
       dirStats = await lstat8(dir);
@@ -16384,7 +16384,7 @@ async function collectEntriesStrict(root) {
     }
     for (const name of names) {
       const relativePath = `${folder}/${name}`;
-      const abs = path59.join(dir, name);
+      const abs = path60.join(dir, name);
       let entryStats;
       try {
         entryStats = await lstat8(abs);
@@ -16476,7 +16476,7 @@ async function collectUnexpectedMarkdown(dir, relativeDir, problems) {
     return;
   }
   for (const name of names) {
-    const abs = path59.join(dir, name);
+    const abs = path60.join(dir, name);
     const relativePath = `${relativeDir}/${name}`;
     let stats;
     try {
@@ -16510,7 +16510,7 @@ async function collectUnexpectedTopLevel(root, problems) {
     if (MEMORY_TYPE_FOLDERS.has(name)) {
       continue;
     }
-    const abs = path59.join(root, name);
+    const abs = path60.join(root, name);
     let stats;
     try {
       stats = await lstat8(abs);
@@ -16879,9 +16879,9 @@ var init_validation = __esm(() => {
 });
 
 // src/memory/config.ts
-import path63 from "path";
+import path64 from "path";
 function memoryConfigPath(cwd) {
-  return path63.join(cwd, ".metaproject", "memory.config.json");
+  return path64.join(cwd, ".metaproject", "memory.config.json");
 }
 async function loadMemoryConfig(cwd) {
   const file = memoryConfigPath(cwd);
@@ -17009,9 +17009,9 @@ function titleSimilarity(a, b) {
 // src/memory/report.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { access as access2, mkdir as mkdir10, readdir as readdir15, rename as rename4, rm as rm4, stat as stat10, writeFile as writeFile7 } from "fs/promises";
-import path64 from "path";
+import path65 from "path";
 function runtimeRoot(cwd) {
-  return path64.join(cwd, ".metaproject", "runtime", "memory");
+  return path65.join(cwd, ".metaproject", "runtime", "memory");
 }
 function bounded(value, maximum) {
   if (Buffer.byteLength(value, "utf8") <= maximum)
@@ -17048,8 +17048,8 @@ function formatScope(scopes) {
   return parts.length > 0 ? parts.join(", ") : null;
 }
 function relativeMemoryPath(value) {
-  const normalized = value.split(path64.sep).join("/");
-  if (!normalized || path64.isAbsolute(value) || normalized.startsWith("../") || normalized.includes("/../")) {
+  const normalized = value.split(path65.sep).join("/");
+  if (!normalized || path65.isAbsolute(value) || normalized.startsWith("../") || normalized.includes("/../")) {
     throw new Error("Memory report paths must be memory-root-relative");
   }
   return bounded(normalized, MAX_PATH_LENGTH);
@@ -17156,7 +17156,7 @@ function validateMemorySearchReport(value) {
       for (const key of Object.keys(item))
         if (!allowedResult.has(key))
           errors.push(`unexpected result property: ${key}`);
-      if (typeof item.path !== "string" || !item.path || item.path.length > MAX_PATH_LENGTH || path64.isAbsolute(item.path) || item.path.includes(".."))
+      if (typeof item.path !== "string" || !item.path || item.path.length > MAX_PATH_LENGTH || path65.isAbsolute(item.path) || item.path.includes(".."))
         errors.push("result path is invalid");
       if (typeof item.title !== "string" || item.title.length > MAX_TITLE_LENGTH)
         errors.push("result title is invalid");
@@ -17243,26 +17243,26 @@ class MemoryReportStore {
       throw new Error("Invalid memory report run ID");
     const report = renderMemorySearchReport({ runId, generatedAt: this.clock(), search: input.search, filters: input.filters ?? {} });
     const root = runtimeRoot(input.cwd);
-    const searchRoot = path64.join(root, "search");
-    const tempRoot = path64.join(root, "tmp");
-    const destination = path64.join(searchRoot, runId);
+    const searchRoot = path65.join(root, "search");
+    const tempRoot = path65.join(root, "tmp");
+    const destination = path65.join(searchRoot, runId);
     if (await exists(destination))
       throw new Error(`Memory report run already exists: ${runId}`);
     await mkdir10(searchRoot, { recursive: true });
     await mkdir10(tempRoot, { recursive: true });
     const staleBefore = this.clock().getTime() - STALE_STAGING_MS;
     for (const name of await readdir15(tempRoot)) {
-      const candidate = path64.join(tempRoot, name);
+      const candidate = path65.join(tempRoot, name);
       if ((await stat10(candidate)).mtimeMs <= staleBefore)
         await rm4(candidate, { recursive: true, force: true });
     }
-    const staging = path64.join(tempRoot, `${runId}.${randomUUID2()}`);
+    const staging = path65.join(tempRoot, `${runId}.${randomUUID2()}`);
     try {
       await mkdir10(staging);
       await Promise.all([
-        writeFile7(path64.join(staging, "report.json"), `${JSON.stringify(report, null, 2)}
+        writeFile7(path65.join(staging, "report.json"), `${JSON.stringify(report, null, 2)}
 `, "utf8"),
-        writeFile7(path64.join(staging, "report.md"), renderMemorySearchReportMarkdown(report), "utf8")
+        writeFile7(path65.join(staging, "report.md"), renderMemorySearchReportMarkdown(report), "utf8")
       ]);
       if (await exists(destination))
         throw new Error(`Memory report run already exists: ${runId}`);
@@ -17273,8 +17273,8 @@ class MemoryReportStore {
     }
     return {
       runId,
-      markdownPath: path64.relative(input.cwd, path64.join(destination, "report.md")),
-      jsonPath: path64.relative(input.cwd, path64.join(destination, "report.json"))
+      markdownPath: path65.relative(input.cwd, path65.join(destination, "report.md")),
+      jsonPath: path65.relative(input.cwd, path65.join(destination, "report.json"))
     };
   }
 }
@@ -17531,22 +17531,22 @@ var init_search = __esm(() => {
 });
 
 // src/gdgraph/data-dir.ts
-import path78 from "path";
+import path79 from "path";
 function gdgraphDataDir(projectRoot, dataDir) {
-  return dataDir ?? path78.join(projectRoot, ".metaproject", "data", "gdgraph");
+  return dataDir ?? path79.join(projectRoot, ".metaproject", "data", "gdgraph");
 }
 function gdgraphStorageDir(projectRoot, dataDir) {
-  return path78.join(gdgraphDataDir(projectRoot, dataDir), "storage");
+  return path79.join(gdgraphDataDir(projectRoot, dataDir), "storage");
 }
 function gdgraphArtifactsDir(projectRoot, dataDir) {
-  return path78.join(gdgraphDataDir(projectRoot, dataDir), "artifacts");
+  return path79.join(gdgraphDataDir(projectRoot, dataDir), "artifacts");
 }
 var init_data_dir = () => {};
 
 // src/gdgraph/config.ts
-import path79 from "path";
+import path80 from "path";
 function gdgraphConfigPath(cwd) {
-  return path79.join(cwd, ".metaproject", "gdgraph.config.json");
+  return path80.join(cwd, ".metaproject", "gdgraph.config.json");
 }
 function mergeGdgraphConfig(parsed) {
   const base = DEFAULT_GDGRAPH_CONFIG;
@@ -18151,7 +18151,7 @@ var init_extract = __esm(() => {
 });
 
 // src/gdgraph/treesitter/grammars.ts
-import path80 from "path";
+import path81 from "path";
 function grammarAssetId(language) {
   return `tree-sitter-${language}`;
 }
@@ -18167,7 +18167,7 @@ function symbolLanguage(language) {
 async function resolveGrammar(cwd, language, grammarsPath) {
   const id = grammarAssetId(language);
   const lock = await loadAssetsLock(cwd);
-  const overrides = grammarsPath ? { [id]: { path: path80.join(grammarsPath, `${id}.wasm`) } } : undefined;
+  const overrides = grammarsPath ? { [id]: { path: path81.join(grammarsPath, `${id}.wasm`) } } : undefined;
   const registry = registryFromLock(lock, overrides);
   const resolved = await resolveAsset(registry, id);
   if (!resolved) {
@@ -18197,7 +18197,7 @@ function toGrammarLanguages(languages) {
   return out;
 }
 function grammarForFile(file, available) {
-  const ext = path80.extname(file);
+  const ext = path81.extname(file);
   const preference = ext === ".tsx" ? ["tsx", "typescript"] : ext === ".ts" ? ["typescript"] : ext === ".jsx" || ext === ".js" || ext === ".mjs" || ext === ".cjs" ? ["javascript"] : ext === ".java" ? ["java"] : ext === ".py" ? ["python"] : [];
   for (const language of preference) {
     if (available.includes(language)) {
@@ -18459,7 +18459,7 @@ var init_adapter = __esm(() => {
 
 // src/gdgraph/enrich.ts
 import { mkdir as mkdir14, writeFile as writeFile8 } from "fs/promises";
-import path81 from "path";
+import path82 from "path";
 async function enrichBuildWithSymbols(cwd, files, resolve, dataDir) {
   const config = await loadGdgraphConfig(cwd);
   const treesitterConfig = {
@@ -18477,10 +18477,10 @@ async function enrichBuildWithSymbols(cwd, files, resolve, dataDir) {
 async function writeSymbolLayer(cwd, layer, dataDir) {
   const storageDir = gdgraphStorageDir(cwd, dataDir);
   await mkdir14(storageDir, { recursive: true });
-  await writeFile8(path81.join(storageDir, "symbols.jsonl"), layer.symbols.map((symbol) => JSON.stringify(symbol)).join(`
+  await writeFile8(path82.join(storageDir, "symbols.jsonl"), layer.symbols.map((symbol) => JSON.stringify(symbol)).join(`
 `) + `
 `, "utf8");
-  await writeFile8(path81.join(storageDir, "calls.jsonl"), layer.calls.map((call) => JSON.stringify(call)).join(`
+  await writeFile8(path82.join(storageDir, "calls.jsonl"), layer.calls.map((call) => JSON.stringify(call)).join(`
 `) + `
 `, "utf8");
 }
@@ -18674,10 +18674,10 @@ var init_describes = () => {};
 
 // src/sync/provenance.ts
 import { mkdir as mkdir15, readFile as readFile40, writeFile as writeFile9 } from "fs/promises";
-import path82 from "path";
+import path83 from "path";
 import { spawn } from "child_process";
 function provenancePath(cwd, module) {
-  return path82.join(cwd, ".metaproject", "data", module, ".provenance.json");
+  return path83.join(cwd, ".metaproject", "data", module, ".provenance.json");
 }
 function gitCmdResult(cwd, args) {
   return new Promise((resolve) => {
@@ -18722,7 +18722,7 @@ async function recordProvenance(cwd, module, at) {
   if (!head)
     return;
   const file = provenancePath(cwd, module);
-  await mkdir15(path82.dirname(file), { recursive: true });
+  await mkdir15(path83.dirname(file), { recursive: true });
   const provenance = { commit: head.commit, branch: head.branch, builtAt: at };
   await writeFile9(file, `${JSON.stringify(provenance, null, 2)}
 `, "utf8");
@@ -18748,7 +18748,7 @@ var init_provenance = __esm(() => {
 // src/gdgraph/staleness.ts
 import { spawn as spawn2 } from "child_process";
 import { stat as stat11 } from "fs/promises";
-import path83 from "path";
+import path84 from "path";
 function gitStatusPorcelain(cwd) {
   return new Promise((resolve) => {
     try {
@@ -18771,10 +18771,10 @@ function gitStatusPorcelain(cwd) {
   });
 }
 function nodesJsonlPath(cwd) {
-  return path83.join(cwd, ".metaproject", "data", "gdgraph", "storage", "nodes.jsonl");
+  return path84.join(cwd, ".metaproject", "data", "gdgraph", "storage", "nodes.jsonl");
 }
 function gdgraphConfigPath2(cwd) {
-  return path83.join(cwd, ".metaproject", "gdgraph.config.json");
+  return path84.join(cwd, ".metaproject", "gdgraph.config.json");
 }
 function categorizeStatusEntries(entries, rootPrefix) {
   const metaprojectPrefix = `${rootPrefix}.metaproject/`;
@@ -18869,7 +18869,7 @@ async function checkGraphStaleness(cwd, statusObservation) {
       }
     } else {
       provenanceMissing = true;
-      const logsHeadStat = await stat11(path83.join(cwd, ".git", "logs", "HEAD")).catch(() => null);
+      const logsHeadStat = await stat11(path84.join(cwd, ".git", "logs", "HEAD")).catch(() => null);
       if (logsHeadStat && logsHeadStat.mtimeMs > nodesStat.mtimeMs) {
         reasons.push("repo HEAD moved since the graph was built (no build provenance recorded; inferred from .git/logs/HEAD)");
       }
@@ -18897,7 +18897,7 @@ async function checkGraphStaleness(cwd, statusObservation) {
         if (projectRelative === null) {
           continue;
         }
-        const fileStat = await stat11(path83.join(cwd, projectRelative)).catch(() => null);
+        const fileStat = await stat11(path84.join(cwd, projectRelative)).catch(() => null);
         if (fileStat && fileStat.mtimeMs > nodesStat.mtimeMs) {
           postBuildEdits.push(displayPath);
         }
@@ -19033,15 +19033,15 @@ var init_types3 = __esm(() => {
 
 // src/wiki/collect.ts
 import { readFile as readFile41, readdir as readdir16 } from "fs/promises";
-import path84 from "path";
+import path85 from "path";
 function wikiRootPath(cwd) {
-  return path84.join(cwd, ".metaproject", "wiki");
+  return path85.join(cwd, ".metaproject", "wiki");
 }
 async function collectPages(cwd) {
   const root = wikiRootPath(cwd);
   const pages = [];
   for (const { type, folder } of WIKI_PAGE_TYPES) {
-    const dir = path84.join(root, folder);
+    const dir = path85.join(root, folder);
     let names;
     try {
       names = await readdir16(dir);
@@ -19056,7 +19056,7 @@ async function collectPages(cwd) {
       if (!entry.endsWith(".md")) {
         continue;
       }
-      const absolutePath = path84.join(dir, entry);
+      const absolutePath = path85.join(dir, entry);
       let content;
       try {
         content = await readFile41(absolutePath, "utf8");
@@ -19917,9 +19917,9 @@ var MEMORY_EMBEDDING_ID = "memory.embedding", DEFAULT_EMBED_DIMS = 96;
 // src/memory/embedding/index.ts
 import { createHash as createHash14 } from "crypto";
 import { mkdir as mkdir16, readFile as readFile42, writeFile as writeFile10 } from "fs/promises";
-import path85 from "path";
+import path86 from "path";
 function embeddingsDir(cwd) {
-  return path85.join(cwd, ".metaproject", "data", "memory", "embeddings");
+  return path86.join(cwd, ".metaproject", "data", "memory", "embeddings");
 }
 function entryText(entry) {
   return `${entry.title}
@@ -19948,17 +19948,17 @@ async function buildEmbeddingIndex(cwd, entries, embedder, model, now) {
   };
   const dir = embeddingsDir(cwd);
   await mkdir16(dir, { recursive: true });
-  await writeFile10(path85.join(dir, "index.meta.json"), `${JSON.stringify(meta, null, 2)}
+  await writeFile10(path86.join(dir, "index.meta.json"), `${JSON.stringify(meta, null, 2)}
 `, "utf8");
-  await writeFile10(path85.join(dir, "vectors.jsonl"), records.map((record) => JSON.stringify(record)).join(`
+  await writeFile10(path86.join(dir, "vectors.jsonl"), records.map((record) => JSON.stringify(record)).join(`
 `) + (records.length > 0 ? `
 ` : ""), "utf8");
   return toIndex(meta, records);
 }
 async function loadEmbeddingIndex(cwd) {
   const dir = embeddingsDir(cwd);
-  const metaPath = path85.join(dir, "index.meta.json");
-  const vectorsPath = path85.join(dir, "vectors.jsonl");
+  const metaPath = path86.join(dir, "index.meta.json");
+  const vectorsPath = path86.join(dir, "vectors.jsonl");
   if (!await pathExists(metaPath) || !await pathExists(vectorsPath)) {
     return null;
   }
@@ -20039,10 +20039,10 @@ var init_embedding = __esm(() => {
 });
 
 // src/wiki/section-tombstone.ts
-import path86 from "path";
+import path87 from "path";
 import { stat as stat12 } from "fs/promises";
 function sectionRegistryPath(cwd) {
-  return path86.join(cwd, ".metaproject", "wiki", ".sections.json");
+  return path87.join(cwd, ".metaproject", "wiki", ".sections.json");
 }
 function emptySectionRegistry() {
   return { version: SECTION_REGISTRY_VERSION, entries: [], tombstones: [], lifted: [] };
@@ -20344,10 +20344,10 @@ var init_section_tombstone = __esm(() => {
 
 // src/memory/cross-layer.ts
 import { readFile as readFile43 } from "fs/promises";
-import path87 from "path";
+import path88 from "path";
 function extractWikiReferences(entryRelativePath, entryAbsolutePath, content, wikiRoot) {
   const references = [];
-  const entryDir = path87.dirname(entryAbsolutePath);
+  const entryDir = path88.dirname(entryAbsolutePath);
   const lines = content.split(`
 `);
   for (let index = 0;index < lines.length; index += 1) {
@@ -20362,16 +20362,16 @@ function extractWikiReferences(entryRelativePath, entryAbsolutePath, content, wi
       if (withoutAnchor.length === 0) {
         continue;
       }
-      const absolute = path87.resolve(entryDir, withoutAnchor);
-      const relativeToWiki = path87.relative(wikiRoot, absolute);
-      if (relativeToWiki.startsWith("..") || path87.isAbsolute(relativeToWiki)) {
+      const absolute = path88.resolve(entryDir, withoutAnchor);
+      const relativeToWiki = path88.relative(wikiRoot, absolute);
+      if (relativeToWiki.startsWith("..") || path88.isAbsolute(relativeToWiki)) {
         continue;
       }
       references.push({
         entry: entryRelativePath,
         kind: "page-path",
         raw: href,
-        target: relativeToWiki.split(path87.sep).join("/"),
+        target: relativeToWiki.split(path88.sep).join("/"),
         line
       });
     }
@@ -20391,7 +20391,7 @@ function isDangling(finding) {
   return finding.state !== "intact";
 }
 async function loadWikiKnowledgeView(cwd) {
-  const wikiRoot = path87.join(cwd, ".metaproject", "wiki");
+  const wikiRoot = path88.join(cwd, ".metaproject", "wiki");
   const pages = await collectPages(cwd);
   const index = buildSectionIndex(await Promise.all(pages.map(async (page) => ({
     page,
@@ -20609,7 +20609,7 @@ function round2(value) {
 var init_dedup = () => {};
 
 // src/memory/check.ts
-import path88 from "path";
+import path89 from "path";
 async function checkMemory(cwd, config) {
   const entries = await collectEntries(cwd);
   const issues = [];
@@ -20625,7 +20625,7 @@ async function checkMemory(cwd, config) {
     }
     for (const file of entry.scopes.files) {
       const clean = file.replace(/^`|`$/g, "");
-      if (!await pathExists(path88.resolve(cwd, clean))) {
+      if (!await pathExists(path89.resolve(cwd, clean))) {
         issues.push({ path: entry.relativePath, kind: "link", message: `related file not found: ${clean}` });
       }
     }
@@ -20680,12 +20680,12 @@ var init_check = __esm(() => {
 
 // src/memory/write.ts
 import { mkdir as mkdir17, open as open2, readFile as readFile44, rename as rename5, rm as rm5, writeFile as writeFile11 } from "fs/promises";
-import path89 from "path";
+import path90 from "path";
 async function resolveCanonicalEntryPath(cwd, relativePath) {
-  const root = path89.resolve(memoryRoot(cwd));
-  const absolutePath = path89.resolve(root, relativePath);
-  const normalized = toPosix2(path89.relative(root, absolutePath));
-  if (!normalized || normalized.startsWith("../") || path89.isAbsolute(normalized) || !normalized.endsWith(".md")) {
+  const root = path90.resolve(memoryRoot(cwd));
+  const absolutePath = path90.resolve(root, relativePath);
+  const normalized = toPosix2(path90.relative(root, absolutePath));
+  if (!normalized || normalized.startsWith("../") || path90.isAbsolute(normalized) || !normalized.endsWith(".md")) {
     return null;
   }
   return { absolutePath, relativePath: normalized };
@@ -20781,9 +20781,9 @@ function validateNextEntry(relativePath, content) {
   return null;
 }
 async function replaceAtomically(target, content) {
-  const dir = path89.dirname(target);
+  const dir = path90.dirname(target);
   await mkdir17(dir, { recursive: true });
-  const tmp = path89.join(dir, `.${path89.basename(target)}.keryx-tmp-${process.pid}-${Math.random().toString(16).slice(2)}`);
+  const tmp = path90.join(dir, `.${path90.basename(target)}.keryx-tmp-${process.pid}-${Math.random().toString(16).slice(2)}`);
   try {
     await writeFile11(tmp, content, "utf8");
     const file = await open2(tmp, "r");
@@ -20819,7 +20819,7 @@ function header(content, name) {
   return content.match(new RegExp(`^${name}:\\s*(.+)$`, "mi"))?.[1]?.trim() ?? null;
 }
 function toPosix2(value) {
-  return value.split(path89.sep).join("/");
+  return value.split(path90.sep).join("/");
 }
 function message(cause) {
   return cause instanceof Error ? cause.message : String(cause);
@@ -20833,9 +20833,9 @@ var init_write = __esm(() => {
 // src/memory/ingest.ts
 import { existsSync as existsSync10 } from "fs";
 import { readFile as readFile45 } from "fs/promises";
-import path90 from "path";
+import path91 from "path";
 async function ingestMemory(cwd, source, filePath, config, now) {
-  const absolute = path90.resolve(cwd, filePath);
+  const absolute = path91.resolve(cwd, filePath);
   if (!await pathExists(absolute)) {
     throw new Error(`Ingest source not found: ${filePath}`);
   }
@@ -20852,8 +20852,8 @@ async function ingestMemory(cwd, source, filePath, config, now) {
   const securityWarnings = [];
   const securitySkipped = [];
   let skippedDuplicates = 0;
-  const dir = path90.join(memoryRoot(cwd), folder);
-  const link = path90.relative(cwd, absolute);
+  const dir = path91.join(memoryRoot(cwd), folder);
+  const link = path91.relative(cwd, absolute);
   const date = dateString(now);
   for (const text of candidates) {
     const title = toTitle(text);
@@ -21034,7 +21034,7 @@ function uniqueSlug(dir, title) {
   const base = slugify2(title) || "entry";
   let slug = base;
   let counter = 2;
-  while (existsSync10(path90.join(dir, `${slug}.md`))) {
+  while (existsSync10(path91.join(dir, `${slug}.md`))) {
     slug = `${base}-${counter}`;
     counter += 1;
   }
@@ -21069,7 +21069,7 @@ var init_ingest = __esm(() => {
 
 // src/memory/supersede.ts
 import { readFile as readFile46 } from "fs/promises";
-import path91 from "path";
+import path92 from "path";
 async function supersedeEntry(input, now) {
   const date = input.date ?? now.toISOString().slice(0, 10);
   const today = now.toISOString().slice(0, 10);
@@ -21129,12 +21129,12 @@ async function supersedeEntry(input, now) {
 async function resolveEntryPath(cwd, raw) {
   const root = memoryRoot(cwd);
   const candidates = [
-    path91.resolve(cwd, raw),
-    path91.resolve(root, raw),
-    path91.isAbsolute(raw) ? raw : path91.join(cwd, raw)
+    path92.resolve(cwd, raw),
+    path92.resolve(root, raw),
+    path92.isAbsolute(raw) ? raw : path92.join(cwd, raw)
   ];
   for (const absolute of candidates) {
-    const confined = await resolveCanonicalEntryPath(cwd, path91.relative(root, absolute));
+    const confined = await resolveCanonicalEntryPath(cwd, path92.relative(root, absolute));
     if (confined && await pathExists(confined.absolutePath)) {
       return { absolute: confined.absolutePath, relative: confined.relativePath };
     }
@@ -21330,9 +21330,9 @@ __export(exports_service3, {
 });
 import { createHash as createHash15 } from "crypto";
 import { mkdir as mkdir18, readFile as readFile47, writeFile as writeFile12 } from "fs/promises";
-import path92 from "path";
+import path93 from "path";
 function dataRoot2(cwd) {
-  return path92.join(cwd, ".metaproject", "data", "memory");
+  return path93.join(cwd, ".metaproject", "data", "memory");
 }
 function createMemoryService() {
   const reportStore = createMemoryReportStore();
@@ -21347,9 +21347,9 @@ function createMemoryService() {
       if (!/^[a-z0-9][a-z0-9-]*$/.test(slug)) {
         throw new Error(`Invalid slug: ${slug}. Use lowercase letters, digits, and hyphens.`);
       }
-      const dir = path92.join(memoryRoot(input.cwd), typeConfig.folder);
-      const filePath = path92.join(dir, `${slug}.md`);
-      const relativePath = path92.relative(input.cwd, filePath);
+      const dir = path93.join(memoryRoot(input.cwd), typeConfig.folder);
+      const filePath = path93.join(dir, `${slug}.md`);
+      const relativePath = path93.relative(input.cwd, filePath);
       if (await pathExists(filePath) && !input.force) {
         throw new Error(`Entry already exists: ${relativePath}. Use --force to overwrite.`);
       }
@@ -21380,9 +21380,9 @@ function createMemoryService() {
     async index(input) {
       const entries = await collectEntries(input.cwd);
       const generatedAt = new Date().toISOString();
-      const indexDir = input.indexDir ?? path92.join(dataRoot2(input.cwd), "index");
+      const indexDir = input.indexDir ?? path93.join(dataRoot2(input.cwd), "index");
       await mkdir18(indexDir, { recursive: true });
-      const indexPath = path92.join(indexDir, "index.json");
+      const indexPath = path93.join(indexDir, "index.json");
       await writeFile12(indexPath, `${JSON.stringify({
         catalogVersion: 1,
         sourceFingerprint: createHash15("sha256").update(JSON.stringify(entries.map((e) => ({
@@ -21403,7 +21403,7 @@ function createMemoryService() {
       }, null, 2)}
 `, "utf8");
       const result = {
-        path: path92.relative(input.cwd, indexPath),
+        path: path93.relative(input.cwd, indexPath),
         entryCount: entries.length,
         generatedAt
       };
@@ -21416,7 +21416,7 @@ function createMemoryService() {
           const built = await buildEmbeddingIndex(input.cwd, entries, embedder.embed, embedder.model, new Date);
           result.embeddings = {
             built: true,
-            path: path92.relative(input.cwd, embeddingsDir(input.cwd)),
+            path: path93.relative(input.cwd, embeddingsDir(input.cwd)),
             vectorCount: built.meta.entryCount,
             model: built.meta.model
           };
@@ -22018,7 +22018,7 @@ var init_ask = __esm(() => {
 });
 
 // src/wiki/backlinks.ts
-import path93 from "path";
+import path94 from "path";
 function extractCodePaths(content) {
   const out = [];
   let match;
@@ -22048,8 +22048,8 @@ function resolveLink(fromRepoPath, raw) {
   const clean = (raw.split("#")[0] ?? "").trim();
   if (!clean)
     return "";
-  const fromDir = path93.posix.dirname(fromRepoPath.split(path93.sep).join("/"));
-  return path93.posix.normalize(path93.posix.join(fromDir, clean));
+  const fromDir = path94.posix.dirname(fromRepoPath.split(path94.sep).join("/"));
+  return path94.posix.normalize(path94.posix.join(fromDir, clean));
 }
 function buildBacklinkIndex(pages) {
   const index = new Map;
@@ -22063,18 +22063,18 @@ function buildBacklinkIndex(pages) {
     }
   };
   for (const page of pages) {
-    const from = page.repoPath.split(path93.sep).join("/");
+    const from = page.repoPath.split(path94.sep).join("/");
     for (const raw of extractLinks(page.content))
       add(resolveLink(from, raw), from);
     for (const raw of extractCodePaths(page.content))
-      add(path93.posix.normalize(raw), from);
+      add(path94.posix.normalize(raw), from);
   }
   for (const list of index.values())
     list.sort();
   return index;
 }
 function backlinksFor(index, targetRepoPath) {
-  const key = path93.posix.normalize(targetRepoPath.split(path93.sep).join("/"));
+  const key = path94.posix.normalize(targetRepoPath.split(path94.sep).join("/"));
   return index.get(key) ?? [];
 }
 var LINK, CODE_SPAN, FILE_LIKE;
@@ -22087,7 +22087,7 @@ var init_backlinks = __esm(() => {
 // src/ctx/assembly.ts
 import { createHash as createHash16 } from "crypto";
 import { mkdir as mkdir19, rename as rename6, writeFile as writeFile13 } from "fs/promises";
-import path94 from "path";
+import path95 from "path";
 function assembleContext(input) {
   let items = 0;
   let tokens = 0;
@@ -22131,9 +22131,9 @@ async function recordNoContentContext(input) {
   return assembly;
 }
 async function recordContextAssembly(input) {
-  const directory = path94.join(input.workspaceRoot, ".metaproject", "context-operations", "traces");
+  const directory = path95.join(input.workspaceRoot, ".metaproject", "context-operations", "traces");
   await mkdir19(directory, { recursive: true });
-  const target = path94.join(directory, path94.basename(input.assembly.traceRef));
+  const target = path95.join(directory, path95.basename(input.assembly.traceRef));
   const temporary = `${target}.${process.pid}.tmp`;
   await writeFile13(temporary, `${JSON.stringify({ schemaVersion: "1.0", correlationId: input.correlationId, outcome: input.outcome, configurationRevision: input.assembly.configurationRevision, policy: { ref: input.assembly.policyRef, revision: input.assembly.policyRevision }, selected: input.assembly.selected, omittedOptional: input.assembly.omittedOptional, partial: input.assembly.partial })}
 `, { mode: 384 });
@@ -22533,9 +22533,9 @@ var init_evidence = __esm(() => {
 });
 
 // src/wiki/config.ts
-import path95 from "path";
+import path96 from "path";
 function wikiConfigPath(cwd) {
-  return path95.join(cwd, ".metaproject", "wiki.config.json");
+  return path96.join(cwd, ".metaproject", "wiki.config.json");
 }
 function mergeWikiConfig(parsed) {
   const base = DEFAULT_WIKI_CONFIG;
@@ -22613,12 +22613,12 @@ var init_config4 = __esm(() => {
 // src/wiki/history.ts
 import { createHash as createHash17, randomBytes as randomBytes5 } from "crypto";
 import { appendFile as appendFile4, mkdir as mkdir20, open as open3, readFile as readFile49, rm as rm6, stat as stat13, writeFile as writeFile14 } from "fs/promises";
-import path96 from "path";
+import path97 from "path";
 function wikiRootPath2(cwd) {
-  return path96.join(cwd, ".metaproject", "wiki");
+  return path97.join(cwd, ".metaproject", "wiki");
 }
 function wikiHistoryRoot(cwd) {
-  return path96.join(cwd, ".metaproject", "data", "gdwiki", "history");
+  return path97.join(cwd, ".metaproject", "data", "gdwiki", "history");
 }
 function newWikiRunId(now = new Date) {
   const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
@@ -22639,29 +22639,29 @@ async function openWikiWriteContext(cwd, command) {
   return createWikiWriteContext(cwd, command, { keep: (await loadWikiConfig(cwd)).history.keep });
 }
 function wikiPageKey(cwd, absolutePath) {
-  const relative = path96.relative(wikiRootPath2(cwd), path96.resolve(absolutePath));
-  if (relative === "" || relative.startsWith("..") || path96.isAbsolute(relative)) {
+  const relative = path97.relative(wikiRootPath2(cwd), path97.resolve(absolutePath));
+  if (relative === "" || relative.startsWith("..") || path97.isAbsolute(relative)) {
     throw new Error(`not a wiki page: ${absolutePath}`);
   }
   return toPosix(relative);
 }
 function assertPageKey(page) {
   const segments = page.split("/");
-  if (page.length === 0 || page.includes("\\") || path96.isAbsolute(page) || segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+  if (page.length === 0 || page.includes("\\") || path97.isAbsolute(page) || segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
     throw new Error(`not a wiki page path: ${page}`);
   }
   return page;
 }
 function pageHistoryDir(cwd, page) {
-  return path96.join(wikiHistoryRoot(cwd), ...assertPageKey(page).replace(/\.md$/i, "").split("/"));
+  return path97.join(wikiHistoryRoot(cwd), ...assertPageKey(page).replace(/\.md$/i, "").split("/"));
 }
 function pagePath(cwd, page) {
-  return path96.join(wikiRootPath2(cwd), ...assertPageKey(page).split("/"));
+  return path97.join(wikiRootPath2(cwd), ...assertPageKey(page).split("/"));
 }
 function versionFilePath(cwd, page, file) {
   const dir = pageHistoryDir(cwd, page);
-  const target = path96.join(dir, file);
-  if (!VERSION_FILE.test(file) || path96.dirname(target) !== dir) {
+  const target = path97.join(dir, file);
+  if (!VERSION_FILE.test(file) || path97.dirname(target) !== dir) {
     throw new Error(`history index names an invalid version file for ${page}: ${file}`);
   }
   return target;
@@ -22734,7 +22734,7 @@ function parsePageHistoryIndex(markdown, page) {
   return { page, rows };
 }
 async function readPageHistory(cwd, page) {
-  const indexPath = path96.join(pageHistoryDir(cwd, page), INDEX_FILE);
+  const indexPath = path97.join(pageHistoryDir(cwd, page), INDEX_FILE);
   const raw = await readBufferOrNull(indexPath);
   if (raw === null)
     return null;
@@ -22746,8 +22746,8 @@ async function readPageHistory(cwd, page) {
 }
 async function storeVersion(cwd, page, version, at, content) {
   const fileName = `${versionLabel(version)}-${at.replace(/[:.]/g, "-")}.md`;
-  const target = path96.join(pageHistoryDir(cwd, page), fileName);
-  await mkdir20(path96.dirname(target), { recursive: true });
+  const target = path97.join(pageHistoryDir(cwd, page), fileName);
+  await mkdir20(path97.dirname(target), { recursive: true });
   await writeFile14(target, content);
   if (sha2562(await readFile49(target)) !== sha2562(content)) {
     throw new Error(`history: stored version does not match the page bytes: ${target}`);
@@ -22785,7 +22785,7 @@ function planPrune(history, keep, maxRows = MAX_INDEX_ROWS) {
 }
 async function ensureHistoryRoot(cwd) {
   const root = wikiHistoryRoot(cwd);
-  const ignore = path96.join(root, ".gitignore");
+  const ignore = path97.join(root, ".gitignore");
   if (await readBufferOrNull(ignore))
     return;
   await mkdir20(root, { recursive: true });
@@ -22815,14 +22815,14 @@ async function endsWithoutNewline(file) {
 }
 async function appendRun(cwd, entry) {
   const root = wikiHistoryRoot(cwd);
-  const file = path96.join(root, RUNS_FILE);
+  const file = path97.join(root, RUNS_FILE);
   const lead = await endsWithoutNewline(file) ? `
 ` : "";
   await appendFile4(file, `${lead}${JSON.stringify(entry)}
 `, "utf8");
   if ((await stat13(file)).size <= MAX_RUNS_BYTES)
     return;
-  await withFileLock(path96.join(root, ".runs.lock"), async () => {
+  await withFileLock(path97.join(root, ".runs.lock"), async () => {
     if ((await stat13(file)).size <= MAX_RUNS_BYTES)
       return;
     const lines = (await readFile49(file, "utf8")).split(`
@@ -22836,7 +22836,7 @@ async function mutatePage(ctx, absolutePath, next) {
   const page = wikiPageKey(ctx.cwd, absolutePath);
   const dir = pageHistoryDir(ctx.cwd, page);
   await ensureHistoryRoot(ctx.cwd);
-  return withFileLock(path96.join(path96.dirname(dir), `.${path96.basename(dir)}.lock`), async () => {
+  return withFileLock(path97.join(path97.dirname(dir), `.${path97.basename(dir)}.lock`), async () => {
     const live = await readBufferOrNull(absolutePath);
     if (next === null ? live === null : live !== null && live.equals(next)) {
       return { changed: false };
@@ -22860,7 +22860,7 @@ async function mutatePage(ctx, absolutePath, next) {
       if (next === null) {
         await rm6(absolutePath, { force: true });
       } else {
-        await mkdir20(path96.dirname(absolutePath), { recursive: true });
+        await mkdir20(path97.dirname(absolutePath), { recursive: true });
         await writeFile14(absolutePath, next);
       }
     } catch (error) {
@@ -22868,7 +22868,7 @@ async function mutatePage(ctx, absolutePath, next) {
         await rm6(versionFilePath(ctx.cwd, page, row.file), { force: true });
       throw error;
     }
-    await writeFileAtomic(path96.join(dir, INDEX_FILE), renderPageHistoryIndex(history));
+    await writeFileAtomic(path97.join(dir, INDEX_FILE), renderPageHistoryIndex(history));
     for (const file of pruned)
       await rm6(versionFilePath(ctx.cwd, page, file), { force: true });
     return { changed: true, action };
@@ -22881,7 +22881,7 @@ async function deleteWikiPage(ctx, absolutePath) {
   return mutatePage(ctx, absolutePath, null);
 }
 async function readWikiRuns(cwd) {
-  const raw = await readBufferOrNull(path96.join(wikiHistoryRoot(cwd), RUNS_FILE));
+  const raw = await readBufferOrNull(path97.join(wikiHistoryRoot(cwd), RUNS_FILE));
   if (raw === null)
     return [];
   const entries = [];
@@ -23573,7 +23573,7 @@ var init_page_invariants = __esm(() => {
 });
 
 // src/wiki/readme-links.ts
-import path97 from "path";
+import path98 from "path";
 function rewriteReadmeLinks(text, readmeDir, pageLink) {
   return text.replace(MARKDOWN_LINK, (whole, bang, label, target) => {
     if (target === "" || HAS_SCHEME.test(target)) {
@@ -23583,7 +23583,7 @@ function rewriteReadmeLinks(text, readmeDir, pageLink) {
     if (filePart === "") {
       return label;
     }
-    const resolved = path97.posix.normalize(filePart.startsWith("/") ? filePart.replace(/^\/+/, "") : path97.posix.join(readmeDir, filePart));
+    const resolved = path98.posix.normalize(filePart.startsWith("/") ? filePart.replace(/^\/+/, "") : path98.posix.join(readmeDir, filePart));
     const codePath = resolved.replace(/\/+$/, "");
     if (codePath === "" || codePath === "." || codePath === ".." || codePath.startsWith("../")) {
       return label;
@@ -23598,12 +23598,12 @@ function rewriteReadmeLinks(text, readmeDir, pageLink) {
   });
 }
 function moduleOfTarget(filePart, codePath) {
-  const base = path97.posix.basename(codePath);
+  const base = path98.posix.basename(codePath);
   if (filePart.endsWith("/") || !/\.[A-Za-z0-9]+$/.test(base)) {
     return codePath;
   }
   if (DOC_ENTRY.test(base)) {
-    const dir = path97.posix.dirname(codePath);
+    const dir = path98.posix.dirname(codePath);
     return dir === "." ? null : dir;
   }
   return null;
@@ -24009,15 +24009,15 @@ __export(exports_service4, {
 import { spawn as spawn3 } from "child_process";
 import { createHash as createHash19 } from "crypto";
 import { mkdir as mkdir21, readFile as readFile50, readdir as readdir17, writeFile as writeFile15 } from "fs/promises";
-import path98 from "path";
+import path99 from "path";
 function wikiRootPath3(cwd) {
-  return path98.join(cwd, ".metaproject", "wiki");
+  return path99.join(cwd, ".metaproject", "wiki");
 }
 function dataRootPath(cwd) {
-  return path98.join(cwd, ".metaproject", "data", "gdwiki");
+  return path99.join(cwd, ".metaproject", "data", "gdwiki");
 }
 function linkCheckReportPath(cwd) {
-  return path98.join(dataRootPath(cwd), "link-check", "latest.md");
+  return path99.join(dataRootPath(cwd), "link-check", "latest.md");
 }
 async function wikiStatus(cwd) {
   const root = wikiRootPath3(cwd);
@@ -24025,7 +24025,7 @@ async function wikiStatus(cwd) {
   const pages = enabled ? await collectPages(cwd) : [];
   return {
     enabled,
-    wikiRoot: path98.relative(cwd, root),
+    wikiRoot: path99.relative(cwd, root),
     totalPages: pages.length,
     countsByType: WIKI_PAGE_TYPES.map(({ type }) => ({
       type,
@@ -24056,9 +24056,9 @@ async function wikiCreatePage(input) {
   if (!/^[a-z0-9][a-z0-9-]*$/.test(input.slug)) {
     throw new Error(`Invalid slug: ${input.slug}. Use lowercase letters, digits, and hyphens.`);
   }
-  const dir = path98.join(wikiRootPath3(input.cwd), typeConfig.folder);
-  const filePath = path98.join(dir, `${input.slug}.md`);
-  const relativePath = path98.relative(input.cwd, filePath);
+  const dir = path99.join(wikiRootPath3(input.cwd), typeConfig.folder);
+  const filePath = path99.join(dir, `${input.slug}.md`);
+  const relativePath = path99.relative(input.cwd, filePath);
   if (await pathExists(filePath) && !input.force) {
     throw new Error(`Page already exists: ${relativePath}. Use --force to overwrite.`);
   }
@@ -24070,7 +24070,7 @@ async function wikiCreatePage(input) {
 }
 async function wikiGenerateIndex(cwd, history) {
   const root = wikiRootPath3(cwd);
-  const indexPath = path98.join(root, "index.md");
+  const indexPath = path99.join(root, "index.md");
   const pages = await collectPages(cwd);
   const generatedAt = new Date().toISOString();
   const managedBlock = `${WIKI_INDEX_BEGIN}
@@ -24087,7 +24087,7 @@ ${managedBlock}
 `;
   await writeWikiPage(history ?? await openWikiWriteContext(cwd, "wiki index"), indexPath, next);
   return {
-    path: path98.relative(cwd, indexPath),
+    path: path99.relative(cwd, indexPath),
     pageCount: pages.length,
     generatedAt
   };
@@ -24095,13 +24095,13 @@ ${managedBlock}
 async function wikiCheckLinks(cwd) {
   const root = wikiRootPath3(cwd);
   const allFiles = await pathExists(root) ? await walkMarkdown(root) : [];
-  const files = allFiles.filter((absolutePath) => !path98.relative(root, absolutePath).startsWith(`templates${path98.sep}`));
+  const files = allFiles.filter((absolutePath) => !path99.relative(root, absolutePath).startsWith(`templates${path99.sep}`));
   const broken = [];
   let checkedLinks = 0;
   let skippedExternal = 0;
   for (const absolutePath of files) {
     const content = await readFile50(absolutePath, "utf8");
-    const pageRelative = path98.relative(cwd, absolutePath);
+    const pageRelative = path99.relative(cwd, absolutePath);
     for (const target of extractLinkTargets(content)) {
       if (EXTERNAL_LINK.test(target)) {
         skippedExternal += 1;
@@ -24112,7 +24112,7 @@ async function wikiCheckLinks(cwd) {
         continue;
       }
       checkedLinks += 1;
-      const resolved = path98.resolve(path98.dirname(absolutePath), filePart);
+      const resolved = path99.resolve(path99.dirname(absolutePath), filePart);
       if (!await pathExists(resolved)) {
         broken.push({
           page: pageRelative,
@@ -24124,7 +24124,7 @@ async function wikiCheckLinks(cwd) {
   }
   const generatedAt = new Date().toISOString();
   const reportPath = linkCheckReportPath(cwd);
-  await mkdir21(path98.dirname(reportPath), { recursive: true });
+  await mkdir21(path99.dirname(reportPath), { recursive: true });
   await writeFile15(reportPath, renderLinkCheckReport({
     generatedAt,
     checkedPages: files.length,
@@ -24133,7 +24133,7 @@ async function wikiCheckLinks(cwd) {
     broken
   }), "utf8");
   return {
-    reportPath: path98.relative(cwd, reportPath),
+    reportPath: path99.relative(cwd, reportPath),
     checkedPages: files.length,
     checkedLinks,
     skippedExternal,
@@ -24184,7 +24184,7 @@ async function wikiValidate(cwd) {
   }
   if (await isIndexStale(cwd, pages)) {
     issues.push({
-      page: path98.join(path98.relative(cwd, wikiRootPath3(cwd)), "index.md"),
+      page: path99.join(path99.relative(cwd, wikiRootPath3(cwd)), "index.md"),
       kind: "index",
       message: "index out of date, run `keryx wiki index`"
     });
@@ -24230,7 +24230,7 @@ function collectCommandLabel(input) {
   return ["wiki collect", ...flags].join(" ");
 }
 async function wikiPruneOrphans(cwd, history) {
-  const componentsDir = path98.join(wikiRootPath3(cwd), "components");
+  const componentsDir = path99.join(wikiRootPath3(cwd), "components");
   if (!await pathExists(componentsDir)) {
     return { pruned: [], orphanedAccepted: [] };
   }
@@ -24250,15 +24250,15 @@ async function wikiPruneOrphans(cwd, history) {
     if (validSlugs.has(slug)) {
       continue;
     }
-    const filePath = path98.join(componentsDir, entry);
+    const filePath = path99.join(componentsDir, entry);
     const current = await readFile50(filePath, "utf8");
     const isUnmodifiedDraft = /\nStatus:\s*draft\s*\n/.test(current) && current.includes("Generated by `keryx wiki collect`");
     if (isUnmodifiedDraft) {
       run ??= history ?? await openWikiWriteContext(cwd, "wiki prune");
       await deleteWikiPage(run, filePath);
-      pruned.push(path98.relative(cwd, filePath));
+      pruned.push(path99.relative(cwd, filePath));
     } else {
-      orphanedAccepted.push(path98.relative(cwd, filePath));
+      orphanedAccepted.push(path99.relative(cwd, filePath));
     }
   }
   return { pruned, orphanedAccepted };
@@ -24268,7 +24268,7 @@ async function validModuleNames(cwd, dataDir) {
   return counts === undefined ? undefined : new Set(counts.keys());
 }
 async function moduleFileCounts(cwd, dataDir) {
-  const nodesPath = path98.join(gdgraphStorageDir(cwd, dataDir), "nodes.jsonl");
+  const nodesPath = path99.join(gdgraphStorageDir(cwd, dataDir), "nodes.jsonl");
   if (!await pathExists(nodesPath)) {
     return;
   }
@@ -24339,9 +24339,9 @@ async function wikiEvidence(input) {
   });
 }
 function resolveEvidenceScope(cwd, override) {
-  const absolute = path98.resolve(cwd);
+  const absolute = path99.resolve(cwd);
   return {
-    projectId: override?.projectId ?? (path98.basename(absolute) || "project"),
+    projectId: override?.projectId ?? (path99.basename(absolute) || "project"),
     checkoutId: override?.checkoutId ?? `checkout:${createHash19("sha256").update(absolute).digest("hex").slice(0, 16)}`,
     ...override?.workspaceId ? { workspaceId: override.workspaceId } : {},
     ...override?.taskId ? { taskId: override.taskId } : {}
@@ -24356,7 +24356,7 @@ function isMachineAuthoredPage(pageType, relativePath, content) {
   if (source === null) {
     return false;
   }
-  const normalised = relativePath.split(path98.sep).join("/").replace(/^wiki\//, "");
+  const normalised = relativePath.split(path99.sep).join("/").replace(/^wiki\//, "");
   return WIKI_PAGE_PRODUCERS.some((producer) => producer.source === source && producer.pageType === pageType && producer.path.test(normalised) && /^-[ \t]+Link:.*\bsha256\b/m.test(content));
 }
 function createGdWikiService() {
@@ -24372,8 +24372,8 @@ function createGdWikiService() {
   };
 }
 async function collectGraphWikiCandidates(cwd, generatedAt, limit, onlyModules, dataDir) {
-  const nodesPath = path98.join(gdgraphStorageDir(cwd, dataDir), "nodes.jsonl");
-  const edgesPath = path98.join(gdgraphStorageDir(cwd, dataDir), "edges.jsonl");
+  const nodesPath = path99.join(gdgraphStorageDir(cwd, dataDir), "nodes.jsonl");
+  const edgesPath = path99.join(gdgraphStorageDir(cwd, dataDir), "edges.jsonl");
   if (!await pathExists(nodesPath) || !await pathExists(edgesPath)) {
     return [];
   }
@@ -24460,7 +24460,7 @@ async function collectGraphWikiCandidates(cwd, generatedAt, limit, onlyModules,
   };
   const moduleCandidates = [];
   const pageModules = new Set(topModules.map((entry) => entry.name));
-  const componentsDir = path98.join(wikiRootPath3(cwd), "components");
+  const componentsDir = path99.join(wikiRootPath3(cwd), "components");
   const existingSlugs = new Set((await pathExists(componentsDir) ? await readdir17(componentsDir) : []).filter((entry) => entry.endsWith(".md")).map((entry) => entry.slice(0, -3)));
   const pageLink = (name) => {
     const slug = slugifyPath(name);
@@ -24568,7 +24568,7 @@ function topCounts(bucket, limit) {
   return [...bucket.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit);
 }
 async function readModuleReadme(cwd, moduleName, pageLink) {
-  const readmePath = path98.join(cwd, ...moduleName.split("/"), "README.md");
+  const readmePath = path99.join(cwd, ...moduleName.split("/"), "README.md");
   if (!await pathExists(readmePath)) {
     return null;
   }
@@ -24589,7 +24589,7 @@ async function extractModuleExports(cwd, files) {
   const declRe = /export\s+(?:async\s+)?(?:default\s+)?(?:const|let|var|function|class|type|interface|enum)\s+([A-Za-z_$][\w$]*)/g;
   const braceRe = /export\s*\{([^}]+)\}/g;
   for (const file of files.slice(0, 4)) {
-    const filePath = path98.join(cwd, ...file.split("/"));
+    const filePath = path99.join(cwd, ...file.split("/"));
     if (!await pathExists(filePath)) {
       continue;
     }
@@ -24620,7 +24620,7 @@ async function extractModuleExports(cwd, files) {
 }
 async function extractModuleApi(cwd, files, dataDir) {
   const names = await extractModuleExports(cwd, files);
-  const symbolsPath = path98.join(gdgraphStorageDir(cwd, dataDir), "symbols.jsonl");
+  const symbolsPath = path99.join(gdgraphStorageDir(cwd, dataDir), "symbols.jsonl");
   if (names.length === 0 || !await pathExists(symbolsPath)) {
     return names.map((name) => "`" + name + "`");
   }
@@ -24646,7 +24646,7 @@ async function extractModuleApi(cwd, files, dataDir) {
   });
 }
 async function collectHealthWikiCandidates(cwd, generatedAt) {
-  const healthPath = path98.join(cwd, ".metaproject", "data", "health", "artifacts", "latest.json");
+  const healthPath = path99.join(cwd, ".metaproject", "data", "health", "artifacts", "latest.json");
   if (!await pathExists(healthPath)) {
     return [];
   }
@@ -24688,7 +24688,7 @@ async function collectHealthWikiCandidates(cwd, generatedAt) {
   }];
 }
 async function collectTestingWikiCandidates(cwd, generatedAt) {
-  const contextPath = path98.join(cwd, ".metaproject", "data", "testing", "context.md");
+  const contextPath = path99.join(cwd, ".metaproject", "data", "testing", "context.md");
   if (!await pathExists(contextPath)) {
     return [];
   }
@@ -24719,8 +24719,8 @@ async function writeCollectedPage(cwd, candidate, force, history) {
   if (!folder) {
     throw new Error(`Unsupported collected wiki type: ${candidate.type}`);
   }
-  const filePath = path98.join(wikiRootPath3(cwd), folder, `${candidate.slug}.md`);
-  const relativePath = path98.relative(cwd, filePath);
+  const filePath = path99.join(wikiRootPath3(cwd), folder, `${candidate.slug}.md`);
+  const relativePath = path99.relative(cwd, filePath);
   const exists = await pathExists(filePath);
   if (exists && !force) {
     return { path: relativePath, type: candidate.type, source: candidate.source, action: "skipped" };
@@ -24771,7 +24771,7 @@ async function writeCollectedPage(cwd, candidate, force, history) {
 async function wikiPagesForFile(cwd, targetRepoPath) {
   const pages = await collectPages(cwd);
   const refs = await Promise.all(pages.map(async (page) => ({
-    repoPath: path98.relative(cwd, page.absolutePath).split(path98.sep).join("/"),
+    repoPath: path99.relative(cwd, page.absolutePath).split(path99.sep).join("/"),
     content: await readFile50(page.absolutePath, "utf8")
   })));
   return backlinksFor(buildBacklinkIndex(refs), targetRepoPath);
@@ -24810,7 +24810,7 @@ function renderIndexBody(pages, generatedAt) {
 `).trimEnd();
 }
 async function isIndexStale(cwd, pages) {
-  const indexPath = path98.join(wikiRootPath3(cwd), "index.md");
+  const indexPath = path99.join(wikiRootPath3(cwd), "index.md");
   if (!await pathExists(indexPath)) {
     return true;
   }
@@ -24828,7 +24828,7 @@ async function walkMarkdown(root) {
   const results = [];
   const entries = await readdir17(root, { withFileTypes: true });
   for (const entry of entries) {
-    const absolutePath = path98.join(root, entry.name);
+    const absolutePath = path99.join(root, entry.name);
     if (entry.isDirectory()) {
       results.push(...await walkMarkdown(absolutePath));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -24885,7 +24885,7 @@ ${JSON.stringify(state, null, 2)}
 `;
 }
 async function readIndexGeneratedAt(cwd) {
-  const indexPath = path98.join(wikiRootPath3(cwd), "index.md");
+  const indexPath = path99.join(wikiRootPath3(cwd), "index.md");
   if (!await pathExists(indexPath)) {
     return null;
   }
@@ -25125,7 +25125,7 @@ async function validateStructure(cwd, pages, issues) {
       if (pattern.includes("*")) {
         continue;
       }
-      if (!await pathExists(path98.join(cwd, pattern))) {
+      if (!await pathExists(path99.join(cwd, pattern))) {
         issues.push({
           page: page.relativePath,
           kind: "describes",
@@ -25195,7 +25195,7 @@ async function validatePageInvariants(cwd, pages, issues) {
   }
 }
 function toPosixPath(value) {
-  return value.split(path98.sep).join("/");
+  return value.split(path99.sep).join("/");
 }
 function compareSemver(a, b) {
   const pa = a.split(".").map(Number);
@@ -25240,7 +25240,7 @@ var init_service4 = __esm(() => {
 // src/gdgraph/wiki-layer.ts
 import { createHash as createHash20 } from "crypto";
 import { mkdir as mkdir22, stat as stat14, writeFile as writeFile16 } from "fs/promises";
-import path99 from "path";
+import path100 from "path";
 function storageDir(projectRoot, dataDir) {
   return gdgraphStorageDir(projectRoot, dataDir);
 }
@@ -25308,11 +25308,11 @@ async function enrichBuildWithWikiLayer(input) {
   const mtimes = new Map;
   for (const record of input.fileRecords) {
     try {
-      const info = await stat14(path99.join(input.projectRoot, record.path));
+      const info = await stat14(path100.join(input.projectRoot, record.path));
       mtimes.set(record.path, info.mtimeMs);
     } catch {}
   }
-  await writeFile16(path99.join(dir, BUILD_MANIFEST_FILE), `${JSON.stringify({ version: 1, files: computeFingerprints(input.fileRecords, mtimes) }, null, 2)}
+  await writeFile16(path100.join(dir, BUILD_MANIFEST_FILE), `${JSON.stringify({ version: 1, files: computeFingerprints(input.fileRecords, mtimes) }, null, 2)}
 `, "utf8");
   const validModules = input.validModules !== undefined ? input.validModules : await (input.loadValidModules ?? ((root) => defaultLoadValidModules(root, input.dataDir)))(input.projectRoot);
   const wikiPages = await collectPages(input.projectRoot);
@@ -25337,8 +25337,8 @@ async function enrichBuildWithWikiLayer(input) {
       version: page.version
     }))
   });
-  await writeJsonl(path99.join(dir, WIKI_PAGES_FILE), layer.pages);
-  await writeJsonl(path99.join(dir, DESCRIBES_FILE), layer.describes);
+  await writeJsonl(path100.join(dir, WIKI_PAGES_FILE), layer.pages);
+  await writeJsonl(path100.join(dir, DESCRIBES_FILE), layer.describes);
   return layer;
 }
 async function defaultLoadValidModules(projectRoot, dataDir) {
@@ -25434,7 +25434,7 @@ function personalizedPageRank(nodes, edges, options) {
 
 // src/gdgraph/repomap.ts
 import { mkdir as mkdir24, writeFile as writeFile18 } from "fs/promises";
-import path102 from "path";
+import path103 from "path";
 function estimateTokens2(text) {
   return Math.ceil(text.length / 4);
 }
@@ -25465,7 +25465,7 @@ function overflowContent(required, missing, budget) {
 `);
 }
 function repomapArtifactPath(cwd) {
-  return path102.join(cwd, ".metaproject", "data", "gdgraph", "artifacts", "repomap.md");
+  return path103.join(cwd, ".metaproject", "data", "gdgraph", "artifacts", "repomap.md");
 }
 function buildRankEdges(graph, config) {
   const edges = [];
@@ -25602,7 +25602,7 @@ function computeRepomap(graph, config, options = {}) {
 async function writeRepomap(cwd, graph, config, options = {}) {
   const result = computeRepomap(graph, config, options);
   const artifactPath = repomapArtifactPath(cwd);
-  await mkdir24(path102.dirname(artifactPath), { recursive: true });
+  await mkdir24(path103.dirname(artifactPath), { recursive: true });
   await writeFile18(artifactPath, result.content, "utf8");
   return { ...result, path: artifactPath };
 }
@@ -25622,7 +25622,7 @@ var init_repomap = __esm(() => {
 // src/gdskills/contracts.ts
 import { readFile as readFile62 } from "fs/promises";
 import { existsSync as existsSync20 } from "fs";
-import path126 from "path";
+import path127 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function loadSchema(name) {
   const contract = CONTRACTS.find((entry) => entry.name === name);
@@ -25633,10 +25633,10 @@ async function loadSchema(name) {
   return JSON.parse(raw);
 }
 function contractPath(contract) {
-  const here = path126.dirname(fileURLToPath2(import.meta.url));
+  const here = path127.dirname(fileURLToPath2(import.meta.url));
   if (contract.sourcePath) {
-    for (const root of [path126.join(here, "..", ".."), path126.join(here, ".."), here]) {
-      const candidate = path126.resolve(root, contract.sourcePath);
+    for (const root of [path127.join(here, "..", ".."), path127.join(here, ".."), here]) {
+      const candidate = path127.resolve(root, contract.sourcePath);
       if (existsSync20(candidate)) {
         return candidate;
       }
@@ -25646,7 +25646,7 @@ function contractPath(contract) {
   if (existsSync20(directPath)) {
     return directPath;
   }
-  const packagedSourcePath = path126.join(here, "..", "src", "gdskills", "contracts", contract.fileName);
+  const packagedSourcePath = path127.join(here, "..", "src", "gdskills", "contracts", contract.fileName);
   if (existsSync20(packagedSourcePath)) {
     return packagedSourcePath;
   }
@@ -25829,7 +25829,7 @@ var init_config_dir = __esm(() => {
 // src/session/preservation.ts
 import { createHash as createHash23, randomUUID as randomUUID3 } from "crypto";
 import { closeSync, fsyncSync, mkdirSync as mkdirSync3, openSync, readdirSync as readdirSync3, readFileSync as readFileSync13, renameSync as renameSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
-import path129 from "path";
+import path130 from "path";
 function syncDir(dir) {
   if (process.platform === "win32")
     return;
@@ -25841,7 +25841,7 @@ function syncDir(dir) {
   }
 }
 function writePreservationFile(file, body) {
-  const dir = path129.dirname(file);
+  const dir = path130.dirname(file);
   mkdirSync3(dir, { recursive: true, mode: 448 });
   const tmp = `${file}.${randomUUID3()}.tmp`;
   const fd = openSync(tmp, "wx", 384);
@@ -25866,11 +25866,11 @@ function writePreservationFile(file, body) {
   }
 }
 function readPreservation(dir, snapshotId) {
-  const base = path129.join(dir, "preservation");
+  const base = path130.join(dir, "preservation");
   let id = snapshotId;
   if (id === undefined) {
     try {
-      id = readFileSync13(path129.join(base, "CURRENT"), "utf8");
+      id = readFileSync13(path130.join(base, "CURRENT"), "utf8");
     } catch (e) {
       if (e.code === "ENOENT")
         return;
@@ -25879,7 +25879,7 @@ function readPreservation(dir, snapshotId) {
   }
   if (!/^[a-f0-9]{64}$/.test(id))
     throw new Error("invalid preservation identity");
-  const read = readTranscriptFile(path129.join(base, "generations", `${id}.json`));
+  const read = readTranscriptFile(path130.join(base, "generations", `${id}.json`));
   if (!read.ok)
     throw new Error(`snapshot unreadable: ${read.reason}`);
   if (hash(read.text) !== id)
@@ -25897,9 +25897,9 @@ function readPreservation(dir, snapshotId) {
   return parsed;
 }
 function readPendingHistory(dir) {
-  let read = readConfigFile(path129.join(dir, "preservation", "HISTORY"));
+  let read = readConfigFile(path130.join(dir, "preservation", "HISTORY"));
   if (!read.ok && read.reason === "absent") {
-    read = readConfigFile(path129.join(dir, "preservation", "MIRRORING"));
+    read = readConfigFile(path130.join(dir, "preservation", "MIRRORING"));
   }
   if (!read.ok) {
     if (read.reason === "absent")
@@ -25923,12 +25923,12 @@ var init_preservation = __esm(() => {
 
 // src/session/slate.ts
 import { mkdir as mkdir33, readFile as readFile66, readdir as readdir23, stat as stat17 } from "fs/promises";
-import path134 from "path";
+import path135 from "path";
 function isSlateSeedKind(value) {
   return typeof value === "string" && SLATE_SEED_KINDS.includes(value);
 }
 function slatePath(dir) {
-  return path134.join(dir, "slate.json");
+  return path135.join(dir, "slate.json");
 }
 function slateLockPath(dir) {
   return `${slatePath(dir)}.lock`;
@@ -26394,7 +26394,7 @@ __export(exports_service10, {
 init_fs();
 init_validator();
 import { mkdir as mkdir13, readFile as readFile39 } from "fs/promises";
-import path77 from "path";
+import path78 from "path";
 
 // src/flow/machine.ts
 var TRANSITIONS = {
@@ -26593,7 +26593,7 @@ function evaluateTaskGate(tasks) {
 }
 
 // src/review/coverage-complete.ts
-import path53 from "path";
+import path54 from "path";
 
 // src/lib/shell-quote.ts
 function shellQuote(value) {
@@ -26611,7 +26611,7 @@ init_fs();
 import { createHash as createHash8 } from "crypto";
 import { existsSync as existsSync9 } from "fs";
 init_fs();
-import path52 from "path";
+import path53 from "path";
 
 // src/review/blast-radius.ts
 init_affected();
@@ -27552,7 +27552,7 @@ var encoder = new TextEncoder;
 // src/review/coverage.ts
 import { existsSync as existsSync8 } from "fs";
 import { readFile as readFile23, realpath as realpath13 } from "fs/promises";
-import path51 from "path";
+import path52 from "path";
 
 // src/review/git-base.ts
 var SHA = /^[0-9a-f]{7,64}$/i;
@@ -29321,6 +29321,85 @@ async function pendingMutants(packageDir) {
   }
   return unjudgedMutants(packageDir, specs);
 }
+// src/review/role-switches.ts
+init_fs();
+init_json();
+import path51 from "path";
+var OPTIONAL_BY_DEFAULT = ["review-clean-code", "review-style"];
+var ROUND_ROLES_FILE = "round-roles.json";
+var ROLE_LINE_PREFIX = "\u043E\u043F\u0446\u0438\u043E\u043D\u0430\u043B\u044C\u043D\u044B\u0435 \u0440\u043E\u043B\u0438 \u043D\u0435 \u0437\u0430\u043F\u0443\u0441\u043A\u0430\u043B\u0438\u0441\u044C:";
+var names = (value, field, warnings) => {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+    warnings.push(`routing.config.json reviewRoles.${field} must be a list of role names; it is ignored`);
+    return [];
+  }
+  return [...new Set(value.map((item) => item.trim()).filter(Boolean))];
+};
+async function readRoleConfig(projectRoot) {
+  const none = { disabled: [], enabled: [], warnings: [] };
+  const file = path51.join(projectRoot, "routing.config.json");
+  if (!await pathExists(file))
+    return none;
+  const read = await readJsonObjectFile(file);
+  if (read.state !== "object")
+    return { ...none, warnings: [`${file} could not be read as a JSON object (${read.state}); reviewRoles is ignored`] };
+  const own = read.value.reviewRoles;
+  if (own === undefined)
+    return none;
+  if (own === null || typeof own !== "object" || Array.isArray(own))
+    return { ...none, warnings: ["routing.config.json reviewRoles must be an object with disabled and enabled lists; it is ignored"] };
+  const fields = own;
+  const warnings = [];
+  return { disabled: names(fields.disabled, "disabled", warnings), enabled: names(fields.enabled, "enabled", warnings), warnings };
+}
+function decideRoleSwitches(input) {
+  const { roster, config, optIn, protectedRoles } = input;
+  const known = new Set(roster);
+  const warnings = [...config.warnings];
+  const off = new Map;
+  for (const name of OPTIONAL_BY_DEFAULT)
+    off.set(name, `optional role, off by default (--style turns it on)`);
+  if (input.configIgnored !== undefined && config.disabled.length > 0)
+    warnings.push(`reviewRoles.disabled not applied: ${input.configIgnored}`);
+  else {
+    for (const name of config.disabled) {
+      if (protectedRoles.has(name))
+        warnings.push(`reviewRoles.disabled: ${name} is a core role that always runs; it stays on`);
+      else if (!known.has(name))
+        warnings.push(`reviewRoles.disabled: unknown role "${name}"; ignored`);
+      else
+        off.set(name, `disabled by routing.config.json reviewRoles.disabled (--with-role ${name} turns it on)`);
+    }
+  }
+  for (const name of config.enabled) {
+    if (!known.has(name) && !OPTIONAL_BY_DEFAULT.includes(name))
+      warnings.push(`reviewRoles.enabled: unknown role "${name}"; ignored`);
+    else
+      off.delete(name);
+  }
+  for (const name of optIn) {
+    if (!known.has(name) && !OPTIONAL_BY_DEFAULT.includes(name))
+      warnings.push(`--with-role: unknown role "${name}"; ignored`);
+    else
+      off.delete(name);
+  }
+  for (const name of [...off.keys()])
+    if (!known.has(name))
+      off.delete(name);
+  return { off, warnings };
+}
+async function packageEnabledRoles(packageDir) {
+  const read = await readJsonObjectFile(path51.join(packageDir, ROUND_ROLES_FILE)).catch(() => {
+    return;
+  });
+  if (read?.state !== "object" || !Array.isArray(read.value.enabled))
+    return [];
+  return read.value.enabled.filter((item) => typeof item === "string" && item.trim() !== "");
+}
+var LINE = new RegExp(`^${ROLE_LINE_PREFIX}.*$`, "m");
+
 // src/review/coverage.ts
 var LIGHT_MAX_FILES = 5;
 var LIGHT_MAX_CHANGED_LINES = 300;
@@ -29332,8 +29411,8 @@ function overlayChangedByRound(reviewer, context) {
     return;
   if (context.files === undefined)
     return `${reviewer.name} is a project overlay and the round's changed files are not recorded, so it cannot be ruled out that this branch wrote it`;
-  const absolute = path51.isAbsolute(reviewer.path) ? reviewer.path : path51.resolve(context.root ?? process.cwd(), reviewer.path);
-  const dir = path51.relative(context.root ?? process.cwd(), path51.dirname(absolute)).split(path51.sep).join("/");
+  const absolute = path52.isAbsolute(reviewer.path) ? reviewer.path : path52.resolve(context.root ?? process.cwd(), reviewer.path);
+  const dir = path52.relative(context.root ?? process.cwd(), path52.dirname(absolute)).split(path52.sep).join("/");
   const changed = context.files.find((file) => file === dir || file.startsWith(`${dir}/`));
   return changed === undefined ? undefined : `${reviewer.name} is a project overlay this round changes (${changed})`;
 }
@@ -29398,7 +29477,7 @@ async function autoDepth(root, input) {
 }
 var ROUND_DEPTH_FILE = "round-depth.json";
 async function packageDepthBasis(packageDir) {
-  const manifest = await readFile23(path51.join(packageDir, "manifest.json"), "utf8").then((t) => JSON.parse(t)).catch(() => {
+  const manifest = await readFile23(path52.join(packageDir, "manifest.json"), "utf8").then((t) => JSON.parse(t)).catch(() => {
     return;
   });
   const head = manifest?.target?.head;
@@ -29407,7 +29486,7 @@ async function packageDepthBasis(packageDir) {
 }
 async function packageChangedLines(packageDir) {
   try {
-    const parsed = JSON.parse(await readFile23(path51.join(packageDir, "scope-files.json"), "utf8"));
+    const parsed = JSON.parse(await readFile23(path52.join(packageDir, "scope-files.json"), "utf8"));
     return typeof parsed?.changedLines === "number" && Number.isFinite(parsed.changedLines) && parsed.changedLines >= 0 ? parsed.changedLines : undefined;
   } catch {
     return;
@@ -29416,7 +29495,7 @@ async function packageChangedLines(packageDir) {
 async function packageRoundDepth(packageDir) {
   let parsed;
   try {
-    parsed = JSON.parse(await readFile23(path51.join(packageDir, ROUND_DEPTH_FILE), "utf8"));
+    parsed = JSON.parse(await readFile23(path52.join(packageDir, ROUND_DEPTH_FILE), "utf8"));
   } catch {
     return;
   }
@@ -29469,7 +29548,7 @@ function derivedFromFiles(files) {
   return picked;
 }
 async function readSkill(root, relativePath) {
-  const file = path51.join(root, relativePath, "SKILL.md");
+  const file = path52.join(root, relativePath, "SKILL.md");
   return existsSync8(file) ? readFile23(file, "utf8").catch(() => {
     return;
   }) : undefined;
@@ -29579,6 +29658,21 @@ async function requiredReviewers(root, mode, files, options = {}) {
       projectGates.set(reviewer.name, reviewer.paths.map(globToRegExp2));
   }
   const filesKnown = files !== undefined;
+  const switches = decideRoleSwitches({
+    roster,
+    config: await readRoleConfig(root),
+    optIn: options.enabledRoles ?? [],
+    protectedRoles: NEVER_SUPERSEDED,
+    configIgnored: files?.some((file) => file === "routing.config.json") ? "this round changes routing.config.json, so a branch cannot switch roles off for its own review" : undefined
+  });
+  const rolesOff = [...switches.off.keys()].sort();
+  const warnings = switches.warnings;
+  const switchedOff = (name) => switches.off.has(name);
+  for (const name of roster)
+    if (switchedOff(name))
+      excluded.push({ reviewer: name, reason: switches.off.get(name) });
+  roster.splice(0, roster.length, ...roster.filter((name) => !switchedOff(name)));
+  const switchFields = { ...warnings.length === 0 ? {} : { warnings }, ...rolesOff.length === 0 ? {} : { rolesOff } };
   if (options.depth === "light") {
     const conventions = lightConventionsReviewer(roster, inventory);
     const keep = new Set([...LIGHT_FIXED_REVIEWERS, ...conventions === undefined ? [] : [conventions]]);
@@ -29591,7 +29685,7 @@ async function requiredReviewers(root, mode, files, options = {}) {
         excluded.push({ reviewer: name, reason: "light round: not part of the light set" });
     const notes = [];
     const kept = applySupersedes(light, inventory, excluded, { root, files }, notes).sort();
-    return { mode, depth: "light", required: kept, excluded, filesKnown, ...notes.length === 0 ? {} : { notes } };
+    return { mode, depth: "light", required: kept, excluded, filesKnown, ...notes.length === 0 ? {} : { notes }, ...switchFields };
   }
   const gated = (name) => {
     if (!filesKnown)
@@ -29633,7 +29727,7 @@ async function requiredReviewers(root, mode, files, options = {}) {
   }
   const notes = [];
   const collapsed = applyOverlapGroups(applySupersedes(required, inventory, excluded, { root, files }, notes), inventory, files, excluded, { root }, notes).sort();
-  return { mode, depth: "full", required: collapsed, excluded, filesKnown, ...notes.length === 0 ? {} : { notes } };
+  return { mode, depth: "full", required: collapsed, excluded, filesKnown, ...notes.length === 0 ? {} : { notes }, ...switchFields };
 }
 async function gitDiffAt(cwd, base, head, pathspec) {
   try {
@@ -29698,7 +29792,7 @@ async function packageDiffStats(options) {
   return packageDiffStatsCached({ packageDir: options.packageDir, root: options.root, target: { ...target, head: target.head } });
 }
 async function readPackageTarget(packageDir) {
-  const manifest = await readFile23(path51.join(packageDir, "manifest.json"), "utf8").then((t) => JSON.parse(t)).catch(() => {
+  const manifest = await readFile23(path52.join(packageDir, "manifest.json"), "utf8").then((t) => JSON.parse(t)).catch(() => {
     return;
   });
   const target = asRecord(asRecord(manifest)?.target) ?? {};
@@ -29737,8 +29831,8 @@ async function diffOfTarget({ packageDir, root, target }) {
   const resolved = await resolveDiffBases(cwd, target);
   if ("error" in resolved)
     return { error: `${UNRESOLVED}: ${resolved.error} (${where(target.recordedBase)})` };
-  const realRoot = await realpath13(path51.resolve(root)).catch(() => path51.resolve(root));
-  const pathspec = notReviewPackagesAt(path51.relative(cwd, realRoot));
+  const realRoot = await realpath13(path52.resolve(root)).catch(() => path52.resolve(root));
+  const pathspec = notReviewPackagesAt(path52.relative(cwd, realRoot));
   const results = await Promise.all(resolved.bases.map((base) => gitDiffAt(cwd, base, target.head, pathspec)));
   const diffs = [];
   for (const [index, result] of results.entries()) {
@@ -29770,7 +29864,7 @@ async function effectiveDepth(record, options) {
 }
 async function packageHead(packageDir) {
   try {
-    const manifest = JSON.parse(await readFile23(path51.join(packageDir, "manifest.json"), "utf8"));
+    const manifest = JSON.parse(await readFile23(path52.join(packageDir, "manifest.json"), "utf8"));
     return typeof manifest.target?.head === "string" && manifest.target.head.trim() !== "" ? manifest.target.head.trim() : undefined;
   } catch {
     return;
@@ -29779,7 +29873,8 @@ async function packageHead(packageDir) {
 async function reviewersLeftOut(packageDir, selected) {
   const need = await requiredReviewers(projectRootOfPackage(packageDir), "all", await packageScopeFiles(packageDir), {
     blastRadius: await packageHasBlastRadius(packageDir),
-    prContext: packageHasPrContext(packageDir)
+    prContext: packageHasPrContext(packageDir),
+    enabledRoles: await packageEnabledRoles(packageDir)
   });
   return { required: need.required, missing: selected === undefined ? need.required : need.required.filter((role) => !selected.includes(role)) };
 }
@@ -29800,7 +29895,7 @@ async function unconfirmedDecision(options, kind, selected) {
   return `${stale}${writersFor(kind, dir)}`;
 }
 function writersFor(kind, packageDir) {
-  return decisionWriters(kind, packageDir === undefined ? "<review-dir>" : path51.relative(process.cwd(), packageDir) || ".");
+  return decisionWriters(kind, packageDir === undefined ? "<review-dir>" : path52.relative(process.cwd(), packageDir) || ".");
 }
 async function mutationErrors(record, options, depth) {
   const pending = options.pendingMutants ?? 0;
@@ -29826,14 +29921,14 @@ async function mutationErrors(record, options, depth) {
 }
 async function packageHasBlastRadius(packageDir, name = "blast-radius.json") {
   try {
-    const parsed = JSON.parse(await readFile23(path51.join(packageDir, name), "utf8"));
+    const parsed = JSON.parse(await readFile23(path52.join(packageDir, name), "utf8"));
     return Array.isArray(parsed?.files) && Array.isArray(parsed?.changedFiles);
   } catch {
     return false;
   }
 }
 function packageHasPrContext(packageDir, name = "pr-context.md") {
-  return existsSync8(path51.join(packageDir, name));
+  return existsSync8(path52.join(packageDir, name));
 }
 async function coverageErrors(dispatch, options) {
   const record = asRecord(dispatch);
@@ -29865,7 +29960,8 @@ async function reviewerSetErrors(dispatch, options, effective) {
   const need = await requiredReviewers(options.root, record.mode, options.files, {
     blastRadius: options.blastRadius,
     prContext: options.prContext === true && dispatchKnowsRole(record, PR_CONTRACT),
-    depth: effective?.depth ?? "full"
+    depth: effective?.depth ?? "full",
+    enabledRoles: options.packageDir === undefined ? [] : await packageEnabledRoles(options.packageDir)
   });
   const selected = new Set(Array.isArray(record.selected) ? record.selected.filter(text) : []);
   const skips = dispatchSkips(record).filter((skip) => need.required.includes(skip.reviewer) && !selected.has(skip.reviewer));
@@ -29925,20 +30021,20 @@ function dispatchSkips(dispatch) {
 }
 async function packageScopeFiles(packageDir) {
   try {
-    const parsed = JSON.parse(await readFile23(path51.join(packageDir, "scope-files.json"), "utf8"));
+    const parsed = JSON.parse(await readFile23(path52.join(packageDir, "scope-files.json"), "utf8"));
     return Array.isArray(parsed?.files) && parsed.files.every((f) => typeof f === "string") ? parsed.files : undefined;
   } catch {
     return;
   }
 }
 function projectRootOfPackage(packageDir) {
-  const resolved = path51.resolve(packageDir);
-  const parts = resolved.split(path51.sep);
+  const resolved = path52.resolve(packageDir);
+  const parts = resolved.split(path52.sep);
   const at = parts.lastIndexOf(".metaproject");
   if (at > 0)
-    return parts.slice(0, at).join(path51.sep) || path51.sep;
+    return parts.slice(0, at).join(path52.sep) || path52.sep;
   const found = resolveProjectRoot(resolved);
-  return found !== resolved ? found : path51.resolve(resolved, "..", "..", "..");
+  return found !== resolved ? found : path52.resolve(resolved, "..", "..", "..");
 }
 
 // src/review/conform-state.ts
@@ -30093,14 +30189,14 @@ var CHUNK_STATE_FILE = "chunk-state.json";
 var CHUNK_REVIEWER = BLAST_RADIUS_SCOPE_REVIEWER;
 var readJson = (file) => readJsonFileOr(file, undefined);
 async function readChunkPlan(packageDir) {
-  const plan = await readJson(path52.join(packageDir, CHUNKS_FILE));
+  const plan = await readJson(path53.join(packageDir, CHUNKS_FILE));
   return plan !== undefined && Array.isArray(plan.chunks) ? plan : undefined;
 }
 function emptyChunkState() {
   return { schemaVersion: 1, retry: emptyRetryState(), derived: [], outcomes: {} };
 }
 async function readChunkState(packageDir) {
-  const state = await readJson(path52.join(packageDir, CHUNK_STATE_FILE));
+  const state = await readJson(path53.join(packageDir, CHUNK_STATE_FILE));
   return state !== undefined && state.retry !== undefined && Array.isArray(state.derived) && state.outcomes !== undefined ? state : emptyChunkState();
 }
 var textOf = (entry) => `${entry.files.join(`
@@ -30197,7 +30293,7 @@ async function computeChunkPass(packageDir) {
   return pass;
 }
 function hasChunkPlan(packageDir) {
-  return existsSync9(path52.join(packageDir, CHUNKS_FILE));
+  return existsSync9(path53.join(packageDir, CHUNKS_FILE));
 }
 
 // src/review/coverage-complete.ts
@@ -30207,7 +30303,7 @@ var SLICE_MANIFEST_COPY = "slice-manifest.json";
 var readJson2 = (file) => readJsonFileOr(file, undefined);
 var text2 = (value) => typeof value === "string" && value.trim().length > 0;
 async function readManifest(packageDir) {
-  for (const candidate of [path53.join(packageDir, "slices", "manifest.json"), path53.join(packageDir, SLICE_MANIFEST_COPY)]) {
+  for (const candidate of [path54.join(packageDir, "slices", "manifest.json"), path54.join(packageDir, SLICE_MANIFEST_COPY)]) {
     const found = await readJson2(candidate);
     if (found !== undefined && Array.isArray(found.slices))
       return found;
@@ -30245,9 +30341,9 @@ function scopeBRunComplete(dispatch) {
 async function packageRecordsCoverage(packageDir, research) {
   if (hasChunkPlan(packageDir))
     return true;
-  if (await readJson2(path53.join(packageDir, COVERAGE_FILE)) !== undefined)
+  if (await readJson2(path54.join(packageDir, COVERAGE_FILE)) !== undefined)
     return true;
-  const ledger = research ?? await readJson2(path53.join(packageDir, "research.json"));
+  const ledger = research ?? await readJson2(path54.join(packageDir, "research.json"));
   return dispatchRunRecords(asRecord(ledger)?.dispatch).some((run) => Array.isArray(run.coveredSlices));
 }
 function readCoverageWaiver(dispatch) {
@@ -30261,11 +30357,11 @@ function readCoverageWaiver(dispatch) {
   return { operatorQuote: waiver.operatorQuote, time: waiver.time, files, ...via === undefined ? {} : { confirmedVia: via }, ...cardPressFields({ pressedBy, pressedAt }) };
 }
 async function computeCoverage(packageDir, options = {}) {
-  const research = options.research ?? await readJson2(path53.join(packageDir, "research.json"));
+  const research = options.research ?? await readJson2(path54.join(packageDir, "research.json"));
   const dispatch = asRecord(asRecord(research)?.dispatch);
-  const radius = await readJson2(path53.join(packageDir, "blast-radius.json"));
+  const radius = await readJson2(path54.join(packageDir, "blast-radius.json"));
   const manifest = await readManifest(packageDir);
-  const retry = await readJson2(path53.join(packageDir, "retry-state.json"));
+  const retry = await readJson2(path54.join(packageDir, "retry-state.json"));
   const scopeA = await packageScopeFiles(packageDir) ?? [];
   const chunkPass = hasChunkPlan(packageDir) ? await computeChunkPass(packageDir) : null;
   const radiusFiles = (radius?.files ?? []).map((entry) => entry.file).filter(text2);
@@ -30353,7 +30449,7 @@ async function coverageGateErrors(packageDir, research) {
   const uncovered = report.files.filter((entry) => entry.status === "uncovered");
   const first = uncovered.slice(0, FIRST_FILES).map((entry) => entry.file);
   const more = uncovered.length > FIRST_FILES ? `, \u2026 (+${uncovered.length - FIRST_FILES})` : "";
-  const dir = shellWord(path53.relative(process.cwd(), packageDir) || ".");
+  const dir = shellWord(path54.relative(process.cwd(), packageDir) || ".");
   const chunkWork = uncovered.some((entry) => entry.scope === "B");
   const sliceWork = uncovered.some((entry) => entry.scope === "A");
   const commands = [
@@ -30422,7 +30518,7 @@ function dispatchErrors(value) {
 
 // src/review/research.ts
 import { readFile as readFile24 } from "fs/promises";
-import path54 from "path";
+import path55 from "path";
 function researchErrors(value, findings) {
   const ledger = asRecord(value);
   if (ledger === undefined)
@@ -30486,7 +30582,7 @@ async function packageResearchErrors(packageDir, artifacts, findings, options =
   if (a.research !== "research.json")
     return ["invalid research artifact locator"];
   try {
-    const ledger = JSON.parse(await readFile24(path54.join(packageDir, "research.json"), "utf8"));
+    const ledger = JSON.parse(await readFile24(path55.join(packageDir, "research.json"), "utf8"));
     const recorded = ledger?.dispatch !== undefined;
     const checked = a.reviewerDispatch !== undefined || recorded;
     const mismatch = recorded && a.reviewerDispatch === undefined ? ['research.json records a reviewer dispatch but manifest.json does not declare it: restore artifacts.reviewerDispatch "research.json"'] : [];
@@ -30549,11 +30645,11 @@ var CARRIED_PREMISE_CONTEXT = new Set(["judge", "model", "operator"]);
 // src/flow/review-gate.ts
 init_fs();
 import { readFile as readFile27 } from "fs/promises";
-import path57 from "path";
+import path58 from "path";
 
 // src/review/package-location.ts
 import { readdir as readdir12, readFile as readFile25 } from "fs/promises";
-import path55 from "path";
+import path56 from "path";
 
 // src/lib/map-bounded.ts
 async function mapBounded(items, limit, map) {
@@ -30569,15 +30665,15 @@ async function mapBounded(items, limit, map) {
 
 // src/review/package-location.ts
 function reviewsRoot(cwd) {
-  return path55.join(cwd, ".metaproject", "reviews");
+  return path56.join(cwd, ".metaproject", "reviews");
 }
 function flowReviewsRoot(cwd, flowDir) {
-  return path55.join(flowsRoot(cwd), flowDir, "reviews");
+  return path56.join(flowsRoot(cwd), flowDir, "reviews");
 }
 async function readManifestHead(packageDir) {
   let manifest;
   try {
-    manifest = JSON.parse(await readFile25(path55.join(packageDir, "manifest.json"), "utf8"));
+    manifest = JSON.parse(await readFile25(path56.join(packageDir, "manifest.json"), "utf8"));
   } catch {
     return;
   }
@@ -30589,13 +30685,13 @@ async function readManifestHead(packageDir) {
   return { reviewId: str(fields.reviewId), mode: str(fields.mode), status: str(fields.status), flowId: str(flow.id), flowPath: str(flow.path) };
 }
 function boundToFlow(head, flowDir) {
-  if (head.flowPath !== undefined && path55.posix.normalize(head.flowPath.split(path55.sep).join("/")) === path55.posix.join(".metaproject", "flows", flowDir))
+  if (head.flowPath !== undefined && path56.posix.normalize(head.flowPath.split(path56.sep).join("/")) === path56.posix.join(".metaproject", "flows", flowDir))
     return true;
   return head.flowId !== undefined && head.flowId !== "" && (flowDir === head.flowId || flowDir.startsWith(`${head.flowId}-`));
 }
 async function dirsUnder(root) {
   try {
-    return (await readdir12(root, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path55.join(root, entry.name));
+    return (await readdir12(root, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path56.join(root, entry.name));
   } catch {
     return [];
   }
@@ -30615,8 +30711,8 @@ async function flowPackageDirs(cwd, flowDir, standalone) {
   return [...own, ...heads.filter(({ head }) => boundToFlow(head, flowDir)).map(({ dir }) => dir)];
 }
 var REVIEW_PACKAGE_MANIFEST_GLOBS = [
-  path55.posix.join(".metaproject", "reviews", "*", "manifest.json"),
-  path55.posix.join(".metaproject", "flows", "*", "reviews", "*", "manifest.json")
+  path56.posix.join(".metaproject", "reviews", "*", "manifest.json"),
+  path56.posix.join(".metaproject", "flows", "*", "reviews", "*", "manifest.json")
 ];
 
 // src/review/loop.ts
@@ -30660,12 +30756,12 @@ function normalizeText(value) {
 // src/review/pr-comments.ts
 init_fs();
 import { readFile as readFile26 } from "fs/promises";
-import path56 from "path";
+import path57 from "path";
 var SEVERITY_SET = new Set(["blocker", "major", "minor", "info"]);
 var KNOWN_REVIEW_STATES = new Set(["APPROVED", "CHANGES_REQUESTED", "COMMENTED", "DISMISSED", "PENDING"]);
 var PR_COMMENT_STATE_VERSION = 1;
 function prCommentsStatePath(cwd, repo, number) {
-  return path56.join(cwd, ".metaproject", "reviews", "pr-comments", `${repo.replace(/\//g, "__")}__${number}.json`);
+  return path57.join(cwd, ".metaproject", "reviews", "pr-comments", `${repo.replace(/\//g, "__")}__${number}.json`);
 }
 function emptyPrCommentState(repo, number) {
   return {
@@ -30724,7 +30820,7 @@ function safeFsErrorCode(error) {
   return typeof code === "string" && /^[A-Z][A-Z0-9]{2,15}$/.test(code) ? code : undefined;
 }
 async function readReviewGateConfig(cwd) {
-  const file = path57.join(cwd, REVIEW_GATE_CONFIG_PATH);
+  const file = path58.join(cwd, REVIEW_GATE_CONFIG_PATH);
   if (!await pathExists(file)) {
     return { ...DEFAULT_REVIEW_GATE_CONFIG, notes: [] };
   }
@@ -30876,13 +30972,13 @@ function matchNumber(text, key) {
 async function readReviewRounds(cwd, flowDir) {
   const rounds = [];
   for (const packageDir of await flowPackageDirs(cwd, flowDir)) {
-    const name = path57.basename(packageDir);
+    const name = path58.basename(packageDir);
     const problems = [];
-    const manifest = readRecord(await readJson3(path57.join(packageDir, "manifest.json")));
+    const manifest = readRecord(await readJson3(path58.join(packageDir, "manifest.json")));
     if (manifest === null) {
       problems.push("manifest.json is missing or unreadable");
     }
-    const rawFindings = await readJson3(path57.join(packageDir, "findings.json"));
+    const rawFindings = await readJson3(path58.join(packageDir, "findings.json"));
     if (!Array.isArray(rawFindings)) {
       problems.push("findings.json is missing, unreadable, or not an array");
     }
@@ -30900,14 +30996,14 @@ async function readReviewRounds(cwd, flowDir) {
         }
       ];
     }) : [];
-    const scopePath = path57.join(packageDir, "scope.md");
+    const scopePath = path58.join(packageDir, "scope.md");
     const scope = await pathExists(scopePath) ? await readScopeMarkdown(scopePath) : null;
     const completeness = readString(manifest?.["status"]) !== "closed" && await packageRecordsCoverage(packageDir);
     problems.push(...await packageResearchErrors(packageDir, manifest?.["artifacts"], rawFindings, { completeness }));
     const findings = Array.isArray(rawFindings) ? await findingsWithHolds(rawFindings.map((item, index) => toGateFinding(item, reviewId, index)), packageDir, problems) : [];
     rounds.push({
       reviewId,
-      dir: path57.relative(cwd, packageDir),
+      dir: path58.relative(cwd, packageDir),
       sortKey: readString(manifest?.["createdAt"]) ?? name,
       ingested: problems.length === 0,
       problems,
@@ -31194,7 +31290,7 @@ var durableExternalCommentsGate = async (input) => {
     return {
       collected: false,
       unanswered: [],
-      detail: `nothing records whether anyone commented on ${ref.repo}#${ref.number} ` + `(\`${path57.relative(input.cwd, file)}\` does not exist). Zero collected comments and no collection at ` + "all are different facts, and only one of them is clean. Run " + `\`keryx review comments collect --repo ${ref.repo} --pr ${ref.number} --sha <pr-head>\`, or inject ` + "`FlowServiceDeps.externalCommentsGate` with a collector of your own."
+      detail: `nothing records whether anyone commented on ${ref.repo}#${ref.number} ` + `(\`${path58.relative(input.cwd, file)}\` does not exist). Zero collected comments and no collection at ` + "all are different facts, and only one of them is clean. Run " + `\`keryx review comments collect --repo ${ref.repo} --pr ${ref.number} --sha <pr-head>\`, or inject ` + "`FlowServiceDeps.externalCommentsGate` with a collector of your own."
     };
   }
   const state = await readPrCommentState(input.cwd, ref.repo, ref.number);
@@ -31783,14 +31879,14 @@ function describeIdentity(identity) {
 // src/review/flow-move.ts
 init_fs();
 import { readdir as readdir14, readFile as readFile29, rename as rename3 } from "fs/promises";
-import path61 from "path";
+import path62 from "path";
 
 // src/review/review-notes.ts
 init_fs();
 init_store();
-import path60 from "path";
+import path61 from "path";
 function reviewNotesDir(cwd) {
-  return path60.join(memoryRoot(cwd), "review-notes");
+  return path61.join(memoryRoot(cwd), "review-notes");
 }
 
 // src/review/flow-move.ts
@@ -31798,16 +31894,16 @@ var RECORDED_FLOWS_ROOT = ".metaproject/flows";
 var SCOPE_FLOW_LINE = /^flow: (\d{3})\b/m;
 var NOTE_PATH_LINE = /^(- (?:Link|Location): `?)([^`\s]+)/gm;
 async function moveFlowDirWithReviewRecords(move) {
-  const fromRoot = path61.join(flowsRoot(move.cwd), move.fromDir);
-  const toRoot = path61.join(flowsRoot(move.cwd), move.toDir);
-  const plan = await planReviewRecordRewrites(move, fromRoot, (file) => path61.relative(move.cwd, file.startsWith(`${fromRoot}${path61.sep}`) ? path61.join(toRoot, path61.relative(fromRoot, file)) : file));
+  const fromRoot = path62.join(flowsRoot(move.cwd), move.fromDir);
+  const toRoot = path62.join(flowsRoot(move.cwd), move.toDir);
+  const plan = await planReviewRecordRewrites(move, fromRoot, (file) => path62.relative(move.cwd, file.startsWith(`${fromRoot}${path62.sep}`) ? path62.join(toRoot, path62.relative(fromRoot, file)) : file));
   const written = [];
   try {
     for (const rewrite of plan.rewrites) {
       await writeFileAtomic(rewrite.current, rewrite.after);
       written.push(rewrite);
     }
-    await rename3(path61.join(flowsRoot(move.cwd), move.fromDir), path61.join(flowsRoot(move.cwd), move.toDir));
+    await rename3(path62.join(flowsRoot(move.cwd), move.fromDir), path62.join(flowsRoot(move.cwd), move.toDir));
   } catch (error) {
     const unrestored = await restore(written);
     if (unrestored.length > 0) {
@@ -31833,14 +31929,14 @@ async function planReviewRecordRewrites(move, packagesRoot, finalOf) {
   const newPrefix = `${RECORDED_FLOWS_ROOT}/${move.toDir}`;
   const movePath = (value) => value === oldPrefix || value.startsWith(`${oldPrefix}/`) ? `${newPrefix}${value.slice(oldPrefix.length)}` : value;
   const plan = { rewrites: [], unreadable: [] };
-  const reviewsDir = path61.join(packagesRoot, "reviews");
+  const reviewsDir = path62.join(packagesRoot, "reviews");
   if (await pathExists(reviewsDir)) {
     for (const entry of await readdir14(reviewsDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const packageDir = path61.join(reviewsDir, entry.name);
-      await planJson(plan, path61.join(packageDir, "manifest.json"), finalOf, (value) => {
+      const packageDir = path62.join(reviewsDir, entry.name);
+      await planJson(plan, path62.join(packageDir, "manifest.json"), finalOf, (value) => {
         const moved = mapStrings(value, movePath);
         const flow = asRecord3(asRecord3(moved)?.["flow"]);
         if (flow !== null && flow["id"] === move.from) {
@@ -31848,8 +31944,8 @@ async function planReviewRecordRewrites(move, packagesRoot, finalOf) {
         }
         return moved;
       });
-      await planJson(plan, path61.join(packageDir, "findings.json"), finalOf, (value) => mapStrings(value, movePath));
-      await planText(plan, path61.join(packageDir, "scope.md"), finalOf, (text) => text.replace(SCOPE_FLOW_LINE, (line, id) => id === move.from ? `flow: ${move.to}` : line));
+      await planJson(plan, path62.join(packageDir, "findings.json"), finalOf, (value) => mapStrings(value, movePath));
+      await planText(plan, path62.join(packageDir, "scope.md"), finalOf, (text) => text.replace(SCOPE_FLOW_LINE, (line, id) => id === move.from ? `flow: ${move.to}` : line));
     }
   }
   const notesDir = reviewNotesDir(move.cwd);
@@ -31858,7 +31954,7 @@ async function planReviewRecordRewrites(move, packagesRoot, finalOf) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) {
         continue;
       }
-      await planText(plan, path61.join(notesDir, entry.name), finalOf, (text) => text.replace(NOTE_PATH_LINE, (_line, lead, value) => `${lead}${movePath(value)}`));
+      await planText(plan, path62.join(notesDir, entry.name), finalOf, (text) => text.replace(NOTE_PATH_LINE, (_line, lead, value) => `${lead}${movePath(value)}`));
     }
   }
   return plan;
@@ -31909,7 +32005,7 @@ function asRecord3(value) {
 }
 
 // src/flow/ac-reseal.ts
-import path62 from "path";
+import path63 from "path";
 async function acFileUnchangedSinceHead(cwd, acRelativePath) {
   if (!Bun.which("git")) {
     return { clean: false, reason: "git is not on PATH, so the file's state cannot be established" };
@@ -31960,7 +32056,7 @@ async function acFileUnchangedSinceHead(cwd, acRelativePath) {
   return { clean: true };
 }
 function acRelativePathFor(flowsRootRelative, dir) {
-  return path62.posix.join(flowsRootRelative, dir, "acceptance-criteria.md");
+  return path63.posix.join(flowsRootRelative, dir, "acceptance-criteria.md");
 }
 
 // src/flow/schema.ts
@@ -32306,7 +32402,7 @@ function flowStateSchema() {
 init_fs();
 init_config2();
 import { readFile as readFile30 } from "fs/promises";
-import path65 from "path";
+import path66 from "path";
 
 // src/memory/inject.ts
 init_config2();
@@ -32463,7 +32559,7 @@ ${renderMemorySearchReportMarkdown(report, { includeHeader: false }).trimEnd()}`
     ".metaproject/data/gdgraph/artifacts/summary.md",
     ".metaproject/data/gdgraph/artifacts/module-map.json"
   ]) {
-    if (await pathExists(path65.join(cwd, rel))) {
+    if (await pathExists(path66.join(cwd, rel))) {
       graphRefs.push(`- \`${rel}\``);
     }
   }
@@ -32475,7 +32571,7 @@ ${graphRefs.join(`
 
 Use \`keryx gdgraph affected <file>\` for blast radius.`);
   }
-  const healthLatest = path65.join(cwd, ".metaproject", "data", "health", "artifacts", "latest.json");
+  const healthLatest = path66.join(cwd, ".metaproject", "data", "health", "artifacts", "latest.json");
   if (await pathExists(healthLatest)) {
     try {
       const report = JSON.parse(await readFile30(healthLatest, "utf8"));
@@ -32485,7 +32581,7 @@ Use \`keryx gdgraph affected <file>\` for blast radius.`);
 - refresh: \`keryx health run\``);
     } catch {}
   }
-  const manifestPath = path65.join(cwd, ".metaproject", "metaproject.json");
+  const manifestPath = path66.join(cwd, ".metaproject", "metaproject.json");
   if (await pathExists(manifestPath)) {
     try {
       const manifest = JSON.parse(await readFile30(manifestPath, "utf8"));
@@ -32527,13 +32623,13 @@ var DEFAULT_TASKS = [
 init_fs();
 import { createHash as createHash10, randomBytes as randomBytes4 } from "crypto";
 import { readFile as readFile31 } from "fs/promises";
-import path66 from "path";
+import path67 from "path";
 var CONFIRMATION_TOKEN_TTL_MS = 10 * 60000;
 var CONFIRMATION_CAVEAT = "The token proves an interactive confirmation step ran outside the agent's tool roster, within its TTL, " + "for this criteria checksum \u2014 not that a human ran it, and not who.";
 var CONFIRM_TOKEN_FILE = "confirm-token.json";
 var TOKEN_REF_LENGTH = 12;
 function confirmTokenPath(cwd, dir) {
-  return path66.join(flowsRoot(cwd), dir, CONFIRM_TOKEN_FILE);
+  return path67.join(flowsRoot(cwd), dir, CONFIRM_TOKEN_FILE);
 }
 function completionTarget(input) {
   return input.merged ? "merged" : `pr:${input.prUrl ?? "none"}`;
@@ -32648,7 +32744,7 @@ function describeConfirmationFailure(reason, flowId) {
 }
 async function readRequireConfirmationDefault(cwd) {
   try {
-    const parsed = JSON.parse(await readFile31(path66.join(cwd, REVIEW_GATE_CONFIG_PATH), "utf8"));
+    const parsed = JSON.parse(await readFile31(path67.join(cwd, REVIEW_GATE_CONFIG_PATH), "utf8"));
     if (typeof parsed !== "object" || parsed === null)
       return false;
     const completion = parsed["completion"];
@@ -32772,7 +32868,7 @@ async function githubPostReview(url, event, body) {
   }
 }
 // src/flow/uncommitted-state.ts
-import path67 from "path";
+import path68 from "path";
 var UNCOMMITTED_LIST_CAP = 5;
 var READ_ONLY_GIT_FLAGS = ["--no-optional-locks"];
 var GIT_TIMEOUT_MS2 = 5000;
@@ -32849,7 +32945,7 @@ async function readGit(cwd, scope, git) {
 }
 async function uncommittedFlowStateNote(cwd, flowId, dir, git = spawnGit) {
   try {
-    const read = await readGit(cwd, path67.join(flowsRoot(cwd), dir), git);
+    const read = await readGit(cwd, path68.join(flowsRoot(cwd), dir), git);
     return read === null ? null : noteFor(flowId, dir, read);
   } catch {
     return null;
@@ -33055,7 +33151,7 @@ function readAcKindRecords(value) {
 }
 // src/flow/description-intent.ts
 import { readFile as readFile32 } from "fs/promises";
-import path68 from "path";
+import path69 from "path";
 var OUTCOME_HINT = 'State an outcome criterion: what you would look at afterwards to see this helped, as a bullet. Or write "- not measured \u2014 <reason>".';
 var PLACEHOLDERS = ["Describe the problem precisely", "What must be true when this flow is done"];
 var FLOW_STATEMENT_HEADINGS = [/^problem$/i, /^expected outcome$/i];
@@ -33168,7 +33264,7 @@ function initIntentNote(description) {
 }
 async function intentNoteForNewFlow(cwd, dir) {
   try {
-    return initIntentNote(await readFile32(path68.join(cwd, dir, "description.md"), "utf8"));
+    return initIntentNote(await readFile32(path69.join(cwd, dir, "description.md"), "utf8"));
   } catch {
     return null;
   }
@@ -33176,7 +33272,7 @@ async function intentNoteForNewFlow(cwd, dir) {
 // src/flow/check-ac.ts
 import { createHash as createHash11 } from "crypto";
 import { chmod as chmod4, mkdir as mkdir11, readFile as readFile33 } from "fs/promises";
-import path69 from "path";
+import path70 from "path";
 init_service2();
 init_fs();
 var AC_LINE2 = /^\s*[-*]\s*(AC\d+)\s*:\s?(.*)$/i;
@@ -33357,7 +33453,7 @@ function factsOnlyVerdict(item) {
 }
 async function readAcCheckEnabled(cwd) {
   try {
-    const parsed = JSON.parse(await readFile33(path69.join(cwd, REVIEW_GATE_CONFIG_PATH), "utf8"));
+    const parsed = JSON.parse(await readFile33(path70.join(cwd, REVIEW_GATE_CONFIG_PATH), "utf8"));
     if (typeof parsed !== "object" || parsed === null)
       return false;
     const review = parsed["review"];
@@ -33378,7 +33474,7 @@ function acCheckCacheKey(criteriaChecksum, diffText) {
   return `${criteriaChecksum}:${hashDiff(diffText)}`;
 }
 function acCheckCachePath(cwd, flowDir) {
-  return path69.join(cwd, ".metaproject", "data", "ac-check", `${flowDir}.json`);
+  return path70.join(cwd, ".metaproject", "data", "ac-check", `${flowDir}.json`);
 }
 async function readAcCheckCache(cachePath) {
   if (!await pathExists(cachePath))
@@ -33390,7 +33486,7 @@ async function readAcCheckCache(cachePath) {
   }
 }
 async function writeAcCheckCache(cachePath, record) {
-  await mkdir11(path69.dirname(cachePath), { recursive: true });
+  await mkdir11(path70.dirname(cachePath), { recursive: true });
   await writeFileAtomic(cachePath, `${JSON.stringify(record, null, 2)}
 `, { mode: 384 });
   if (process.platform !== "win32") {
@@ -33448,10 +33544,10 @@ function renderAcCheckAdvisoryNotice(verdicts) {
 }
 // src/flow/allocation.ts
 import { appendFile as appendFile3, mkdir as mkdir12, readFile as readFile34 } from "fs/promises";
-import path71 from "path";
+import path72 from "path";
 
 // src/lib/clone-scope.ts
-import path70 from "path";
+import path71 from "path";
 async function gitCommonDir(cwd) {
   try {
     const proc = Bun.spawn(["git", "rev-parse", "--git-common-dir"], {
@@ -33463,7 +33559,7 @@ async function gitCommonDir(cwd) {
     if (await proc.exited !== 0 || output.length === 0) {
       return null;
     }
-    return path70.isAbsolute(output) ? output : path70.resolve(cwd, output);
+    return path71.isAbsolute(output) ? output : path71.resolve(cwd, output);
   } catch {
     return null;
   }
@@ -33488,23 +33584,23 @@ function projectKey(toplevel, cwd) {
   if (!toplevel) {
     return "root";
   }
-  const relative = path71.relative(toplevel, cwd);
+  const relative = path72.relative(toplevel, cwd);
   return relative === "" ? "root" : slugify(relative);
 }
 async function resolveAllocationScope(cwd) {
   const commonDir = await gitCommonDir(cwd);
   if (!commonDir) {
     return {
-      lockPath: path71.join(flowsRoot(cwd), ".flow-init.lock"),
+      lockPath: path72.join(flowsRoot(cwd), ".flow-init.lock"),
       ledgerPath: null,
       project: "root"
     };
   }
   const key = projectKey(await gitToplevel(cwd), cwd);
-  const dir = path71.join(commonDir, "keryx", "flow-ids");
+  const dir = path72.join(commonDir, "keryx", "flow-ids");
   return {
-    lockPath: path71.join(dir, `${key}.lock`),
-    ledgerPath: path71.join(dir, `${key}.jsonl`),
+    lockPath: path72.join(dir, `${key}.lock`),
+    ledgerPath: path72.join(dir, `${key}.jsonl`),
     project: key
   };
 }
@@ -33537,13 +33633,13 @@ async function recordAllocation(scope, record) {
   if (!scope.ledgerPath) {
     return;
   }
-  await mkdir12(path71.dirname(scope.ledgerPath), { recursive: true });
+  await mkdir12(path72.dirname(scope.ledgerPath), { recursive: true });
   await appendFile3(scope.ledgerPath, `${JSON.stringify(record)}
 `, "utf8");
 }
 
 // src/flow/remote-flows.ts
-import path72 from "path";
+import path73 from "path";
 var MAX_REFS = 500;
 var CONCURRENCY = 8;
 async function runGit2(cwd, args) {
@@ -33624,7 +33720,7 @@ async function flowDirsOnRef(cwd, ref, flowsPath) {
   if (result === undefined || result.code !== 0) {
     return [];
   }
-  return nulSplit(result.stdout).map((entry) => path72.posix.basename(entry)).filter((name) => /^\d{3}-/.test(name));
+  return nulSplit(result.stdout).map((entry) => path73.posix.basename(entry)).filter((name) => /^\d{3}-/.test(name));
 }
 async function knownRemoteFlowDirs(cwd) {
   try {
@@ -33804,12 +33900,12 @@ function renderJournal(createdAt) {
 
 // src/flow/task-project-context.ts
 import { readFile as readFile38 } from "fs/promises";
-import path76 from "path";
+import path77 from "path";
 
 // src/gdskills/project-context-config.ts
 init_fs();
 import { readFile as readFile35 } from "fs/promises";
-import path73 from "path";
+import path74 from "path";
 var PROJECT_CONTEXT_CONFIG_PATH = ".metaproject/tasks.config.json";
 var DEFAULT_MAX_BYTES = 131072;
 var MAX_BYTES_FLOOR = 4096;
@@ -33819,7 +33915,7 @@ function isValidMaxBytes(value) {
 }
 async function readRoot(projectRoot) {
   try {
-    const parsed = JSON.parse(await readFile35(path73.join(projectRoot, PROJECT_CONTEXT_CONFIG_PATH), "utf8"));
+    const parsed = JSON.parse(await readFile35(path74.join(projectRoot, PROJECT_CONTEXT_CONFIG_PATH), "utf8"));
     return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : undefined;
   } catch {
     return;
@@ -33863,7 +33959,7 @@ async function readProjectContextConfig(projectRoot) {
 
 // src/gdskills/resolved-context-check.ts
 import { readFile as readFile37 } from "fs/promises";
-import path75 from "path";
+import path76 from "path";
 
 // src/gdskills/project-rules.ts
 import { createHash as createHash12 } from "crypto";
@@ -33876,7 +33972,7 @@ function sha256Hex(content) {
 
 // src/gdskills/reference-proof.ts
 import { readFile as readFile36 } from "fs/promises";
-import path74 from "path";
+import path75 from "path";
 
 // src/gdskills/references-section.ts
 var FENCE = /^ {0,3}(`{3,}|~{3,})/;
@@ -33982,7 +34078,7 @@ function pickProofItem(items, pinned) {
   return items.find((item) => item.sha256 === pinned && item.how !== "n/a") ?? items.find((item) => item.how !== "n/a") ?? items[0];
 }
 async function currentSection(projectRoot, entry) {
-  const file = path74.isAbsolute(entry.path) ? entry.path : path74.join(projectRoot, entry.path);
+  const file = path75.isAbsolute(entry.path) ? entry.path : path75.join(projectRoot, entry.path);
   let text;
   try {
     text = await readFile36(file, "utf8");
@@ -34074,7 +34170,7 @@ function appliedOf(result) {
 }
 async function currentSha(projectRoot, entryPath) {
   try {
-    return sha256Hex(await readFile37(path75.isAbsolute(entryPath) ? entryPath : path75.join(projectRoot, entryPath), "utf8"));
+    return sha256Hex(await readFile37(path76.isAbsolute(entryPath) ? entryPath : path76.join(projectRoot, entryPath), "utf8"));
   } catch {
     return;
   }
@@ -34153,8 +34249,8 @@ async function checkTaskProjectContext(input) {
   }
   const report = await checkResolvedContext({
     projectRoot: input.projectRoot,
-    resolved: await readResolvedFile(path76.resolve(input.projectRoot, input.resolvedFile)),
-    result: await readResultFile(path76.resolve(input.projectRoot, input.resultFile))
+    resolved: await readResolvedFile(path77.resolve(input.projectRoot, input.resolvedFile)),
+    result: await readResultFile(path77.resolve(input.projectRoot, input.resultFile))
   });
   const lines = formatResolvedReport(report);
   if (lines.length === 0)
@@ -34468,7 +34564,7 @@ function createFlowService(deps) {
         const date = now().slice(0, 10);
         const slug = slugify(input.slug ?? title);
         const dir = `${id}-${date}-${slug}`;
-        const absolute = path77.join(flowsRoot(input.cwd), dir);
+        const absolute = path78.join(flowsRoot(input.cwd), dir);
         if (await pathExists(absolute)) {
           throw new Error(`Flow directory already exists: ${dir}`);
         }
@@ -34504,17 +34600,17 @@ function createFlowService(deps) {
           history: [{ at: createdAt, event: "created" }]
         };
         const sourceLabel = input.issue ?? "user description";
-        await writeFileAtomic(path77.join(absolute, "description.md"), renderDescription(title, originDraft === undefined ? sourceLabel : `${sourceLabel} (origin: ${originDraft.kind})`, originDraft));
-        await writeFileAtomic(path77.join(absolute, "context.md"), context.markdown);
-        await writeFileAtomic(path77.join(absolute, "plan.md"), renderPlan());
-        await writeFileAtomic(path77.join(absolute, "tasks.md"), renderTasksDoc());
-        await writeFileAtomic(path77.join(absolute, "acceptance-criteria.md"), renderAcceptanceCriteria());
-        await writeFileAtomic(path77.join(absolute, "journal.md"), renderJournal(createdAt));
+        await writeFileAtomic(path78.join(absolute, "description.md"), renderDescription(title, originDraft === undefined ? sourceLabel : `${sourceLabel} (origin: ${originDraft.kind})`, originDraft));
+        await writeFileAtomic(path78.join(absolute, "context.md"), context.markdown);
+        await writeFileAtomic(path78.join(absolute, "plan.md"), renderPlan());
+        await writeFileAtomic(path78.join(absolute, "tasks.md"), renderTasksDoc());
+        await writeFileAtomic(path78.join(absolute, "acceptance-criteria.md"), renderAcceptanceCriteria());
+        await writeFileAtomic(path78.join(absolute, "journal.md"), renderJournal(createdAt));
         await writeFlow(input.cwd, dir, flow);
         await recordAllocation(scope, { id, dir, at: createdAt, project: scope.project });
         return {
           flow,
-          dir: path77.relative(input.cwd, absolute),
+          dir: path78.relative(input.cwd, absolute),
           contextNotes: context.notes,
           ...originNote === undefined ? {} : { originNote }
         };
@@ -35155,7 +35251,7 @@ function createFlowService(deps) {
           issues.push({ flow: dir, kind: "schema", message: `unknown schemaVersion ${flow.schemaVersion}` });
         }
         try {
-          const raw = JSON.parse(await Bun.file(path77.join(flowsRoot(cwd), dir, "flow.json")).text());
+          const raw = JSON.parse(await Bun.file(path78.join(flowsRoot(cwd), dir, "flow.json")).text());
           const validation = validateAgainstSchemaObject(flowStateSchema(), raw);
           if (!validation.valid) {
             issues.push({
@@ -35166,7 +35262,7 @@ function createFlowService(deps) {
           }
         } catch {}
         for (const file of ["description.md", "context.md", "plan.md", "tasks.md", "acceptance-criteria.md", "journal.md"]) {
-          if (!await pathExists(path77.join(flowsRoot(cwd), dir, file))) {
+          if (!await pathExists(path78.join(flowsRoot(cwd), dir, file))) {
             issues.push({ flow: dir, kind: "structure", message: `missing ${file}` });
           }
         }
@@ -35205,7 +35301,7 @@ function createFlowService(deps) {
   };
 }
 async function appendIdMap(cwd, entry) {
-  const file = path77.join(flowsRoot(cwd), "id-map.json");
+  const file = path78.join(flowsRoot(cwd), "id-map.json");
   let entries = [];
   if (await pathExists(file)) {
     const raw = await readFile39(file, "utf8");
@@ -35216,7 +35312,7 @@ async function appendIdMap(cwd, entry) {
       }
       entries = parsed;
     } catch (error) {
-      throw new Error(`Cannot read ${path77.relative(cwd, file)}: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`Cannot read ${path78.relative(cwd, file)}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
   entries.push(entry);
@@ -35504,7 +35600,7 @@ async function acCriterionKnown(input) {
 init_data_dir();
 import { mkdir as mkdir23, readdir as readdir18, readFile as readFile51, writeFile as writeFile17 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
-import path100 from "path";
+import path101 from "path";
 
 // src/gdgraph/types.ts
 var UNKNOWN_IMPORT_KIND = "unknown-static";
@@ -35571,7 +35667,7 @@ async function buildGraph(projectRoot, options = {}) {
   const assetNodes = new Map;
   const fileRecords = [];
   for (const file of files) {
-    const absolutePath = path100.join(projectRoot, file);
+    const absolutePath = path101.join(projectRoot, file);
     const content = await readFile51(absolutePath, "utf8");
     fileRecords.push({ path: file, content });
     const language = getLanguage(file);
@@ -35624,24 +35720,24 @@ async function collectSourceFiles(projectRoot) {
   const result = [];
   const skippedDirectories = [];
   async function walk(relativeDir) {
-    const absoluteDir = path100.join(projectRoot, relativeDir);
+    const absoluteDir = path101.join(projectRoot, relativeDir);
     const entries = await readdir18(absoluteDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) {
-          skippedDirectories.push(normalizePath3(path100.posix.join(relativeDir, entry.name)).replace(/^\.\//, ""));
+          skippedDirectories.push(normalizePath3(path101.posix.join(relativeDir, entry.name)).replace(/^\.\//, ""));
           continue;
         }
-        await walk(normalizePath3(path100.posix.join(relativeDir, entry.name)));
+        await walk(normalizePath3(path101.posix.join(relativeDir, entry.name)));
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
-      if (!SOURCE_EXTENSIONS.includes(path100.extname(entry.name))) {
+      if (!SOURCE_EXTENSIONS.includes(path101.extname(entry.name))) {
         continue;
       }
-      result.push(normalizePath3(path100.posix.join(relativeDir, entry.name)).replace(/^\.\//, ""));
+      result.push(normalizePath3(path101.posix.join(relativeDir, entry.name)).replace(/^\.\//, ""));
     }
   }
   await walk(".");
@@ -35723,8 +35819,8 @@ function resolveImport(projectRoot, fromFile, specifier, fileSet, resolver) {
 }
 function resolveAssetImport(projectRoot, fromFile, specifier, resolver) {
   for (const candidate of importCandidateBases(projectRoot, fromFile, specifier, resolver)) {
-    const extension = path100.posix.extname(candidate);
-    if (ASSET_EXTENSIONS.includes(extension) && existsSync11(path100.join(projectRoot, candidate))) {
+    const extension = path101.posix.extname(candidate);
+    if (ASSET_EXTENSIONS.includes(extension) && existsSync11(path101.join(projectRoot, candidate))) {
       return candidate;
     }
   }
@@ -35733,17 +35829,17 @@ function resolveAssetImport(projectRoot, fromFile, specifier, resolver) {
 function importCandidateBases(projectRoot, fromFile, specifier, resolver) {
   const normalizedSpecifier = stripImportSuffix(specifier);
   if (normalizedSpecifier.startsWith(".") && getLanguage(fromFile) !== "python") {
-    const fromDir = path100.posix.dirname(fromFile);
-    return [normalizePath3(path100.posix.normalize(path100.posix.join(fromDir, normalizedSpecifier)))];
+    const fromDir = path101.posix.dirname(fromFile);
+    return [normalizePath3(path101.posix.normalize(path101.posix.join(fromDir, normalizedSpecifier)))];
   }
-  return resolver.candidateBases(normalizedSpecifier, fromFile).map((candidate) => normalizePath3(path100.relative(projectRoot, path100.join(projectRoot, candidate))));
+  return resolver.candidateBases(normalizedSpecifier, fromFile).map((candidate) => normalizePath3(path101.relative(projectRoot, path101.join(projectRoot, candidate))));
 }
 function resolveSourceCandidate(base, fileSet) {
   const candidates = [
     base,
     ...SOURCE_RESOLUTION_EXTENSIONS.map((extension) => `${base}${extension}`),
-    ...SOURCE_RESOLUTION_EXTENSIONS.map((extension) => path100.posix.join(base, `index${extension}`)),
-    path100.posix.join(base, "__init__.py")
+    ...SOURCE_RESOLUTION_EXTENSIONS.map((extension) => path101.posix.join(base, `index${extension}`)),
+    path101.posix.join(base, "__init__.py")
   ];
   return candidates.find((candidate) => fileSet.has(candidate)) ?? null;
 }
@@ -35773,7 +35869,7 @@ async function loadJavaResolver(projectRoot) {
   return createJavaResolver(roots);
 }
 async function discoverJavaSourceRoots(projectRoot) {
-  const pomPath = path100.join(projectRoot, "pom.xml");
+  const pomPath = path101.join(projectRoot, "pom.xml");
   if (existsSync11(pomPath)) {
     try {
       const roots = parseMavenSourceRoots(await readFile51(pomPath, "utf8"));
@@ -35783,7 +35879,7 @@ async function discoverJavaSourceRoots(projectRoot) {
     } catch {}
   }
   for (const gradleName of ["build.gradle", "build.gradle.kts"]) {
-    const gradlePath = path100.join(projectRoot, gradleName);
+    const gradlePath = path101.join(projectRoot, gradleName);
     if (existsSync11(gradlePath)) {
       try {
         const roots = parseGradleSourceRoots(await readFile51(gradlePath, "utf8"));
@@ -35805,12 +35901,12 @@ function createJavaResolver(sourceRoots) {
         return [];
       }
       const relative = specifier.split(".").join("/");
-      return sourceRoots.map((root) => normalizePath3(path100.posix.join(root, relative)));
+      return sourceRoots.map((root) => normalizePath3(path101.posix.join(root, relative)));
     }
   };
 }
 function loadPythonResolver(projectRoot) {
-  const hasSrc = existsSync11(path100.join(projectRoot, "src"));
+  const hasSrc = existsSync11(path101.join(projectRoot, "src"));
   return createPythonResolver(hasSrc);
 }
 function createPythonResolver(hasSrc) {
@@ -35823,16 +35919,16 @@ function createPythonResolver(hasSrc) {
       if (specifier.startsWith(".")) {
         const dots = /^\.+/.exec(specifier)?.[0].length ?? 0;
         const rest = specifier.slice(dots);
-        let baseDir = path100.posix.dirname(fromFile);
+        let baseDir = path101.posix.dirname(fromFile);
         for (let level = 1;level < dots; level += 1) {
-          baseDir = path100.posix.dirname(baseDir);
+          baseDir = path101.posix.dirname(baseDir);
         }
         const suffix = rest ? rest.split(".").join("/") : "";
-        const base = suffix ? path100.posix.join(baseDir, suffix) : baseDir;
+        const base = suffix ? path101.posix.join(baseDir, suffix) : baseDir;
         return [normalizePath3(base)];
       }
       const relative = specifier.split(".").join("/");
-      return roots.map((root) => normalizePath3(root ? path100.posix.join(root, relative) : relative));
+      return roots.map((root) => normalizePath3(root ? path101.posix.join(root, relative) : relative));
     }
   };
 }
@@ -35841,8 +35937,8 @@ function parseMavenSourceRoots(pomXml) {
   for (const match of pomXml.matchAll(/<module>\s*([^<]+?)\s*<\/module>/g)) {
     const moduleDir = match[1]?.trim();
     if (moduleDir && !moduleDir.includes("${")) {
-      roots.add(normalizePath3(path100.posix.join(moduleDir, "src/main/java")));
-      roots.add(normalizePath3(path100.posix.join(moduleDir, "src/test/java")));
+      roots.add(normalizePath3(path101.posix.join(moduleDir, "src/main/java")));
+      roots.add(normalizePath3(path101.posix.join(moduleDir, "src/test/java")));
     }
   }
   for (const tag of ["sourceDirectory", "testSourceDirectory"]) {
@@ -35875,7 +35971,7 @@ function parseGradleSourceRoots(buildGradle) {
 var TSCONFIG_EXTENDS_MAX_DEPTH = 10;
 async function loadTsconfigResolver(projectRoot) {
   const empty = createTsconfigResolver(null, []);
-  const tsconfigPath = path100.join(projectRoot, "tsconfig.json");
+  const tsconfigPath = path101.join(projectRoot, "tsconfig.json");
   if (!existsSync11(tsconfigPath)) {
     return empty;
   }
@@ -35888,7 +35984,7 @@ async function loadTsconfigResolver(projectRoot) {
   return createTsconfigResolver(resolved.baseUrl, paths);
 }
 function toProjectRelativeDir(projectRoot, absoluteDir) {
-  const relative = normalizePath3(path100.relative(projectRoot, absoluteDir)).replace(/^\.\//, "");
+  const relative = normalizePath3(path101.relative(projectRoot, absoluteDir)).replace(/^\.\//, "");
   return relative === "." ? "" : relative;
 }
 async function readTsconfigJson(configPath) {
@@ -35903,11 +35999,11 @@ function resolveTsconfigExtendsPath(configDir, extendsSpecifier) {
   if (!extendsSpecifier.startsWith(".") && !extendsSpecifier.startsWith("/")) {
     return null;
   }
-  const resolved = path100.resolve(configDir, extendsSpecifier);
+  const resolved = path101.resolve(configDir, extendsSpecifier);
   return resolved.endsWith(".json") ? resolved : `${resolved}.json`;
 }
 async function resolveTsconfigOptions(configPath, visited, depth, projectRoot) {
-  const resolvedPath = path100.resolve(configPath);
+  const resolvedPath = path101.resolve(configPath);
   if (depth > TSCONFIG_EXTENDS_MAX_DEPTH || visited.has(resolvedPath)) {
     return null;
   }
@@ -35918,15 +36014,15 @@ async function resolveTsconfigOptions(configPath, visited, depth, projectRoot) {
   }
   let inherited = null;
   if (typeof parsed.extends === "string") {
-    const basePath = resolveTsconfigExtendsPath(path100.dirname(resolvedPath), parsed.extends);
+    const basePath = resolveTsconfigExtendsPath(path101.dirname(resolvedPath), parsed.extends);
     if (basePath) {
       inherited = await resolveTsconfigOptions(basePath, visited, depth + 1, projectRoot);
     }
   }
-  const configDir = path100.dirname(resolvedPath);
+  const configDir = path101.dirname(resolvedPath);
   const declaringDir = toProjectRelativeDir(projectRoot, configDir);
   const options = parsed.compilerOptions ?? {};
-  const ownBaseUrl = typeof options.baseUrl === "string" ? toProjectRelativeDir(projectRoot, path100.resolve(configDir, options.baseUrl)) : null;
+  const ownBaseUrl = typeof options.baseUrl === "string" ? toProjectRelativeDir(projectRoot, path101.resolve(configDir, options.baseUrl)) : null;
   const baseUrl = ownBaseUrl ?? inherited?.baseUrl ?? null;
   const ownPaths = isRecord5(options.paths) ? Object.entries(options.paths).filter((entry) => Array.isArray(entry[1])).map(([pattern, targets]) => ({
     pattern,
@@ -35955,7 +36051,7 @@ function createTsconfigResolver(baseUrl, mappings) {
         }
       }
       if (baseUrl !== null) {
-        candidates.push(normalizePath3(path100.posix.join(baseUrl, normalizedSpecifier)));
+        candidates.push(normalizePath3(path101.posix.join(baseUrl, normalizedSpecifier)));
       }
       return [...new Set(candidates.map((candidate) => candidate.replace(/^\.\//, "")))];
     }
@@ -35975,7 +36071,7 @@ function matchPathPattern(pattern, specifier) {
 }
 function applyPathTarget(base, target, wildcard) {
   const replaced = target.includes("*") ? target.replace("*", wildcard) : target;
-  return normalizePath3(path100.posix.normalize(path100.posix.join(base, replaced)));
+  return normalizePath3(path101.posix.normalize(path101.posix.join(base, replaced)));
 }
 function stripJsonComments(source) {
   let out = "";
@@ -36032,13 +36128,13 @@ async function writeGraph(projectRoot, graph, dataDir) {
   const artifactsDir = gdgraphArtifactsDir(projectRoot, dataDir);
   await mkdir23(storageDir, { recursive: true });
   await mkdir23(artifactsDir, { recursive: true });
-  await writeFile17(path100.join(storageDir, "nodes.jsonl"), graph.nodes.map((node) => JSON.stringify(node)).join(`
+  await writeFile17(path101.join(storageDir, "nodes.jsonl"), graph.nodes.map((node) => JSON.stringify(node)).join(`
 `) + `
 `, "utf8");
-  await writeFile17(path100.join(storageDir, "edges.jsonl"), graph.edges.map((edge) => JSON.stringify(edge)).join(`
+  await writeFile17(path101.join(storageDir, "edges.jsonl"), graph.edges.map((edge) => JSON.stringify(edge)).join(`
 `) + `
 `, "utf8");
-  await writeFile17(path100.join(artifactsDir, "module-map.json"), JSON.stringify(buildModuleMap(graph), null, 2) + `
+  await writeFile17(path101.join(artifactsDir, "module-map.json"), JSON.stringify(buildModuleMap(graph), null, 2) + `
 `, "utf8");
 }
 async function writeSummary(projectRoot, graph, collection, dataDir) {
@@ -36057,7 +36153,7 @@ async function writeSummary(projectRoot, graph, collection, dataDir) {
 `);
   const skippedList = collection.skippedDirectories.length > 0 ? collection.skippedDirectories.slice(0, 30).map((dir) => `- \`${dir}\``).join(`
 `) : "- none";
-  const summaryPath = path100.join(artifactsDir, "summary.md");
+  const summaryPath = path101.join(artifactsDir, "summary.md");
   const content = `# gdgraph Summary
 
 ## Stats
@@ -36138,7 +36234,7 @@ function groupBy(items, getKey) {
 }
 function unresolvedType(specifier) {
   const stripped = stripImportSuffix(specifier);
-  const extension = path100.posix.extname(stripped);
+  const extension = path101.posix.extname(stripped);
   if (extension) {
     return extension;
   }
@@ -36148,7 +36244,7 @@ function unresolvedType(specifier) {
   return "package";
 }
 function normalizePath3(value) {
-  return value.split(path100.sep).join("/");
+  return value.split(path101.sep).join("/");
 }
 
 // src/gdgraph/service.ts
@@ -36157,17 +36253,17 @@ init_config3();
 
 // src/gdgraph/query.ts
 import { readFile as readFile52 } from "fs/promises";
-import path101 from "path";
+import path102 from "path";
 init_data_dir();
 init_target();
 async function loadGraph(projectRoot, dataDir) {
   const storageDir = gdgraphStorageDir(projectRoot, dataDir);
-  const nodes = await readJsonl(path101.join(storageDir, "nodes.jsonl"));
-  const edges = await readJsonl(path101.join(storageDir, "edges.jsonl"));
-  const symbols = await readJsonl(path101.join(storageDir, "symbols.jsonl"));
-  const calls = await readJsonl(path101.join(storageDir, "calls.jsonl"));
-  const wikiPages = await readJsonl(path101.join(storageDir, "wiki-pages.jsonl"));
-  const describes = await readJsonl(path101.join(storageDir, "describes.jsonl"));
+  const nodes = await readJsonl(path102.join(storageDir, "nodes.jsonl"));
+  const edges = await readJsonl(path102.join(storageDir, "edges.jsonl"));
+  const symbols = await readJsonl(path102.join(storageDir, "symbols.jsonl"));
+  const calls = await readJsonl(path102.join(storageDir, "calls.jsonl"));
+  const wikiPages = await readJsonl(path102.join(storageDir, "wiki-pages.jsonl"));
+  const describes = await readJsonl(path102.join(storageDir, "describes.jsonl"));
   const graph = { nodes, edges };
   if (symbols.length > 0) {
     graph.symbols = symbols;
@@ -36227,7 +36323,7 @@ async function bunfigPreloadRoots(projectRoot) {
   const roots = new Set;
   let text;
   try {
-    text = await readFile52(path101.join(projectRoot, "bunfig.toml"), "utf8");
+    text = await readFile52(path102.join(projectRoot, "bunfig.toml"), "utf8");
   } catch {
     return roots;
   }
@@ -36241,8 +36337,8 @@ async function bunfigPreloadRoots(projectRoot) {
       if (raw.length === 0) {
         continue;
       }
-      const absolute = path101.resolve(projectRoot, raw);
-      const relative = path101.relative(projectRoot, absolute).split(path101.sep).join("/");
+      const absolute = path102.resolve(projectRoot, raw);
+      const relative = path102.relative(projectRoot, absolute).split(path102.sep).join("/");
       roots.add(relative);
     }
   }
@@ -36397,12 +36493,12 @@ init_section_tombstone();
 // src/forgetting/journal.ts
 init_fs();
 import { appendFile as appendFile5, mkdir as mkdir25, readFile as readFile53, stat as stat15 } from "fs/promises";
-import path103 from "path";
+import path104 from "path";
 function forgettingDataDir(cwd) {
-  return path103.join(cwd, ".metaproject", "data", "forgetting");
+  return path104.join(cwd, ".metaproject", "data", "forgetting");
 }
 function deletionJournalPath(cwd) {
-  return path103.join(forgettingDataDir(cwd), "journal.jsonl");
+  return path104.join(forgettingDataDir(cwd), "journal.jsonl");
 }
 async function readDeletionJournal(cwd) {
   const file = deletionJournalPath(cwd);
@@ -36817,12 +36913,12 @@ function createGdgraphService() {
 // src/health/service.ts
 init_fs();
 init_json();
-import path123 from "path";
+import path124 from "path";
 
 // src/health/config.ts
 init_fs();
 init_json();
-import path104 from "path";
+import path105 from "path";
 var DEFAULT_HEALTH_CONFIG = {
   schemaVersion: 2,
   ignore: {
@@ -36879,7 +36975,7 @@ var DEFAULT_HEALTH_CONFIG = {
   }
 };
 function configPath2(cwd) {
-  return path104.join(cwd, ".metaproject", "health.config.json");
+  return path105.join(cwd, ".metaproject", "health.config.json");
 }
 var STRICTEST_GATE = {
   failOnPriorities: ["P0", "P1", "P2", "P3"],
@@ -36930,7 +37026,7 @@ async function loadHealthConfig(cwd) {
 // src/health/run.ts
 init_fs();
 import { mkdir as mkdir29, writeFile as writeFile22 } from "fs/promises";
-import path122 from "path";
+import path123 from "path";
 
 // src/metrics/provenance.ts
 async function collectGitProvenance(cwd) {
@@ -37043,12 +37139,12 @@ function computeGate2(input) {
 }
 
 // src/health/scopes.ts
-import path107 from "path";
+import path108 from "path";
 
 // src/health/util.ts
 init_fs();
 import { mkdir as mkdir26, readFile as readFile54, readdir as readdir19, writeFile as writeFile19 } from "fs/promises";
-import path105 from "path";
+import path106 from "path";
 var IGNORED_DIRS = new Set([
   "node_modules",
   ".git",
@@ -37092,14 +37188,14 @@ async function toolVersion(command, cwd) {
   }
 }
 function dataRoot3(cwd) {
-  return path105.join(cwd, ".metaproject", "data", "health");
+  return path106.join(cwd, ".metaproject", "data", "health");
 }
 async function writeRaw(cwd, source, content, stamp) {
-  const dir = path105.join(dataRoot3(cwd), "raw", source);
+  const dir = path106.join(dataRoot3(cwd), "raw", source);
   await mkdir26(dir, { recursive: true });
-  const file = path105.join(dir, `${stamp}.log`);
+  const file = path106.join(dir, `${stamp}.log`);
   await writeFile19(file, content, "utf8");
-  return path105.relative(cwd, file);
+  return path106.relative(cwd, file);
 }
 async function listSourceFiles(cwd, ignorePaths = []) {
   const { files } = await listSourceFilesWithReasons(cwd, ignorePaths);
@@ -37119,7 +37215,7 @@ async function walk2(root, dir, out, incompleteReasons) {
   try {
     entries = await readdir19(dir, { withFileTypes: true });
   } catch (error) {
-    incompleteReasons.push(`${path105.relative(root, dir) || "."}: ${error instanceof Error ? error.message : String(error)}`);
+    incompleteReasons.push(`${path106.relative(root, dir) || "."}: ${error instanceof Error ? error.message : String(error)}`);
     return;
   }
   for (const entry of entries) {
@@ -37127,14 +37223,14 @@ async function walk2(root, dir, out, incompleteReasons) {
       if (entry.isDirectory() && !IGNORED_DIRS.has(entry.name)) {}
       continue;
     }
-    const abs = path105.join(dir, entry.name);
+    const abs = path106.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) {
         continue;
       }
       await walk2(root, abs, out, incompleteReasons);
-    } else if (entry.isFile() && SOURCE_EXT.has(path105.extname(entry.name))) {
-      out.push(path105.relative(root, abs));
+    } else if (entry.isFile() && SOURCE_EXT.has(path106.extname(entry.name))) {
+      out.push(path106.relative(root, abs));
     }
   }
 }
@@ -37149,7 +37245,7 @@ function moduleOfFile(file) {
   return null;
 }
 function isSourceFile(file) {
-  return SOURCE_EXT.has(path105.extname(file));
+  return SOURCE_EXT.has(path106.extname(file));
 }
 function matchesAnyPattern(file, patterns) {
   const normalized = file.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -37251,7 +37347,7 @@ function rankHotspots(files, churn, sourceAnalysis) {
 // src/health/source-analysis.ts
 init_fs();
 import { readFile as readFile55 } from "fs/promises";
-import path106 from "path";
+import path107 from "path";
 
 // src/health/metrics/complexity.ts
 var CONTROL_KEYWORDS = new Set([
@@ -37485,7 +37581,7 @@ async function analyzeSourceFiles(cwd, sourceFiles) {
   return new Map(entries.filter((entry) => entry !== null));
 }
 async function analyzeSourceFile(cwd, file) {
-  const abs = path106.join(cwd, file);
+  const abs = path107.join(cwd, file);
   if (!await pathExists(abs)) {
     return null;
   }
@@ -37562,14 +37658,14 @@ async function computeMetrics(input) {
   }
   const components = new Map;
   for (const file of sourceFiles) {
-    const dir = path107.posix.dirname(file);
+    const dir = path108.posix.dirname(file);
     if (dir === "." || dir === moduleOfFile(file)) {
       continue;
     }
     components.set(dir, [...components.get(dir) ?? [], file]);
   }
   for (const [name, files] of [...components.entries()].sort()) {
-    const compFindings = findings.filter((f) => f.file && path107.posix.dirname(f.file) === name);
+    const compFindings = findings.filter((f) => f.file && path108.posix.dirname(f.file) === name);
     scopes.push(build("component", `component:${name}`, name, files, compFindings, averageCoverage(files, coverage)));
   }
   const findingFiles = findings.map((f) => f.file).filter((f) => Boolean(f));
@@ -37614,7 +37710,7 @@ function tally2(values) {
 // src/health/baseline.ts
 init_fs();
 import { mkdir as mkdir27, readFile as readFile56, writeFile as writeFile20 } from "fs/promises";
-import path108 from "path";
+import path109 from "path";
 var LEGACY_BASELINE_SOURCES = Object.freeze([
   "complexity",
   "coverage",
@@ -37639,7 +37735,7 @@ function measuredSources(sources) {
   return sources.filter((s) => s !== null && typeof s === "object").filter((s) => !didNotProduceResult(s)).map((s) => s.source).sort();
 }
 function baselinePath(cwd) {
-  return path108.join(cwd, ".metaproject", "health", "baselines", "scores.json");
+  return path109.join(cwd, ".metaproject", "health", "baselines", "scores.json");
 }
 async function readBaselineFile(cwd) {
   const file = baselinePath(cwd);
@@ -37660,7 +37756,7 @@ async function loadBaselineSources(cwd) {
 }
 async function writeBaselineFile(cwd, data) {
   const file = baselinePath(cwd);
-  await mkdir27(path108.dirname(file), { recursive: true });
+  await mkdir27(path109.dirname(file), { recursive: true });
   await writeFile20(file, `${JSON.stringify(data, null, 2)}
 `, "utf8");
 }
@@ -37742,10 +37838,10 @@ async function getChurn(cwd, windowDays) {
 
 // src/health/metrics/wiki-freshness.ts
 import { readFile as readFile57, stat as stat16 } from "fs/promises";
-import path109 from "path";
+import path110 from "path";
 var DEFAULT_STALE_EVIDENCE_DAYS = 7;
 function freshnessReportPath(cwd) {
-  return path109.join(cwd, ".metaproject", "data", "wiki", "freshness", "latest.json");
+  return path110.join(cwd, ".metaproject", "data", "wiki", "freshness", "latest.json");
 }
 async function readWikiFreshnessMetric(cwd, options = {}) {
   const file = freshnessReportPath(cwd);
@@ -37766,7 +37862,7 @@ async function readWikiFreshnessMetric(cwd, options = {}) {
   } catch {
     return {
       status: "unreadable-report",
-      reason: `${path109.relative(cwd, file)} is not valid JSON; re-run \`keryx wiki freshness\`.`
+      reason: `${path110.relative(cwd, file)} is not valid JSON; re-run \`keryx wiki freshness\`.`
     };
   }
   const report = parsed;
@@ -37776,7 +37872,7 @@ async function readWikiFreshnessMetric(cwd, options = {}) {
   if (pagesTotal === null || pagesFresh === null) {
     return {
       status: "unreadable-report",
-      reason: `${path109.relative(cwd, file)} is missing its totals; re-run \`keryx wiki freshness\`.`
+      reason: `${path110.relative(cwd, file)} is missing its totals; re-run \`keryx wiki freshness\`.`
     };
   }
   const pagesUndecidable = numberOr3(totals.pagesUndecidable) ?? 0;
@@ -37830,12 +37926,12 @@ function renderWikiFreshnessLine(metric) {
 }
 
 // src/health/sources/helpers.ts
-import path110 from "path";
+import path111 from "path";
 import { existsSync as existsSync12 } from "fs";
 class NoImportError extends Error {
 }
 function resolveBin(cwd, name) {
-  const local = path110.join(cwd, "node_modules", ".bin", name);
+  const local = path111.join(cwd, "node_modules", ".bin", name);
   if (existsSync12(local)) {
     return local;
   }
@@ -37916,13 +38012,13 @@ async function getComplexityFindings(cwd, sourceFiles, config, sourceAnalysis) {
 
 // src/health/metrics/coverage.ts
 import { existsSync as existsSync13 } from "fs";
-import path111 from "path";
+import path112 from "path";
 var SUMMARY_PATHS = [
   "coverage/coverage-summary.json",
   "coverage/coverage-final.json"
 ];
 async function getCoverage(cwd) {
-  const summary = SUMMARY_PATHS.map((rel) => path111.join(cwd, rel)).find((abs) => existsSync13(abs));
+  const summary = SUMMARY_PATHS.map((rel) => path112.join(cwd, rel)).find((abs) => existsSync13(abs));
   if (!summary) {
     return { status: "missing", total: null, byFile: new Map };
   }
@@ -37943,7 +38039,7 @@ async function getCoverage(cwd) {
       total = pct;
       continue;
     }
-    const relative = path111.isAbsolute(key) ? path111.relative(cwd, key) : key;
+    const relative = path112.isAbsolute(key) ? path112.relative(cwd, key) : key;
     byFile.set(relative.replace(/\\/g, "/"), pct);
   }
   return { status: "available", total, byFile };
@@ -38076,10 +38172,10 @@ function renderWikiFreshness(metric) {
 // src/health/skills.ts
 init_fs();
 import { readFile as readFile58 } from "fs/promises";
-import path112 from "path";
+import path113 from "path";
 var EMPTY = { skills: [], skillForFile: () => null };
 async function loadSkillOwnership(cwd) {
-  const manifestPath = path112.join(cwd, ".metaproject", "metaproject.json");
+  const manifestPath = path113.join(cwd, ".metaproject", "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return EMPTY;
   }
@@ -38117,7 +38213,7 @@ function normalize(value) {
 
 // src/health/sources/eslint.ts
 import { existsSync as existsSync14 } from "fs";
-import path113 from "path";
+import path114 from "path";
 var CONFIG_FILES = [
   ".eslintrc",
   ".eslintrc.js",
@@ -38131,7 +38227,7 @@ var CONFIG_FILES = [
   "eslint.config.ts"
 ];
 function hasConfig(cwd) {
-  return CONFIG_FILES.some((file) => existsSync14(path113.join(cwd, file)));
+  return CONFIG_FILES.some((file) => existsSync14(path114.join(cwd, file)));
 }
 var eslintAdapter = {
   id: "eslint",
@@ -38157,7 +38253,7 @@ var eslintAdapter = {
     };
   },
   async import(ctx) {
-    const report = path113.join(ctx.cwd, "eslint-report.json");
+    const report = path114.join(ctx.cwd, "eslint-report.json");
     if (!existsSync14(report)) {
       throw new NoImportError("no eslint-report.json");
     }
@@ -38184,7 +38280,7 @@ var eslintAdapter = {
     }
     const findings = [];
     for (const file of data) {
-      const relative = path113.isAbsolute(file.filePath) ? path113.relative(ctx.cwd, file.filePath) : file.filePath;
+      const relative = path114.isAbsolute(file.filePath) ? path114.relative(ctx.cwd, file.filePath) : file.filePath;
       for (const message of file.messages ?? []) {
         const isError = message.severity === 2;
         findings.push(makeFinding({
@@ -38216,19 +38312,19 @@ var eslintAdapter = {
 
 // src/health/sources/oxlint.ts
 import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
-import path114 from "path";
+import path115 from "path";
 var CONFIG_FILES2 = [".oxlintrc.json", ".oxlintrc.jsonc"];
 var OXLINT_FORMAT = "json";
 var OXLINT_PARSE_ERROR = "oxlint JSON format was not recognized";
 var OXLINT_NO_FILES = "oxlint found no files to lint (check its paths and ignore patterns)";
 var NO_FILES_PREAMBLE = "No files found to lint";
 function hasConfigFile(cwd) {
-  if (CONFIG_FILES2.some((file) => existsSync15(path114.join(cwd, file))))
+  if (CONFIG_FILES2.some((file) => existsSync15(path115.join(cwd, file))))
     return true;
-  return [".oxlintrc.js", ".oxlintrc.cjs", ".oxlintrc.mjs", ".oxlintrc.ts"].some((file) => existsSync15(path114.join(cwd, file)));
+  return [".oxlintrc.js", ".oxlintrc.cjs", ".oxlintrc.mjs", ".oxlintrc.ts"].some((file) => existsSync15(path115.join(cwd, file)));
 }
 function packageNamesOxlint(cwd) {
-  const file = path114.join(cwd, "package.json");
+  const file = path115.join(cwd, "package.json");
   if (!existsSync15(file))
     return false;
   try {
@@ -38286,7 +38382,7 @@ var oxlintAdapter = {
       return [];
     return data.map((diagnostic) => {
       const filePath = diagnostic.filename ?? "";
-      const relative = filePath && path114.isAbsolute(filePath) ? path114.relative(ctx.cwd, filePath) : filePath;
+      const relative = filePath && path115.isAbsolute(filePath) ? path115.relative(ctx.cwd, filePath) : filePath;
       const isError = diagnostic.severity === "error";
       return makeFinding({
         source: "oxlint",
@@ -38312,9 +38408,9 @@ var oxlintAdapter = {
 
 // src/health/sources/typescript.ts
 import { existsSync as existsSync16 } from "fs";
-import path115 from "path";
+import path116 from "path";
 function hasTsconfig(cwd) {
-  return existsSync16(path115.join(cwd, "tsconfig.json"));
+  return existsSync16(path116.join(cwd, "tsconfig.json"));
 }
 var typescriptAdapter = {
   id: "typescript",
@@ -38375,12 +38471,12 @@ init_fs();
 init_contained_write();
 import { existsSync as existsSync17 } from "fs";
 import { readFile as readFile61, readdir as readdir20 } from "fs/promises";
-import path119 from "path";
+import path120 from "path";
 // src/metrics/lifecycle.ts
 init_fs();
 init_guard();
 import { readFile as readFile59 } from "fs/promises";
-import path116 from "path";
+import path117 from "path";
 
 // src/metrics/record.ts
 var RELIABILITIES = new Set(["exact", "estimated", "unknown"]);
@@ -38395,7 +38491,7 @@ var RETRY_TYPES = new Set([
 
 // src/metrics/lifecycle.ts
 async function readArtifactPointer(root, expected) {
-  const pointerFile = path116.join(root, "latest.json");
+  const pointerFile = path117.join(root, "latest.json");
   if (!await pathExists(pointerFile))
     return { status: "missing", pointer: null };
   let pointer;
@@ -38404,7 +38500,7 @@ async function readArtifactPointer(root, expected) {
   } catch {
     return { status: "stale", pointer: null, reason: "latest pointer is invalid JSON" };
   }
-  const recordFile = pointer.record ? path116.join(root, pointer.record) : null;
+  const recordFile = pointer.record ? path117.join(root, pointer.record) : null;
   if (!recordFile || !isPathInside(root, recordFile) || !await pathExists(recordFile)) {
     return { status: "stale", pointer, reason: "pointer record is missing" };
   }
@@ -38420,9 +38516,9 @@ init_guard();
 // src/testing/capability.ts
 init_fs();
 init_json();
-import path117 from "path";
+import path118 from "path";
 async function isTestingCapabilityEnabled(cwd, capability) {
-  const manifestPath = path117.join(cwd, ".metaproject", "metaproject.json");
+  const manifestPath = path118.join(cwd, ".metaproject", "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return false;
   }
@@ -38448,10 +38544,10 @@ async function isTestingCapabilityEnabled(cwd, capability) {
 init_fs();
 init_guard();
 import { readFile as readFile60, mkdir as mkdir28, writeFile as writeFile21 } from "fs/promises";
-import path118 from "path";
+import path119 from "path";
 var COVERAGE_MAP_SCHEMA_VERSION = 1;
 function coverageMapPath(cwd, cfg) {
-  return path118.isAbsolute(cfg.coverageMap.artifact) ? cfg.coverageMap.artifact : path118.join(cwd, cfg.coverageMap.artifact);
+  return path119.isAbsolute(cfg.coverageMap.artifact) ? cfg.coverageMap.artifact : path119.join(cwd, cfg.coverageMap.artifact);
 }
 async function loadCoverageMap(cwd, cfg) {
   const file = coverageMapPath(cwd, cfg);
@@ -38586,7 +38682,7 @@ var DEFAULT_TESTING_CONFIG = {
   }
 };
 function testingDataRoot(cwd) {
-  return path119.join(cwd, ".metaproject", "data", "testing");
+  return path120.join(cwd, ".metaproject", "data", "testing");
 }
 async function computeTestingContext(cwd) {
   const { files, incompleteReasons } = await listProjectFiles(cwd);
@@ -38761,7 +38857,7 @@ async function runTesting(input) {
   return runResult;
 }
 async function loadTestingContext(cwd) {
-  const file = path119.join(testingDataRoot(cwd), "context.json");
+  const file = path120.join(testingDataRoot(cwd), "context.json");
   if (!await pathExists(file)) {
     return null;
   }
@@ -38772,18 +38868,18 @@ async function loadTestingContext(cwd) {
   }
 }
 async function loadTestingReport(cwd) {
-  const file = path119.join(testingDataRoot(cwd), "artifacts", "latest.json");
+  const file = path120.join(testingDataRoot(cwd), "artifacts", "latest.json");
   if (!await pathExists(file)) {
     return null;
   }
   try {
     const latest = JSON.parse(await readFile61(file, "utf8"));
     if (typeof latest.record === "string") {
-      const pointer = await readArtifactPointer(path119.join(testingDataRoot(cwd), "artifacts"), await collectGitProvenance(cwd));
+      const pointer = await readArtifactPointer(path120.join(testingDataRoot(cwd), "artifacts"), await collectGitProvenance(cwd));
       if (pointer.status !== "fresh")
         return null;
-      const recordFile = path119.join(testingDataRoot(cwd), "artifacts", latest.record);
-      if (!isPathInside(path119.join(testingDataRoot(cwd), "artifacts"), recordFile))
+      const recordFile = path120.join(testingDataRoot(cwd), "artifacts", latest.record);
+      if (!isPathInside(path120.join(testingDataRoot(cwd), "artifacts"), recordFile))
         return null;
       if (!await pathExists(recordFile))
         return null;
@@ -38830,28 +38926,28 @@ async function ensureContext(cwd) {
 }
 async function writeContext(cwd, context) {
   const root = testingDataRoot(cwd);
-  const rel = (p) => path119.relative(cwd, p);
+  const rel = (p) => path120.relative(cwd, p);
   await mkdirContained(cwd, rel(root));
-  await writeContained(cwd, rel(path119.join(root, "context.json")), `${JSON.stringify(context, null, 2)}
+  await writeContained(cwd, rel(path120.join(root, "context.json")), `${JSON.stringify(context, null, 2)}
 `);
-  await writeContained(cwd, rel(path119.join(root, "context.md")), renderContextMarkdown(context));
-  await writeContained(cwd, rel(path119.join(root, "recommendations.md")), renderRecommendationsMarkdown(context));
+  await writeContained(cwd, rel(path120.join(root, "context.md")), renderContextMarkdown(context));
+  await writeContained(cwd, rel(path120.join(root, "recommendations.md")), renderRecommendationsMarkdown(context));
 }
 async function writeReport(cwd, report) {
   const root = testingDataRoot(cwd);
-  const artifacts = path119.join(root, "artifacts");
-  const history = path119.join(root, "history");
-  const rel = (p) => path119.relative(cwd, p);
+  const artifacts = path120.join(root, "artifacts");
+  const history = path120.join(root, "history");
+  const rel = (p) => path120.relative(cwd, p);
   await mkdirContained(cwd, rel(artifacts));
   await mkdirContained(cwd, rel(history));
   const stamp = report.generatedAt.replace(/[:.]/g, "-");
-  const json = path119.join(artifacts, "latest.json");
-  const markdown = path119.join(artifacts, "latest.md");
+  const json = path120.join(artifacts, "latest.json");
+  const markdown = path120.join(artifacts, "latest.md");
   const serialized = `${JSON.stringify(report, null, 2)}
 `;
   if (report.runId) {
-    const runJson = path119.join(artifacts, "runs", `${report.runId}.json`);
-    const runMarkdown = path119.join(artifacts, "runs", `${report.runId}.md`);
+    const runJson = path120.join(artifacts, "runs", `${report.runId}.json`);
+    const runMarkdown = path120.join(artifacts, "runs", `${report.runId}.md`);
     if (await pathExists(runJson))
       throw new Error(`immutable testing run already exists: ${report.runId}`);
     await writeContained(cwd, rel(runJson), serialized);
@@ -38862,26 +38958,26 @@ async function writeReport(cwd, report) {
       branch: report.provenance?.branch ?? null,
       worktree: report.provenance?.worktree ?? null,
       generated_at: report.generatedAt,
-      record: path119.posix.join("runs", `${report.runId}.json`)
+      record: path120.posix.join("runs", `${report.runId}.json`)
     }, null, 2)}
 `);
   } else {
     await writeContained(cwd, rel(json), serialized);
   }
   await writeContained(cwd, rel(markdown), renderReportMarkdown3(report));
-  await writeContained(cwd, rel(path119.join(history, `${stamp}.json`)), serialized);
+  await writeContained(cwd, rel(path120.join(history, `${stamp}.json`)), serialized);
   return {
-    markdownPath: path119.relative(cwd, markdown),
-    jsonPath: path119.relative(cwd, json)
+    markdownPath: path120.relative(cwd, markdown),
+    jsonPath: path120.relative(cwd, json)
   };
 }
 async function writeRawLog(cwd, raw) {
-  const logs = path119.join(testingDataRoot(cwd), "logs");
-  const rel = (p) => path119.relative(cwd, p);
+  const logs = path120.join(testingDataRoot(cwd), "logs");
+  const rel = (p) => path120.relative(cwd, p);
   await mkdirContained(cwd, rel(logs));
-  const latest = path119.join(logs, "latest.raw.log");
+  const latest = path120.join(logs, "latest.raw.log");
   await writeContained(cwd, rel(latest), raw);
-  return path119.relative(cwd, latest);
+  return path120.relative(cwd, latest);
 }
 async function listProjectFiles(cwd) {
   const out = [];
@@ -38894,11 +38990,11 @@ async function walk3(root, dir, out, incompleteReasons) {
   try {
     entries = await readdir20(dir, { withFileTypes: true });
   } catch (error) {
-    incompleteReasons.push(`${normalizePath6(path119.relative(root, dir)) || "."}: ${error instanceof Error ? error.message : String(error)}`);
+    incompleteReasons.push(`${normalizePath6(path120.relative(root, dir)) || "."}: ${error instanceof Error ? error.message : String(error)}`);
     return;
   }
   for (const entry of entries) {
-    const abs = path119.join(dir, entry.name);
+    const abs = path120.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (IGNORED_DIRS2.has(entry.name) || entry.name.startsWith(".tmp-")) {
         continue;
@@ -38907,12 +39003,12 @@ async function walk3(root, dir, out, incompleteReasons) {
       continue;
     }
     if (entry.isFile()) {
-      out.push(normalizePath6(path119.relative(root, abs)));
+      out.push(normalizePath6(path120.relative(root, abs)));
     }
   }
 }
 async function readPackageJson(cwd) {
-  const file = path119.join(cwd, "package.json");
+  const file = path120.join(cwd, "package.json");
   if (!await pathExists(file)) {
     return null;
   }
@@ -38923,7 +39019,7 @@ async function readPackageJson(cwd) {
   }
 }
 async function loadTestingConfig(cwd) {
-  const file = path119.join(cwd, ".metaproject", "testing.config.json");
+  const file = path120.join(cwd, ".metaproject", "testing.config.json");
   if (!await pathExists(file)) {
     return DEFAULT_TESTING_CONFIG;
   }
@@ -38988,7 +39084,7 @@ function detectFrameworks(input) {
 async function extractConventions(cwd, files) {
   const conventions = new Set;
   for (const file of files.slice(0, 40)) {
-    const abs = path119.join(cwd, file);
+    const abs = path120.join(cwd, file);
     if (!await pathExists(abs)) {
       continue;
     }
@@ -39118,7 +39214,7 @@ async function findTestsByImportedTargets(cwd, targets, testFiles) {
   const targetKeys = new Set(targets.map((target) => modulePathKey(normalizePath6(target))));
   const selected = new Set;
   for (const testFile of testFiles) {
-    const absoluteTest = path119.join(cwd, testFile);
+    const absoluteTest = path120.join(cwd, testFile);
     if (!await pathExists(absoluteTest)) {
       continue;
     }
@@ -39152,10 +39248,10 @@ function resolveImportPath(cwd, testFile, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const importerDir = path119.dirname(testFile);
-  const absoluteResolved = path119.resolve(path119.join(cwd, importerDir), importPath);
-  const relative = path119.relative(cwd, absoluteResolved);
-  if (relative.startsWith(`..${path119.sep}`) || relative === "..") {
+  const importerDir = path120.dirname(testFile);
+  const absoluteResolved = path120.resolve(path120.join(cwd, importerDir), importPath);
+  const relative = path120.relative(cwd, absoluteResolved);
+  if (relative.startsWith(`..${path120.sep}`) || relative === "..") {
     return null;
   }
   const relativeNormalized = normalizePath6(relative);
@@ -39207,13 +39303,13 @@ function resolveTestCommand(cwd, context, input) {
 }
 var BUN_LOCKFILES = ["bun.lock", "bun.lockb"];
 function detectPackageManager(cwd) {
-  if (resolveBunBin() && BUN_LOCKFILES.some((name) => pathExistsSync(path119.join(cwd, name)))) {
+  if (resolveBunBin() && BUN_LOCKFILES.some((name) => pathExistsSync(path120.join(cwd, name)))) {
     return "bun";
   }
-  if (Bun.which("pnpm") && pathExistsSync(path119.join(cwd, "pnpm-lock.yaml"))) {
+  if (Bun.which("pnpm") && pathExistsSync(path120.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (Bun.which("yarn") && pathExistsSync(path119.join(cwd, "yarn.lock"))) {
+  if (Bun.which("yarn") && pathExistsSync(path120.join(cwd, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
@@ -39553,7 +39649,7 @@ async function compatibleReportForHealth(ctx) {
 
 // src/health/sources/dependency-audit.ts
 import { existsSync as existsSync18 } from "fs";
-import path120 from "path";
+import path121 from "path";
 function auditSeverityToPriority(severity) {
   if (severity === "critical" || severity === "high")
     return "P0";
@@ -39672,7 +39768,7 @@ var LOCKFILE_COMMANDS = [
 ];
 function auditCommand(cwd) {
   for (const entry of LOCKFILE_COMMANDS) {
-    if (!entry.lockfiles.some((name) => existsSync18(path120.join(cwd, name))))
+    if (!entry.lockfiles.some((name) => existsSync18(path121.join(cwd, name))))
       continue;
     const bin = resolveBin(cwd, entry.bin);
     if (bin)
@@ -39731,13 +39827,13 @@ var dependencyAuditAdapter = {
 
 // src/health/sources/sonarqube.ts
 import { existsSync as existsSync19 } from "fs";
-import path121 from "path";
+import path122 from "path";
 var REPORT_FILES = ["sonar-issues.json", ".metaproject/data/health/sonar-issues.json"];
 function reportPath(cwd) {
   const fromEnv = process.env.SONAR_ISSUES_FILE;
   const candidates = fromEnv ? [fromEnv, ...REPORT_FILES] : REPORT_FILES;
   for (const rel of candidates) {
-    const abs = path121.isAbsolute(rel) ? rel : path121.join(cwd, rel);
+    const abs = path122.isAbsolute(rel) ? rel : path122.join(cwd, rel);
     if (existsSync19(abs)) {
       return abs;
     }
@@ -39821,7 +39917,7 @@ var sonarqubeAdapter = {
 function relativizeComponent(component, cwd) {
   const colon = component.indexOf(":");
   const value = colon >= 0 ? component.slice(colon + 1) : component;
-  return path121.isAbsolute(value) ? path121.relative(cwd, value) : value;
+  return path122.isAbsolute(value) ? path122.relative(cwd, value) : value;
 }
 
 // src/health/sources/index.ts
@@ -40182,19 +40278,19 @@ function filteredInfo(source, cfg) {
   };
 }
 async function writeOutputs(cwd, report, config, stamp) {
-  const artifacts = path122.join(dataRoot3(cwd), "artifacts");
-  const history = path122.join(dataRoot3(cwd), "history");
+  const artifacts = path123.join(dataRoot3(cwd), "artifacts");
+  const history = path123.join(dataRoot3(cwd), "history");
   await mkdir29(artifacts, { recursive: true });
   await mkdir29(history, { recursive: true });
-  const markdown = path122.join(artifacts, "latest.md");
-  const json = path122.join(artifacts, "latest.json");
-  const historyJson = path122.join(history, `${stamp}.json`);
+  const markdown = path123.join(artifacts, "latest.md");
+  const json = path123.join(artifacts, "latest.json");
+  const historyJson = path123.join(history, `${stamp}.json`);
   const serialized = `${JSON.stringify(report, null, 2)}
 `;
   await writeFile22(markdown, renderReportMarkdown2(report, config), "utf8");
   if (report.runId) {
-    const runJson = path122.join(artifacts, "runs", `${report.runId}.json`);
-    const runMarkdown = path122.join(artifacts, "runs", `${report.runId}.md`);
+    const runJson = path123.join(artifacts, "runs", `${report.runId}.json`);
+    const runMarkdown = path123.join(artifacts, "runs", `${report.runId}.md`);
     if (await pathExists(runJson))
       throw new Error(`immutable health run already exists: ${report.runId}`);
     await writeFileAtomic(runJson, serialized);
@@ -40205,7 +40301,7 @@ async function writeOutputs(cwd, report, config, stamp) {
       branch: report.provenance?.branch ?? null,
       worktree: report.provenance?.worktree ?? null,
       generated_at: report.generatedAt,
-      record: path122.posix.join("runs", `${report.runId}.json`)
+      record: path123.posix.join("runs", `${report.runId}.json`)
     }, null, 2)}
 `);
   } else {
@@ -40213,8 +40309,8 @@ async function writeOutputs(cwd, report, config, stamp) {
   }
   await writeFile22(historyJson, serialized, "utf8");
   return {
-    markdownPath: path122.relative(cwd, markdown),
-    jsonPath: path122.relative(cwd, json)
+    markdownPath: path123.relative(cwd, markdown),
+    jsonPath: path123.relative(cwd, json)
   };
 }
 async function resolveChanged(cwd, selector) {
@@ -40267,7 +40363,7 @@ function hasGateShape(value) {
   return Array.isArray(report.metrics) && Array.isArray(report.sources) && Array.isArray(report.findings);
 }
 async function readLatest(cwd) {
-  const file = path123.join(dataRoot3(cwd), "artifacts", "latest.json");
+  const file = path124.join(dataRoot3(cwd), "artifacts", "latest.json");
   if (!await pathExists(file)) {
     return null;
   }
@@ -40278,11 +40374,11 @@ async function readLatest(cwd) {
     const latest = read.value;
     const record = latest.record;
     if (typeof record === "string") {
-      const pointer = await readArtifactPointer(path123.join(dataRoot3(cwd), "artifacts"), await collectGitProvenance(cwd));
+      const pointer = await readArtifactPointer(path124.join(dataRoot3(cwd), "artifacts"), await collectGitProvenance(cwd));
       if (pointer.status !== "fresh")
         return null;
-      const recordFile = path123.join(dataRoot3(cwd), "artifacts", record);
-      if (!isPathInside(path123.join(dataRoot3(cwd), "artifacts"), recordFile))
+      const recordFile = path124.join(dataRoot3(cwd), "artifacts", record);
+      if (!isPathInside(path124.join(dataRoot3(cwd), "artifacts"), recordFile))
         return null;
       if (!await pathExists(recordFile))
         return null;
@@ -40355,7 +40451,7 @@ function createCodeHealthService() {
   return {
     run: (input) => runHealth(input),
     async status(input) {
-      const enabled = await pathExists(path123.join(input.cwd, ".metaproject", "health.config.json"));
+      const enabled = await pathExists(path124.join(input.cwd, ".metaproject", "health.config.json"));
       const latest = await readLatest(input.cwd);
       const project = latest?.metrics.find((m) => m.key === "project") ?? null;
       const decliningScopes = latest ? latest.metrics.filter((m) => m.regression_score > 0).length : 0;
@@ -40512,10 +40608,10 @@ function renderEvidenceBlock(evidences, siblings) {
 init_fs();
 init_contained_write();
 init_json();
-import path124 from "path";
+import path125 from "path";
 import { createHash as createHash21 } from "crypto";
 function impactEvidenceDataRoot(root) {
-  return path124.join(root, ".metaproject", "data", "security", "impact-evidence");
+  return path125.join(root, ".metaproject", "data", "security", "impact-evidence");
 }
 function sanitizeSessionId(sessionId) {
   const cleaned = sessionId.replace(/[^A-Za-z0-9._-]/g, "_");
@@ -40527,7 +40623,7 @@ function sessionStateFilename(sessionId) {
   return `${sanitized}-${suffix}.json`;
 }
 function sessionStatePath(root, sessionId) {
-  return path124.join(impactEvidenceDataRoot(root), "sessions", sessionStateFilename(sessionId));
+  return path125.join(impactEvidenceDataRoot(root), "sessions", sessionStateFilename(sessionId));
 }
 async function loadSessionState(root, sessionId) {
   const file = sessionStatePath(root, sessionId);
@@ -40546,11 +40642,11 @@ async function loadSessionState(root, sessionId) {
 }
 async function saveSessionState(root, sessionId, state) {
   const file = sessionStatePath(root, sessionId);
-  await writeContained(root, path124.relative(root, file), `${JSON.stringify(state, null, 2)}
+  await writeContained(root, path125.relative(root, file), `${JSON.stringify(state, null, 2)}
 `);
 }
 function logPath(root) {
-  return path124.join(impactEvidenceDataRoot(root), "log.jsonl");
+  return path125.join(impactEvidenceDataRoot(root), "log.jsonl");
 }
 async function appendLogRecord(root, record) {
   const full = {
@@ -40561,7 +40657,7 @@ async function appendLogRecord(root, record) {
     ...record.detail !== undefined ? { detail: record.detail } : {}
   };
   const file = logPath(root);
-  await appendContained(root, path124.relative(root, file), `${JSON.stringify(full)}
+  await appendContained(root, path125.relative(root, file), `${JSON.stringify(full)}
 `);
   return full;
 }
@@ -40588,7 +40684,7 @@ init_command_risk();
 init_shell_syntax();
 init_fs();
 init_service2();
-import path125 from "path";
+import path126 from "path";
 import { createHash as createHash22 } from "crypto";
 import { realpathSync as realpathSync2 } from "fs";
 function impactEvidenceHookClass(strict) {
@@ -40604,29 +40700,29 @@ function realpathNearestExisting(p) {
   for (;; ) {
     try {
       const real = realpathSync2(current);
-      return tail.length > 0 ? path125.join(real, ...tail) : real;
+      return tail.length > 0 ? path126.join(real, ...tail) : real;
     } catch {
-      const parent = path125.dirname(current);
+      const parent = path126.dirname(current);
       if (parent === current) {
-        return tail.length > 0 ? path125.join(current, ...tail) : current;
+        return tail.length > 0 ? path126.join(current, ...tail) : current;
       }
-      tail.unshift(path125.basename(current));
+      tail.unshift(path126.basename(current));
       current = parent;
     }
   }
 }
 function normalizeRequestFiles(root, files) {
-  const rootReal = realpathNearestExisting(path125.resolve(root));
+  const rootReal = realpathNearestExisting(path126.resolve(root));
   const normalized = [];
   const rejected = [];
   for (const file of files) {
-    const lexicalAbsolute = path125.isAbsolute(file) ? path125.resolve(file) : path125.resolve(rootReal, toPosix(file).replace(/^\.\//, ""));
+    const lexicalAbsolute = path126.isAbsolute(file) ? path126.resolve(file) : path126.resolve(rootReal, toPosix(file).replace(/^\.\//, ""));
     const effective = realpathNearestExisting(lexicalAbsolute);
     if (!isPathInside(rootReal, effective)) {
       rejected.push(file);
       continue;
     }
-    normalized.push(toPosix(path125.relative(rootReal, effective)));
+    normalized.push(toPosix(path126.relative(rootReal, effective)));
   }
   return { files: [...new Set(normalized)], rejected };
 }
@@ -40908,7 +41004,7 @@ function hostDeliveryStatus() {
 // src/job/service.ts
 init_fs();
 import { copyFile, mkdir as mkdir31 } from "fs/promises";
-import path128 from "path";
+import path129 from "path";
 
 // src/job/types.ts
 var JOB_INTENTS = ["implement", "analyze", "review", "custom"];
@@ -41049,15 +41145,15 @@ init_validator();
 init_contracts();
 init_fs();
 import { appendFile as appendFile6, mkdir as mkdir30, readFile as readFile63, readdir as readdir21 } from "fs/promises";
-import path127 from "path";
+import path128 from "path";
 function jobsRoot(cwd) {
-  return path127.join(cwd, ".metaproject", "jobs");
+  return path128.join(cwd, ".metaproject", "jobs");
 }
 function jobDir(cwd, name) {
-  return path127.join(jobsRoot(cwd), name);
+  return path128.join(jobsRoot(cwd), name);
 }
 function jobStatePath(cwd, name) {
-  return path127.join(jobDir(cwd, name), "state.json");
+  return path128.join(jobDir(cwd, name), "state.json");
 }
 var JOB_NAME_PATTERN = /^[a-z0-9-]+$/;
 function assertJobName(name) {
@@ -41094,12 +41190,12 @@ async function writeJob(cwd, name, state) {
 `));
   }
   const file = jobStatePath(cwd, name);
-  await mkdir30(path127.dirname(file), { recursive: true });
+  await mkdir30(path128.dirname(file), { recursive: true });
   await writeFileAtomic(file, `${JSON.stringify(state, null, 2)}
 `);
 }
 async function appendJournal2(cwd, name, at, line) {
-  await appendFile6(path127.join(jobDir(cwd, name), "journal.md"), `- ${at} - ${line}
+  await appendFile6(path128.join(jobDir(cwd, name), "journal.md"), `- ${at} - ${line}
 `, "utf8");
 }
 function renderJournal2(name, at) {
@@ -41120,7 +41216,7 @@ function assertDocumentType(raw) {
   return raw;
 }
 function documentFileName(type, sourcePath) {
-  const extension = path127.extname(sourcePath) || ".md";
+  const extension = path128.extname(sourcePath) || ".md";
   return `${type}${extension}`;
 }
 
@@ -41128,7 +41224,7 @@ function documentFileName(type, sourcePath) {
 function createJobService(deps) {
   const now = () => deps.now().toISOString();
   function lockPath(cwd, name) {
-    return path128.join(jobsRoot(cwd), `.job-lock-${name}`);
+    return path129.join(jobsRoot(cwd), `.job-lock-${name}`);
   }
   async function mutate(cwd, name, run) {
     assertJobName(name);
@@ -41177,20 +41273,20 @@ function createJobService(deps) {
         },
         plan: { steps: defaultPlan(intent) },
         documentation: {
-          job_path: path128.join(".metaproject", "jobs", name),
+          job_path: path129.join(".metaproject", "jobs", name),
           documents_created: []
         },
         metrics: { steps: [] },
-        jobs_root: path128.join(".metaproject", "jobs"),
+        jobs_root: path129.join(".metaproject", "jobs"),
         updated_at: createdAt
       };
       const first = firstOpenStep(state.plan.steps);
       if (first) {
         state.plan.current_step = first.id;
       }
-      await writeFileAtomic(path128.join(absolute, "journal.md"), renderJournal2(name, createdAt));
+      await writeFileAtomic(path129.join(absolute, "journal.md"), renderJournal2(name, createdAt));
       await writeJob(input.cwd, name, state);
-      return { state, dir: path128.relative(input.cwd, absolute) };
+      return { state, dir: path129.relative(input.cwd, absolute) };
     },
     async status({ cwd, name }) {
       assertJobName(name);
@@ -41202,7 +41298,7 @@ function createJobService(deps) {
       }
       return {
         state,
-        dir: path128.join(".metaproject", "jobs", name),
+        dir: path129.join(".metaproject", "jobs", name),
         stepsDone: state.plan.steps.filter((step) => isTerminalStep(step.status)).length,
         stepsTotal: state.plan.steps.length,
         nextStep: firstOpenStep(state.plan.steps),
@@ -41259,23 +41355,23 @@ function createJobService(deps) {
       if (!input.file) {
         throw new Error("Missing --file. Usage: keryx job document <name> --type <type> --file <path>");
       }
-      const source = path128.isAbsolute(input.file) ? input.file : path128.join(input.cwd, input.file);
+      const source = path129.isAbsolute(input.file) ? input.file : path129.join(input.cwd, input.file);
       if (!await pathExists(source)) {
         throw new Error(`--file not found: ${input.file}. Write the document first, then record it.`);
       }
       let recorded;
       await mutate(input.cwd, input.name, async (state) => {
         const fileName = documentFileName(type, source);
-        const target = path128.join(jobDir(input.cwd, state.job_name), fileName);
+        const target = path129.join(jobDir(input.cwd, state.job_name), fileName);
         await copyFile(source, target);
         state.documentation ??= {};
-        state.documentation.job_path ??= path128.join(".metaproject", "jobs", state.job_name);
+        state.documentation.job_path ??= path129.join(".metaproject", "jobs", state.job_name);
         const created = state.documentation.documents_created ?? [];
         state.documentation.documents_created = created.includes(fileName) ? created : [...created, fileName];
         recorded = {
           state,
           document: fileName,
-          path: path128.join(".metaproject", "jobs", state.job_name, fileName)
+          path: path129.join(".metaproject", "jobs", state.job_name, fileName)
         };
         return { state, event: "document", detail: `${type} -> ${fileName}` };
       });
@@ -41310,7 +41406,7 @@ function createJobService(deps) {
             name: state.job_name,
             phase: state.phase,
             intent: state.intent,
-            dir: path128.join(".metaproject", "jobs", name),
+            dir: path129.join(".metaproject", "jobs", name),
             stepsDone: state.plan.steps.filter((step) => isTerminalStep(step.status)).length,
             stepsTotal: state.plan.steps.length,
             nextStep: firstOpenStep(state.plan.steps)?.id ?? null
@@ -41331,12 +41427,12 @@ init_fs();
 init_preservation();
 import { randomUUID as randomUUID8 } from "crypto";
 import { lstat as lstat9, readdir as readdir26 } from "fs/promises";
-import path142 from "path";
+import path143 from "path";
 
 // src/session/paths.ts
 import { existsSync as existsSync21 } from "fs";
 import { homedir as homedir2 } from "os";
-import path130 from "path";
+import path131 from "path";
 function keryxDataDir(override) {
   if (override !== undefined && override.length > 0) {
     return override;
@@ -41348,22 +41444,22 @@ function keryxDataDir(override) {
   const home = homedir2();
   if (process.platform === "win32") {
     const appData = process.env.APPDATA;
-    const base = appData !== undefined && appData.length > 0 ? appData : path130.join(home, "AppData", "Roaming");
-    return path130.join(base, "keryx");
+    const base = appData !== undefined && appData.length > 0 ? appData : path131.join(home, "AppData", "Roaming");
+    return path131.join(base, "keryx");
   }
   const xdg = process.env.XDG_DATA_HOME;
-  const base = xdg !== undefined && xdg.length > 0 ? xdg : path130.join(home, ".local", "share");
-  return path130.join(base, "keryx");
+  const base = xdg !== undefined && xdg.length > 0 ? xdg : path131.join(home, ".local", "share");
+  return path131.join(base, "keryx");
 }
 function resolveProjectRoot2(cwd) {
-  const abs = path130.resolve(cwd);
+  const abs = path131.resolve(cwd);
   let dir = abs;
   for (;; ) {
-    const gitPath = path130.join(dir, ".git");
+    const gitPath = path131.join(dir, ".git");
     if (existsSync21(gitPath)) {
       return dir;
     }
-    const parent = path130.dirname(dir);
+    const parent = path131.dirname(dir);
     if (parent === dir) {
       break;
     }
@@ -41372,12 +41468,12 @@ function resolveProjectRoot2(cwd) {
   return abs;
 }
 function projectKeyFromPath(projectPath) {
-  const abs = path130.resolve(projectPath);
+  const abs = path131.resolve(projectPath);
   const encoded = encodeURIComponent(abs);
   if (encoded.length <= 200) {
     return encoded;
   }
-  const base = path130.basename(abs).replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40);
+  const base = path131.basename(abs).replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40);
   let h = 0;
   for (let i = 0;i < abs.length; i++) {
     h = Math.imul(31, h) + abs.charCodeAt(i) | 0;
@@ -41387,22 +41483,22 @@ function projectKeyFromPath(projectPath) {
 }
 function projectSessionsDir(projectPath, dataDir) {
   const key = projectKeyFromPath(resolveProjectRoot2(projectPath));
-  return path130.join(keryxDataDir(dataDir), "sessions", key);
+  return path131.join(keryxDataDir(dataDir), "sessions", key);
 }
 function sessionDir(projectPath, sessionId, dataDir) {
-  return path130.join(projectSessionsDir(projectPath, dataDir), sessionId);
+  return path131.join(projectSessionsDir(projectPath, dataDir), sessionId);
 }
 
 // src/sac/proposal-lifecycle.ts
 init_fs();
 import { createHash as createHash32, randomUUID as randomUUID7 } from "crypto";
 import { appendFile as appendFile7, mkdir as mkdir35, readdir as readdir25, readFile as readFile73 } from "fs/promises";
-import path141 from "path";
+import path142 from "path";
 
 // src/sac/index.ts
 import { access as access3, readFile as readFile64, realpath as realpath14 } from "fs/promises";
 import { createHash as createHash24 } from "crypto";
-import path131 from "path";
+import path132 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/sac/workspace-reference.ts
@@ -41462,21 +41558,21 @@ var normativeSchemaFiles = {
   "review-decision": "review-decision.schema.json"
 };
 var normativeSchemas = new Map;
-var NORMATIVE_SCHEMA_DIR = path131.join("docs", "requirements", "shared-agent-context", "schemas");
+var NORMATIVE_SCHEMA_DIR = path132.join("docs", "requirements", "shared-agent-context", "schemas");
 async function resolveSacNormativeSchemaPath(fileName, searchFrom = [fileURLToPath3(new URL(".", import.meta.url)), process.cwd()]) {
   const seen = new Set;
   for (const start of searchFrom) {
-    let dir = path131.resolve(start);
+    let dir = path132.resolve(start);
     for (let i = 0;i < 10; i++) {
       if (seen.has(dir))
         break;
       seen.add(dir);
-      const candidate = path131.join(dir, NORMATIVE_SCHEMA_DIR, fileName);
+      const candidate = path132.join(dir, NORMATIVE_SCHEMA_DIR, fileName);
       try {
         await access3(candidate);
         return candidate;
       } catch {}
-      const parent = path131.dirname(dir);
+      const parent = path132.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -42145,12 +42241,12 @@ class SacReferenceError extends Error {
   code = "unsafe_workspace_reference";
 }
 async function resolveWorkspaceReference(input) {
-  if (!workspacePathPattern.test(input.uri) || path131.isAbsolute(input.uri) || /^[a-z][a-z0-9+.-]*:/i.test(input.uri) || input.uri.includes("\\"))
+  if (!workspacePathPattern.test(input.uri) || path132.isAbsolute(input.uri) || /^[a-z][a-z0-9+.-]*:/i.test(input.uri) || input.uri.includes("\\"))
     throw new SacReferenceError("unsafe workspace reference");
-  const lexicalRoot = path131.resolve(input.workspaceRoot);
+  const lexicalRoot = path132.resolve(input.workspaceRoot);
   const root = await realpath14(lexicalRoot);
-  const candidate = path131.resolve(lexicalRoot, input.uri.slice(2));
-  if (candidate !== lexicalRoot && !candidate.startsWith(`${lexicalRoot}${path131.sep}`))
+  const candidate = path132.resolve(lexicalRoot, input.uri.slice(2));
+  if (candidate !== lexicalRoot && !candidate.startsWith(`${lexicalRoot}${path132.sep}`))
     throw new SacReferenceError("workspace reference escapes root");
   let resolved;
   try {
@@ -42158,7 +42254,7 @@ async function resolveWorkspaceReference(input) {
   } catch {
     throw new SacReferenceError("workspace reference is not resolvable");
   }
-  if (resolved !== root && !resolved.startsWith(`${root}${path131.sep}`))
+  if (resolved !== root && !resolved.startsWith(`${root}${path132.sep}`))
     throw new SacReferenceError("workspace reference escapes root after realpath");
   return candidate;
 }
@@ -42214,16 +42310,16 @@ async function evaluateStrictSacGuard(input) {
 init_fs();
 import { mkdir as mkdir32, readdir as readdir22, readFile as readFile65 } from "fs/promises";
 import { createHash as createHash25, randomUUID as randomUUID4 } from "crypto";
-import path133 from "path";
+import path134 from "path";
 
 // src/sac/secure-resource-read.ts
 init_contained_read();
 init_descriptor_read();
-import path132 from "path";
+import path133 from "path";
 function readWorkspaceFileNoFollow(workspaceRoot, absolutePath) {
-  const relativePath = path132.relative(workspaceRoot, absolutePath);
-  const components = relativePath.split(path132.sep);
-  if (!relativePath || path132.isAbsolute(relativePath) || components.some((component) => !component || component === "." || component === "..")) {
+  const relativePath = path133.relative(workspaceRoot, absolutePath);
+  const components = relativePath.split(path133.sep);
+  if (!relativePath || path133.isAbsolute(relativePath) || components.some((component) => !component || component === "." || component === "..")) {
     throw new Error("safe source path is not workspace-relative");
   }
   return readDescriptorChain(workspaceRoot, absolutePath, {
@@ -42250,8 +42346,8 @@ class WorkspaceService {
   now;
   constructor(options) {
     this.options = options;
-    this.root = path133.resolve(options.workspaceRoot);
-    this.storageRoot = path133.resolve(options.storageRoot ?? path133.join(this.root, ".metaproject", "workspaces"));
+    this.root = path134.resolve(options.workspaceRoot);
+    this.storageRoot = path134.resolve(options.storageRoot ?? path134.join(this.root, ".metaproject", "workspaces"));
     this.now = options.now ?? (() => new Date);
   }
   async create(input) {
@@ -42577,13 +42673,13 @@ class WorkspaceService {
     return parsed;
   }
   workspaceDir(id) {
-    return path133.join(this.storageRoot, id);
+    return path134.join(this.storageRoot, id);
   }
   manifestPath(id) {
-    return path133.join(this.workspaceDir(id), "workspace.json");
+    return path134.join(this.workspaceDir(id), "workspace.json");
   }
   lockPath(id) {
-    return path133.join(this.storageRoot, `.${id}.lock`);
+    return path134.join(this.storageRoot, `.${id}.lock`);
   }
   timestamp() {
     return this.now().toISOString();
@@ -42699,7 +42795,7 @@ function bindingHash(owner, intent) {
 // src/sac/session-wrap-up.ts
 import { createHash as createHash28 } from "crypto";
 import { mkdir as mkdir34, writeFile as writeFile23 } from "fs/promises";
-import path136 from "path";
+import path137 from "path";
 
 // src/session/store.ts
 init_preservation();
@@ -42712,7 +42808,7 @@ import {
   renameSync as renameSync5,
   writeFileSync as writeFileSync4
 } from "fs";
-import path135 from "path";
+import path136 from "path";
 init_slate();
 init_redact();
 var SESSION_SCHEMA_VERSION = 1;
@@ -42805,7 +42901,7 @@ function parseRemote(value) {
 function readSummaryFile(file) {
   let pending;
   try {
-    pending = readPendingHistory(path135.dirname(file));
+    pending = readPendingHistory(path136.dirname(file));
   } catch {
     pending = undefined;
   }
@@ -42857,11 +42953,11 @@ class TranscriptUnreadableError extends Error {
   }
 }
 function readJsonl2(file) {
-  const pending = readPendingHistory(path135.dirname(file));
+  const pending = readPendingHistory(path136.dirname(file));
   if (pending === undefined && !existsSync22(file)) {
     return [];
   }
-  const read = pending !== undefined ? { ok: true, text: pending.files[path135.basename(file)] } : readTranscriptFile(file);
+  const read = pending !== undefined ? { ok: true, text: pending.files[path136.basename(file)] } : readTranscriptFile(file);
   if (!read.ok) {
     throw new TranscriptUnreadableError(file, read.reason);
   }
@@ -42912,11 +43008,11 @@ function listSessions(cwd, dataDir) {
     if (name.startsWith(".")) {
       continue;
     }
-    const summary = readSummaryFile(path135.join(root, name, "summary.json"));
+    const summary = readSummaryFile(path136.join(root, name, "summary.json"));
     if (summary === undefined) {
       continue;
     }
-    if (path135.resolve(summary.projectPath) !== path135.resolve(projectPath)) {
+    if (path136.resolve(summary.projectPath) !== path136.resolve(projectPath)) {
       continue;
     }
     out.push(summary);
@@ -42949,15 +43045,15 @@ async function readSessionSlate(cwd, sessionId, dataDir) {
 }
 function loadContext(cwd, sessionId, dataDir) {
   const dir = sessionDir(resolveProjectRoot2(cwd), sessionId, dataDir);
-  const contextPath = path135.join(dir, "context.jsonl");
+  const contextPath = path136.join(dir, "context.jsonl");
   if (readPendingHistory(dir) !== undefined || existsSync22(contextPath)) {
     return readJsonl2(contextPath);
   }
-  return readJsonl2(path135.join(dir, "transcript.jsonl"));
+  return readJsonl2(path136.join(dir, "transcript.jsonl"));
 }
 function loadArchive(cwd, sessionId, dataDir, onDegraded) {
   const dir = sessionDir(resolveProjectRoot2(cwd), sessionId, dataDir);
-  const archivePath = path135.join(dir, "archive.jsonl");
+  const archivePath = path136.join(dir, "archive.jsonl");
   if (readPendingHistory(dir) !== undefined || existsSync22(archivePath)) {
     try {
       const archive = readJsonl2(archivePath);
@@ -43032,7 +43128,7 @@ function sessionEvidenceRef(workspaceId, sessionId) {
 }
 async function resolveSessionWrapUp(input) {
   const now = input.now ?? (() => new Date);
-  const sessionId = path136.posix.basename(input.sourceRef, ".md");
+  const sessionId = path137.posix.basename(input.sourceRef, ".md");
   const summary = findSession(input.cwd, sessionId);
   if (summary === undefined || input.sourceRef !== sessionEvidenceRef(input.workspaceId, summary.id)) {
     throw new SessionWrapUpError("session_not_found", `no session matching "${input.sourceRef}" in this project \u2014 use \`keryx sessions list\``);
@@ -43049,7 +43145,7 @@ async function resolveSessionWrapUp(input) {
     throw new SessionWrapUpError("session_unreadable", `session "${summary.id}" could not be read: ${cause.message}`);
   }
   const relPath = sessionEvidenceRef(input.workspaceId, summary.id).slice(2);
-  const evidenceDir = path136.dirname(relPath);
+  const evidenceDir = path137.dirname(relPath);
   const slate = await readSessionSlate(input.cwd, summary.id);
   const diff = await gitDiff(input.cwd);
   const diffBody = diff.kind === "measured" ? diff.text : unmeasurableDiffBody(diff.detail);
@@ -43071,23 +43167,23 @@ async function resolveSessionWrapUp(input) {
     ""
   ].join(`
 `);
-  const wrapUpRelPath = path136.join(evidenceDir, `${summary.id}.wrap-up.md`);
-  const diffRelPath = path136.join(evidenceDir, `${summary.id}.diff.txt`);
-  const noticeRelPath = path136.join(evidenceDir, `${summary.id}.redaction.md`);
+  const wrapUpRelPath = path137.join(evidenceDir, `${summary.id}.wrap-up.md`);
+  const diffRelPath = path137.join(evidenceDir, `${summary.id}.diff.txt`);
+  const noticeRelPath = path137.join(evidenceDir, `${summary.id}.redaction.md`);
   const floor = await applyEvidenceRedactionFloor(input.cwd, [
-    { name: path136.basename(relPath), content: markdown, path: relPath, source: "generated" },
-    { name: path136.basename(wrapUpRelPath), content: wrapUpMarkdown, path: wrapUpRelPath, source: "generated" },
-    { name: path136.basename(diffRelPath), content: diffBody, path: diffRelPath, source: "tool-output" }
+    { name: path137.basename(relPath), content: markdown, path: relPath, source: "generated" },
+    { name: path137.basename(wrapUpRelPath), content: wrapUpMarkdown, path: wrapUpRelPath, source: "generated" },
+    { name: path137.basename(diffRelPath), content: diffBody, path: diffRelPath, source: "tool-output" }
   ]);
   if (!floor.ok)
     throw new SessionWrapUpError("security_denied", floor.reason);
   const [safeSession, safeWrapUp, safeDiff] = floor.bodies;
-  await mkdir34(path136.join(input.cwd, evidenceDir), { recursive: true });
-  await writeFile23(path136.join(input.cwd, relPath), safeSession.content, "utf8");
-  await writeFile23(path136.join(input.cwd, wrapUpRelPath), safeWrapUp.content, "utf8");
-  await writeFile23(path136.join(input.cwd, diffRelPath), safeDiff.content, "utf8");
+  await mkdir34(path137.join(input.cwd, evidenceDir), { recursive: true });
+  await writeFile23(path137.join(input.cwd, relPath), safeSession.content, "utf8");
+  await writeFile23(path137.join(input.cwd, wrapUpRelPath), safeWrapUp.content, "utf8");
+  await writeFile23(path137.join(input.cwd, diffRelPath), safeDiff.content, "utf8");
   if (floor.notice !== undefined)
-    await writeFile23(path136.join(input.cwd, noticeRelPath), floor.notice, "utf8");
+    await writeFile23(path137.join(input.cwd, noticeRelPath), floor.notice, "utf8");
   const observedAt = now().toISOString();
   const evidence = [
     { kind: "wrap-up", uri: `./${wrapUpRelPath}`, revision: createHash28("sha256").update(safeWrapUp.content).digest("hex"), observedAt },
@@ -43110,13 +43206,13 @@ async function resolveSessionWrapUp(input) {
 init_fs();
 import { createHash as createHash29, randomBytes as randomBytes6 } from "crypto";
 import { readFile as readFile67 } from "fs/promises";
-import path137 from "path";
+import path138 from "path";
 var CONFIRM_TOKEN_TTL_MS = 2 * 60000;
 function confirmTokenPath2(cwd, workspaceId, proposalId) {
-  return path137.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.confirm-token.json`);
+  return path138.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.confirm-token.json`);
 }
 function confirmReceiptPath(cwd, workspaceId, proposalId, idempotencyKey) {
-  return path137.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${sha2563(idempotencyKey)}.confirm-receipt.json`);
+  return path138.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${sha2563(idempotencyKey)}.confirm-receipt.json`);
 }
 function sha2563(text) {
   return createHash29("sha256").update(text).digest("hex");
@@ -43157,21 +43253,21 @@ init_store();
 init_config2();
 import { readFile as readFile69, readdir as readdir24 } from "fs/promises";
 import { randomUUID as randomUUID6 } from "crypto";
-import path139 from "path";
+import path140 from "path";
 
 // src/sac/proposal-evidence.ts
 init_fs();
 import { createHash as createHash30 } from "crypto";
 import { readFile as readFile68, rm as rm7 } from "fs/promises";
-import path138 from "path";
+import path139 from "path";
 function proposalPath(cwd, workspaceId, proposalId) {
-  return path138.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.json`);
+  return path139.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.json`);
 }
 function ownerReceiptPath(cwd, owner, workspaceId, idempotencyKey) {
-  return path138.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-receipts`, `${idempotencyKey}.json`);
+  return path139.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-receipts`, `${idempotencyKey}.json`);
 }
 function proposalNotePath(cwd, workspaceId, proposalId) {
-  return path138.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.note.txt`);
+  return path139.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.note.txt`);
 }
 async function readVerifiedProposalEvidence(cwd, workspaceId, proposalId) {
   let proposal;
@@ -43185,7 +43281,7 @@ async function readVerifiedProposalEvidence(cwd, workspaceId, proposalId) {
     return { ok: false, code: "no_evidence_to_write" };
   let content;
   try {
-    content = await readFile68(path138.join(cwd, evidence.uri), "utf8");
+    content = await readFile68(path139.join(cwd, evidence.uri), "utf8");
   } catch {
     return { ok: false, code: "evidence_file_unreadable" };
   }
@@ -43215,22 +43311,22 @@ function targetRelPath(targetRef) {
   return targetRef.replace(/^\.\//, "");
 }
 function targetAbsolutePath(cwd, targetRef) {
-  return path138.join(cwd, ".metaproject", targetRelPath(targetRef));
+  return path139.join(cwd, ".metaproject", targetRelPath(targetRef));
 }
 function targetKey(targetRef) {
   return digestOf2(targetRelPath(targetRef)).slice(0, 32);
 }
 function ownerTargetVersionPath(cwd, owner, workspaceId, targetRef) {
-  return path138.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-target-versions`, `${targetKey(targetRef)}.json`);
+  return path139.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-target-versions`, `${targetKey(targetRef)}.json`);
 }
 function ownerTargetLockPath(cwd, owner, targetRef) {
-  return path138.join(cwd, ".metaproject", "data", "sac", "target-locks", owner, `${targetKey(targetRef)}.lock`);
+  return path139.join(cwd, ".metaproject", "data", "sac", "target-locks", owner, `${targetKey(targetRef)}.lock`);
 }
 function ownerStagingDir(cwd, owner, workspaceId, idempotencyKey) {
-  return path138.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-staging`, digestOf2(idempotencyKey).slice(0, 32));
+  return path139.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-staging`, digestOf2(idempotencyKey).slice(0, 32));
 }
 function ownerConflictDir(cwd, owner, workspaceId, idempotencyKey) {
-  return path138.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-conflicts`, digestOf2(idempotencyKey).slice(0, 32));
+  return path139.join(cwd, ".metaproject", "workspaces", workspaceId, `${owner}-write-conflicts`, digestOf2(idempotencyKey).slice(0, 32));
 }
 async function readJson4(file) {
   try {
@@ -43301,7 +43397,7 @@ async function applyGuardedTargetWrite(input) {
       staged: input.staged,
       stagedAt: receipt.completedAt
     };
-    await writeFileAtomic(path138.join(ownerStagingDir(cwd, owner, intent.workspaceId, intent.idempotencyKey), "plan.json"), `${JSON.stringify(staged, null, 2)}
+    await writeFileAtomic(path139.join(ownerStagingDir(cwd, owner, intent.workspaceId, intent.idempotencyKey), "plan.json"), `${JSON.stringify(staged, null, 2)}
 `);
     const applied = await input.apply(input.staged);
     if (!applied.ok) {
@@ -43327,15 +43423,15 @@ async function recoverStagedOwnerWrite(input) {
   });
 }
 async function readStagedOwnerWrite(cwd, owner, workspaceId, idempotencyKey) {
-  return readJson4(path138.join(ownerStagingDir(cwd, owner, workspaceId, idempotencyKey), "plan.json"));
+  return readJson4(path139.join(ownerStagingDir(cwd, owner, workspaceId, idempotencyKey), "plan.json"));
 }
 async function recordConflict(input) {
   const base = { targetRef: input.targetRef, expectedVersion: input.expectedVersion, currentVersion: input.currentVersion };
   if (input.proposedContent === undefined)
     return base;
   const dir = ownerConflictDir(input.cwd, input.owner, input.intent.workspaceId, input.intent.idempotencyKey);
-  await writeFileAtomic(path138.join(dir, "proposed"), input.proposedContent);
-  const diffRef = `./workspaces/${input.intent.workspaceId}/${input.owner}-write-conflicts/${path138.basename(dir)}/proposed`;
+  await writeFileAtomic(path139.join(dir, "proposed"), input.proposedContent);
+  const diffRef = `./workspaces/${input.intent.workspaceId}/${input.owner}-write-conflicts/${path139.basename(dir)}/proposed`;
   return { ...base, diffRef };
 }
 
@@ -43385,7 +43481,7 @@ async function resolveWorkspaceModule(cwd, workspaceId) {
   }
 }
 async function collectWikiDecisionEntries(cwd) {
-  const dir = path139.join(cwd, ".metaproject", "wiki", "decisions");
+  const dir = path140.join(cwd, ".metaproject", "wiki", "decisions");
   let files;
   try {
     files = (await readdir24(dir)).filter((name) => name.endsWith(".md"));
@@ -43394,12 +43490,12 @@ async function collectWikiDecisionEntries(cwd) {
   }
   const entries = [];
   for (const file of files) {
-    const absolutePath = path139.join(dir, file);
+    const absolutePath = path140.join(dir, file);
     try {
       const content = await readFile69(absolutePath, "utf8");
       entries.push({
         absolutePath,
-        relativePath: path139.posix.join("decisions", file),
+        relativePath: path140.posix.join("decisions", file),
         type: extractHeaderField(content, "Type") ?? "decision",
         title: extractTitle(content),
         version: extractHeaderField(content, "Version") ?? null,
@@ -43621,7 +43717,7 @@ function createRealMemoryOwnerWriter(cwd, opts) {
 init_service4();
 init_guard();
 import { readFile as readFile71 } from "fs/promises";
-import path140 from "path";
+import path141 from "path";
 function renderWrapUpDecisionPage(input) {
   const note = input.note?.trim();
   return `# ${input.title}
@@ -43662,7 +43758,7 @@ export is the source of truth for what actually happened.
 `;
 }
 function wikiPageRelativePath(proposalId) {
-  return path140.posix.join("decisions", `sac-${proposalId}.md`);
+  return path141.posix.join("decisions", `sac-${proposalId}.md`);
 }
 function createRealWikiOwnerWriter(cwd, opts) {
   const now = opts?.now ?? (() => new Date);
@@ -43670,7 +43766,7 @@ function createRealWikiOwnerWriter(cwd, opts) {
     const relativePath = staged.relativePath;
     const content = staged.content;
     const history = await openWikiWriteContext(cwd, "sac proposal accept");
-    await writeWikiPage(history, path140.join(cwd, ".metaproject", "wiki", relativePath), content);
+    await writeWikiPage(history, path141.join(cwd, ".metaproject", "wiki", relativePath), content);
     return { ok: true };
   };
   return {
@@ -43819,7 +43915,7 @@ class ProposalLifecycleService {
   now;
   constructor(options) {
     this.options = options;
-    this.root = path141.resolve(options.workspaceRoot);
+    this.root = path142.resolve(options.workspaceRoot);
     this.now = options.now ?? (() => new Date);
   }
   async create(input) {
@@ -43839,7 +43935,7 @@ class ProposalLifecycleService {
       if (manifest.status === "archived")
         throw new ProposalLifecycleError("guard_denied", "workspace is archived");
       const file = this.proposalPath(workspaceId, proposal.id);
-      await mkdir35(path141.dirname(file), { recursive: true, mode: 448 });
+      await mkdir35(path142.dirname(file), { recursive: true, mode: 448 });
       return withFileLock(`${file}.lock`, async () => {
         const consume = this.options.wrapUpAuthority.consume(input.wrapUp, { actor, workspaceId });
         if (consume !== "ok")
@@ -43867,7 +43963,7 @@ class ProposalLifecycleService {
     return this.options.workspaces.withAuthorizedActor({ actorContext: actor, workspaceId: input.workspaceId, action: "review", execute: async (manifest) => {
       const proposal = await this.loadProposal(input.workspaceId, input.proposalId);
       const ledger = this.ledgerPath(input.workspaceId);
-      await mkdir35(path141.dirname(ledger), { recursive: true, mode: 448 });
+      await mkdir35(path142.dirname(ledger), { recursive: true, mode: 448 });
       return withFileLock(`${ledger}.lock`, async () => {
         const records = (await this.records(ledger)).filter((record) => record.proposalId === proposal.id);
         const events = records.filter((record) => record.recordType === "proposal-transition");
@@ -43909,7 +44005,7 @@ class ProposalLifecycleService {
     } });
   }
   async listProposedProposals(workspaceId) {
-    const proposalsDir = path141.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals");
+    const proposalsDir = path142.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals");
     let entries;
     try {
       entries = (await readdir25(proposalsDir)).filter((name) => name.endsWith(".json"));
@@ -43921,7 +44017,7 @@ class ProposalLifecycleService {
     const proposals = [];
     for (const entry of entries) {
       try {
-        const parsed = JSON.parse(await readFile73(path141.join(proposalsDir, entry), "utf8"));
+        const parsed = JSON.parse(await readFile73(path142.join(proposalsDir, entry), "utf8"));
         if (parsed.recordType === "proposal-created")
           proposals.push(parsed);
       } catch {}
@@ -44187,31 +44283,31 @@ class ProposalLifecycleService {
     }
   }
   proposalPath(workspaceId, proposalId) {
-    return path141.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.json`);
+    return path142.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.json`);
   }
   decisionRef(proposalId, key) {
     return `./proposals/${proposalId}.${hash2(key)}.decision.json`;
   }
   decisionPath(workspaceId, proposalId, key) {
-    return path141.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash2(key)}.decision.json`);
+    return path142.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash2(key)}.decision.json`);
   }
   approvalRef(proposalId, key) {
     return `./proposals/${proposalId}.${hash2(key)}.approval.json`;
   }
   approvalPath(workspaceId, proposalId, key) {
-    return path141.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash2(key)}.approval.json`);
+    return path142.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash2(key)}.approval.json`);
   }
   writeResultPath(workspaceId, proposalId, key) {
-    return path141.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash2(key)}.write-result.json`);
+    return path142.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash2(key)}.write-result.json`);
   }
   intentRef(proposalId, key) {
     return `./proposals/${proposalId}.${hash2(key)}.write-intent.json`;
   }
   intentPath(workspaceId, proposalId, key) {
-    return path141.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash2(key)}.write-intent.json`);
+    return path142.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash2(key)}.write-intent.json`);
   }
   attemptPath(workspaceId, proposalId, key) {
-    return path141.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash2(key)}.owner-write-attempt.json`);
+    return path142.join(this.root, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${hash2(key)}.owner-write-attempt.json`);
   }
   async loadWriteResult(workspaceId, proposalId, key) {
     try {
@@ -44238,7 +44334,7 @@ class ProposalLifecycleService {
     }
   }
   ledgerPath(workspaceId) {
-    return path141.join(this.root, ".metaproject", "workspaces", workspaceId, "activity.jsonl");
+    return path142.join(this.root, ".metaproject", "workspaces", workspaceId, "activity.jsonl");
   }
   timestamp() {
     return this.now().toISOString();
@@ -44357,11 +44453,11 @@ async function replayPreservation(input) {
   if (typeof slate.workspaceId !== "string" || !/^[a-z][a-z0-9-]{2,63}$/.test(slate.workspaceId))
     throw new Error("invalid workspace identity");
   const workspaceId = slate.workspaceId;
-  const outbox = path142.join(input.dir, "preservation", "outbox");
-  const receipt = await readReplayJson(path142.join(outbox, `${input.snapshot}.json`));
+  const outbox = path143.join(input.dir, "preservation", "outbox");
+  const receipt = await readReplayJson(path143.join(outbox, `${input.snapshot}.json`));
   if (receipt.version !== 1 || receipt.snapshot !== input.snapshot || receipt.state !== "pending-review")
     throw new Error("invalid outbox receipt");
-  return withFileLock(path142.join(outbox, `${input.snapshot}.delivery.lock`), async () => {
+  return withFileLock(path143.join(outbox, `${input.snapshot}.delivery.lock`), async () => {
     input.signal?.throwIfAborted();
     const { service, wrapUpAuthority, authorizationServer } = createHarnessProposalLifecycleService(input.cwd, {
       workspaceId,
@@ -44388,12 +44484,12 @@ async function replayPreservation(input) {
     } catch (error) {
       if (!(error instanceof ProposalLifecycleError) || error.code !== "conflict")
         throw error;
-      const existing = await readReplayJson(path142.join(input.cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${id}.json`));
+      const existing = await readReplayJson(path143.join(input.cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${id}.json`));
       const refs = (evidence) => evidence.map((e) => [e.uri, e.revision]);
       if (existing.workspaceId !== workspaceId || existing.author !== actor.subject || existing.kind !== "follow-up" || existing.proposalRevision !== input.snapshot || existing.wrapUp?.sourceRef !== sourceRef || existing.wrapUp?.sourceRevision !== wrapUp.sourceRevision || JSON.stringify(refs(existing.evidence)) !== JSON.stringify(refs(wrapUp.evidence)))
         throw new Error("delivery conflict mismatch", { cause: error });
     }
-    const delivered = path142.join(outbox, `${input.snapshot}.delivered`);
+    const delivered = path143.join(outbox, `${input.snapshot}.delivered`);
     try {
       const marker = await readReplayJson(delivered);
       if (marker.version !== 1 || marker.workspaceId !== workspaceId || marker.proposalId !== id || marker.snapshot !== input.snapshot) {
@@ -44406,7 +44502,7 @@ async function replayPreservation(input) {
     }
     input.afterCreate?.();
     input.signal?.throwIfAborted();
-    writePreservationFile(path142.join(outbox, `${input.snapshot}.delivered`), JSON.stringify({ version: 1, workspaceId, proposalId: id, snapshot: input.snapshot }));
+    writePreservationFile(path143.join(outbox, `${input.snapshot}.delivered`), JSON.stringify({ version: 1, workspaceId, proposalId: id, snapshot: input.snapshot }));
     return "proposed";
   }, input.signal ? { signal: input.signal } : {});
 }
@@ -44429,14 +44525,14 @@ async function scanPreservationOutbox(input) {
   const result = { proposed: 0, deferred: 0, unbound: 0 };
   let entries;
   try {
-    entries = await readdir26(path142.join(input.dir, "preservation", "outbox"));
+    entries = await readdir26(path143.join(input.dir, "preservation", "outbox"));
   } catch (error) {
     if (error.code === "ENOENT")
       return result;
     throw error;
   }
   let attempted = 0;
-  const cursorFile = path142.join(input.dir, "preservation", "outbox", "SCAN_CURSOR");
+  const cursorFile = path143.join(input.dir, "preservation", "outbox", "SCAN_CURSOR");
   for (const entry of resumeScan(entries.filter((name) => /^[a-f0-9]{64}\.json$/.test(name)), cursorFile)) {
     if (input.signal?.aborted || Date.now() >= (input.deadline ?? Infinity) || attempted >= (input.maxItems ?? 8))
       break;
@@ -44461,11 +44557,11 @@ async function replayProjectPreservationOutboxes(input) {
   return boundedReplay(input, scanProjectPreservationOutboxes);
 }
 async function retryProjectPreservation(cwd) {
-  return replayProjectPreservationOutboxes({ cwd, dir: path142.join(projectSessionsDir(cwd), ".explicit-retry") });
+  return replayProjectPreservationOutboxes({ cwd, dir: path143.join(projectSessionsDir(cwd), ".explicit-retry") });
 }
 async function scanProjectPreservationOutboxes(input) {
   const result = { proposed: 0, deferred: 0, unbound: 0 };
-  const root = path142.dirname(input.dir);
+  const root = path143.dirname(input.dir);
   let entries;
   try {
     entries = await readdir26(root, { withFileTypes: true });
@@ -44476,7 +44572,7 @@ async function scanProjectPreservationOutboxes(input) {
   }
   const deadline = input.deadline ?? Date.now() + 2000;
   let scanned = 0;
-  const cursorFile = path142.join(root, ".preservation-replay-cursor");
+  const cursorFile = path143.join(root, ".preservation-replay-cursor");
   const candidates = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
   for (const name of resumeScan(candidates, cursorFile)) {
     if (input.signal?.aborted || Date.now() >= deadline || scanned >= 32)
@@ -44485,7 +44581,7 @@ async function scanProjectPreservationOutboxes(input) {
     recordScanCursor(cursorFile, name);
     scanned++;
     try {
-      const replay = await replayPreservationOutbox({ ...input, deadline, maxItems: 1, dir: path142.join(root, name) });
+      const replay = await replayPreservationOutbox({ ...input, deadline, maxItems: 1, dir: path143.join(root, name) });
       result.proposed += replay.proposed;
       result.deferred += replay.deferred;
       result.unbound += replay.unbound;
@@ -44524,7 +44620,7 @@ async function boundedReplay(input, scan) {
 import { createHash as createHash35, randomUUID as randomUUID9 } from "crypto";
 init_assembly();
 import { appendFile as appendFile8, mkdir as mkdir36, open as open4, readFile as readFile74, rename as rename7, rm as rm8, stat as stat18, writeFile as writeFile24 } from "fs/promises";
-import path143 from "path";
+import path144 from "path";
 init_fs();
 
 // src/sac/policy-experiment.ts
@@ -45267,7 +45363,7 @@ function hasReportIntegrity(report) {
   return reportHashPattern.test(reportDigest) && sha2566(body) === reportDigest;
 }
 async function resolvePolicySelection(workspaceRoot, canonicalFallback) {
-  const configPath = path143.join(workspaceRoot, ...policyExperimentConfigPath);
+  const configPath = path144.join(workspaceRoot, ...policyExperimentConfigPath);
   let configJson;
   try {
     const raw = await readFile74(configPath, "utf8").catch((error) => {
@@ -45465,9 +45561,9 @@ class FwkReadService {
     const recordedAt = nowIso2(now);
     const id = `receipt-${randomUUID9().replace(/-/g, "").slice(0, 16)}`;
     const base = { schemaVersion: "1.0", id, workspaceId, actor, action, decision, recordedAt, cost: { tokens: 0, toolCalls: 1, elapsedMs: 0 }, contextAssembly: { traceRef: assembly.traceRef, configurationRevision: assembly.configurationRevision, selected: assembly.selected.map((id) => `./ids/${id}`), omittedOptional: assembly.omittedOptional.map((id) => `./ids/${id}`) }, policy: { ref: assembly.policyRef, revision: assembly.policyRevision }, ...action === "resource" ? { resourceRef: `./ids/${resourceId ?? "unknown"}` } : {} };
-    const ledger = path143.join(this.options.canonical.workspaceRoot, ".metaproject", "context-operations", "access-receipts.jsonl");
-    const checkpointPath = path143.join(path143.dirname(ledger), "access-receipts.checkpoint.json");
-    await mkdir36(path143.dirname(ledger), { recursive: true, mode: 448 });
+    const ledger = path144.join(this.options.canonical.workspaceRoot, ".metaproject", "context-operations", "access-receipts.jsonl");
+    const checkpointPath = path144.join(path144.dirname(ledger), "access-receipts.checkpoint.json");
+    await mkdir36(path144.dirname(ledger), { recursive: true, mode: 448 });
     return withFileLock(`${ledger}.lock`, async () => {
       const state = await resolveLedgerState(ledger, checkpointPath, this.options.verifyReceiptLedger ?? verifyAccessReceiptLedger);
       const receipt = sealAccessReceipt(base, state.headHash);
@@ -45570,7 +45666,7 @@ function normalizeFwkResult(result) {
 // src/sac/collaboration-service.ts
 import { appendFile as appendFile9, mkdir as mkdir37, readFile as readFile75 } from "fs/promises";
 import { randomUUID as randomUUID10 } from "crypto";
-import path144 from "path";
+import path145 from "path";
 class CollaborationServiceError extends Error {
   code;
   constructor(code, message) {
@@ -45585,7 +45681,7 @@ class CollaborationService {
     this.input = input;
   }
   file(id) {
-    return path144.join(this.input.workspaceRoot, ".metaproject", "workspaces", id, "activity.jsonl");
+    return path145.join(this.input.workspaceRoot, ".metaproject", "workspaces", id, "activity.jsonl");
   }
   async overview(input) {
     const manifest = await this.input.workspaces.show(input);
@@ -45622,7 +45718,7 @@ class CollaborationService {
         occurredAt: (this.input.now ?? (() => new Date))().toISOString(),
         ...suppliedHandoff ? { handoff: { ...suppliedHandoff, from: actor.subject } } : {}
       });
-      await mkdir37(path144.dirname(this.file(manifest.id)), { recursive: true, mode: 448 });
+      await mkdir37(path145.dirname(this.file(manifest.id)), { recursive: true, mode: 448 });
       await appendFile9(this.file(manifest.id), `${JSON.stringify(activity)}
 `, { mode: 384 });
       return normalizeCollaborationResult(activity);
@@ -45672,14 +45768,14 @@ function normalizeCollaborationResult(value) {
 // src/session/external-slate.ts
 init_fs();
 import { mkdir as mkdir39, readdir as readdir27, readFile as readFile76 } from "fs/promises";
-import path146 from "path";
+import path147 from "path";
 
 // src/sac/machine-wrap-up.ts
 init_fs();
 init_slate();
 import { createHash as createHash36, randomUUID as randomUUID12 } from "crypto";
 import { mkdir as mkdir38 } from "fs/promises";
-import path145 from "path";
+import path146 from "path";
 
 // src/sac/workspace-resolve.ts
 init_redact();
@@ -45822,11 +45918,11 @@ async function resolveMachineWrapUp(input) {
 `;
   const seedsJson = `${JSON.stringify(seedsForKind.map((seed) => ({ text: seed.text, source: describeSource(seed.source) })), null, 2)}
 `;
-  const evidenceRelBase = path145.posix.join(".metaproject", "workspaces", input.workspaceId, "machine-evidence");
+  const evidenceRelBase = path146.posix.join(".metaproject", "workspaces", input.workspaceId, "machine-evidence");
   const floor = await applyEvidenceRedactionFloor(input.cwd, [
-    { name: `${input.kind}.diff.txt`, content: diffBody, path: path145.posix.join(evidenceRelBase, `${input.kind}.diff.txt`), source: "tool-output" },
-    { name: `${input.kind}.flow.json`, content: flowSnapshotJson, path: path145.posix.join(evidenceRelBase, `${input.kind}.flow.json`), source: "generated" },
-    { name: `${input.kind}.seeds.json`, content: seedsJson, path: path145.posix.join(evidenceRelBase, `${input.kind}.seeds.json`), source: "generated" }
+    { name: `${input.kind}.diff.txt`, content: diffBody, path: path146.posix.join(evidenceRelBase, `${input.kind}.diff.txt`), source: "tool-output" },
+    { name: `${input.kind}.flow.json`, content: flowSnapshotJson, path: path146.posix.join(evidenceRelBase, `${input.kind}.flow.json`), source: "generated" },
+    { name: `${input.kind}.seeds.json`, content: seedsJson, path: path146.posix.join(evidenceRelBase, `${input.kind}.seeds.json`), source: "generated" }
   ]);
   if (!floor.ok)
     return { ok: false, code: "security_denied", detail: floor.reason };
@@ -45880,14 +45976,14 @@ ${safeSeeds.content}`;
     }
     summary = result.text.trim().length > 0 ? result.text.trim() : mechanicalSummary(summaryDiff, course);
   }
-  const evidenceDir = path145.join(input.cwd, ".metaproject", "workspaces", input.workspaceId, "machine-evidence");
+  const evidenceDir = path146.join(input.cwd, ".metaproject", "workspaces", input.workspaceId, "machine-evidence");
   await mkdir38(evidenceDir, { recursive: true });
   const diffFile = `${input.kind}.${shortHash}.diff.txt`;
   const flowFile = `${input.kind}.${shortHash}.flow.json`;
   const seedsFile = `${input.kind}.${shortHash}.seeds.json`;
-  await writeFileAtomic(path145.join(evidenceDir, diffFile), safeDiff.content);
-  await writeFileAtomic(path145.join(evidenceDir, flowFile), safeFlow.content);
-  await writeFileAtomic(path145.join(evidenceDir, seedsFile), safeSeeds.content);
+  await writeFileAtomic(path146.join(evidenceDir, diffFile), safeDiff.content);
+  await writeFileAtomic(path146.join(evidenceDir, flowFile), safeFlow.content);
+  await writeFileAtomic(path146.join(evidenceDir, seedsFile), safeSeeds.content);
   const observedAt = now().toISOString();
   const relBase = `./.metaproject/workspaces/${input.workspaceId}/machine-evidence`;
   const evidence = [
@@ -45897,7 +45993,7 @@ ${safeSeeds.content}`;
   ];
   if (floor.notice !== undefined) {
     const noticeFile = `${input.kind}.${shortHash}.redaction.md`;
-    await writeFileAtomic(path145.join(evidenceDir, noticeFile), floor.notice);
+    await writeFileAtomic(path146.join(evidenceDir, noticeFile), floor.notice);
     evidence.push({ kind: REDACTION_NOTICE_KIND, uri: `${relBase}/${noticeFile}`, revision: sha2567(floor.notice), observedAt });
   }
   return {
@@ -45916,18 +46012,18 @@ async function writeFlooredArchiveArtifact(params) {
     {
       name: params.filename,
       content: params.content,
-      path: path145.posix.join("slate-archive", params.filename),
+      path: path146.posix.join("slate-archive", params.filename),
       source: "generated"
     }
   ]);
   if (!floor.ok)
     return { ok: false, code: "security_denied", detail: floor.reason };
   const body = floor.bodies[0];
-  const archiveDir = path145.join(params.dir, "slate-archive");
+  const archiveDir = path146.join(params.dir, "slate-archive");
   await mkdir38(archiveDir, { recursive: true });
-  await writeFileAtomic(path145.join(archiveDir, params.filename), body.content);
+  await writeFileAtomic(path146.join(archiveDir, params.filename), body.content);
   if (floor.notice !== undefined) {
-    await writeFileAtomic(path145.join(archiveDir, `${params.filename}${ARCHIVE_REDACTION_NOTICE_SUFFIX}`), floor.notice);
+    await writeFileAtomic(path146.join(archiveDir, `${params.filename}${ARCHIVE_REDACTION_NOTICE_SUFFIX}`), floor.notice);
   }
   return { ok: true, altered: body.altered };
 }
@@ -45963,9 +46059,9 @@ async function writeWrapUpOutcomeArtifact(cwd, dir, trigger, now, groups) {
       return;
     const refusalIso = now().toISOString();
     const refusalFilename = `${refusalIso.replace(/[:.]/g, "-")}-wrap-up-outcome.json`;
-    const archiveDir = path145.join(dir, "slate-archive");
+    const archiveDir = path146.join(dir, "slate-archive");
     await mkdir38(archiveDir, { recursive: true });
-    await writeFileAtomic(path145.join(archiveDir, refusalFilename), `${JSON.stringify({
+    await writeFileAtomic(path146.join(archiveDir, refusalFilename), `${JSON.stringify({
       recordType: "wrap-up-outcome",
       trigger,
       generatedAt: refusalIso,
@@ -46102,7 +46198,7 @@ async function runWrapUp(input) {
 
 // src/session/external-slate.ts
 function externalSlatesDir(cwd) {
-  return path146.join(cwd, ".keryx", "external-slates");
+  return path147.join(cwd, ".keryx", "external-slates");
 }
 var EXTERNAL_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 function assertValidExternalSessionId(externalSessionId) {
@@ -46112,14 +46208,14 @@ function assertValidExternalSessionId(externalSessionId) {
 }
 function externalSlatePath(cwd, externalSessionId) {
   assertValidExternalSessionId(externalSessionId);
-  return path146.join(externalSlatesDir(cwd), `${externalSessionId}.json`);
+  return path147.join(externalSlatesDir(cwd), `${externalSessionId}.json`);
 }
 function externalSlateLockPath(cwd, externalSessionId) {
   return `${externalSlatePath(cwd, externalSessionId)}.lock`;
 }
 function externalSlateEvidenceDir(cwd, externalSessionId) {
   assertValidExternalSessionId(externalSessionId);
-  return path146.join(externalSlatesDir(cwd), externalSessionId);
+  return path147.join(externalSlatesDir(cwd), externalSessionId);
 }
 async function readExternalSlate(cwd, externalSessionId) {
   try {
@@ -46203,12 +46299,12 @@ init_service2();
 
 // src/standard/service.ts
 init_fs();
-import path149 from "path";
+import path150 from "path";
 import { readFile as readFile79 } from "fs/promises";
 
 // src/standard/validate.ts
 init_fs();
-import path148 from "path";
+import path149 from "path";
 import { readFile as readFile78 } from "fs/promises";
 
 // src/standard/schemas.ts
@@ -46338,7 +46434,7 @@ var SCHEMA_REGISTRY2 = {
 // src/standard/profiles.ts
 init_fs();
 init_entrypoint_targets();
-import path147 from "path";
+import path148 from "path";
 import { readFile as readFile77 } from "fs/promises";
 var AGENT_MODULES = ["gdgraph", "gdctx", "gdskills", "gdwiki", "memory"];
 var CI_MODULES = ["health", "testing"];
@@ -46363,7 +46459,7 @@ function enabledModuleKeys(manifest) {
 }
 async function rootEntrypointLinksIndex(cwd, manifest) {
   for (const { path: name } of namedEntrypoints(manifest)) {
-    const filePath = path147.join(cwd, name);
+    const filePath = path148.join(cwd, name);
     if (!await pathExists(filePath)) {
       continue;
     }
@@ -46375,16 +46471,16 @@ async function rootEntrypointLinksIndex(cwd, manifest) {
   return false;
 }
 async function minimalSatisfied(cwd) {
-  const metaprojectRoot = path147.join(cwd, ".metaproject");
+  const metaprojectRoot = path148.join(cwd, ".metaproject");
   const requiredFiles = ["index.md", "README.md", "metaproject.json"];
   const requiredDirs = ["modules", "rules", "skills", "data"];
   for (const file of requiredFiles) {
-    if (!await pathExists(path147.join(metaprojectRoot, file))) {
+    if (!await pathExists(path148.join(metaprojectRoot, file))) {
       return false;
     }
   }
   for (const dir of requiredDirs) {
-    if (!await pathExists(path147.join(metaprojectRoot, dir))) {
+    if (!await pathExists(path148.join(metaprojectRoot, dir))) {
       return false;
     }
   }
@@ -46397,7 +46493,7 @@ async function ciSatisfied(cwd, manifest) {
     return false;
   }
   for (const key of ciModules) {
-    if (await pathExists(path147.join(cwd, ".metaproject", "data", key, "artifacts"))) {
+    if (await pathExists(path148.join(cwd, ".metaproject", "data", key, "artifacts"))) {
       return true;
     }
   }
@@ -46410,7 +46506,7 @@ async function evaluateProfiles(cwd, manifest) {
     satisfied.push("minimal");
   }
   const hasAgentModule = AGENT_MODULES.some((key) => new Set(enabledModuleKeys(manifest)).has(key));
-  const agent = minimal && hasAgentModule && await rootEntrypointLinksIndex(cwd, manifest) && await pathExists(path147.join(cwd, ".metaproject", "rules"));
+  const agent = minimal && hasAgentModule && await rootEntrypointLinksIndex(cwd, manifest) && await pathExists(path148.join(cwd, ".metaproject", "rules"));
   if (agent) {
     satisfied.push("agent");
   }
@@ -46579,20 +46675,20 @@ var MANIFEST_TOP_LEVEL_SCHEMA = {
 async function validateWorkspace2(cwd) {
   const errors = [];
   const warnings = [];
-  const metaprojectRoot = path148.join(cwd, ".metaproject");
+  const metaprojectRoot = path149.join(cwd, ".metaproject");
   const requiredFiles = ["index.md", "README.md", "metaproject.json"];
   for (const file of requiredFiles) {
-    if (!await pathExists(path148.join(metaprojectRoot, file))) {
+    if (!await pathExists(path149.join(metaprojectRoot, file))) {
       errors.push(issue("missing-required-file", `Required file .metaproject/${file} is missing`, `Run \`keryx init\` to scaffold .metaproject/${file}.`));
     }
   }
   const requiredDirs = ["modules", "rules", "skills", "data"];
   for (const dir of requiredDirs) {
-    if (!await pathExists(path148.join(metaprojectRoot, dir))) {
+    if (!await pathExists(path149.join(metaprojectRoot, dir))) {
       errors.push(issue("missing-required-dir", `Required directory .metaproject/${dir}/ is missing`, `Run \`keryx init\` to create .metaproject/${dir}/.`));
     }
   }
-  const manifestPath = path148.join(metaprojectRoot, "metaproject.json");
+  const manifestPath = path149.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return { ok: errors.length === 0, errors, warnings };
   }
@@ -46624,7 +46720,7 @@ async function validateWorkspace2(cwd) {
       if (typeof value !== "string") {
         continue;
       }
-      if (!await pathExists(path148.join(cwd, value))) {
+      if (!await pathExists(path149.join(cwd, value))) {
         errors.push(issue("missing-declared-path", `Declared path paths.${key} -> ${value} does not exist`, `Create ${value} or remove paths.${key} from metaproject.json.`));
       }
     }
@@ -46634,7 +46730,7 @@ async function validateWorkspace2(cwd) {
       continue;
     }
     if (typeof entry.manifest === "string") {
-      if (!await pathExists(path148.join(cwd, entry.manifest))) {
+      if (!await pathExists(path149.join(cwd, entry.manifest))) {
         errors.push(issue("missing-module-manifest", `Enabled module "${key}" manifest ${entry.manifest} is missing`, `Create ${entry.manifest} or run \`keryx update\` to regenerate module manifests.`));
       }
     }
@@ -46643,14 +46739,14 @@ async function validateWorkspace2(cwd) {
       if (typeof value !== "string") {
         continue;
       }
-      if (!await pathExists(path148.join(cwd, value))) {
+      if (!await pathExists(path149.join(cwd, value))) {
         const sink = field === "data" ? warnings : errors;
         sink.push(issue("missing-module-path", `Module "${key}" declares ${String(field)} ${value}, which does not exist`, field === "data" ? `Run the module (e.g. \`keryx ${key} ...\`) to generate ${value}, or update modules.${key}.data in metaproject.json.` : `Create ${value} or update modules.${key}.${String(field)} in metaproject.json.`));
       }
     }
   }
   for (const { path: name, scope } of namedEntrypoints(manifest)) {
-    const filePath = path148.join(cwd, name);
+    const filePath = path149.join(cwd, name);
     if (!await pathExists(filePath)) {
       continue;
     }
@@ -47656,7 +47752,7 @@ async function runDoctor(cwd) {
   return validateWorkspace2(cwd);
 }
 async function readManifest2(cwd) {
-  const manifestPath = path149.join(cwd, ".metaproject", "metaproject.json");
+  const manifestPath = path150.join(cwd, ".metaproject", "metaproject.json");
   if (!await pathExists(manifestPath)) {
     throw new Error("Metaproject is not initialized (missing .metaproject/metaproject.json). Run `keryx init` first.");
   }