@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/{chunk-M5T5VO65.js → chunk-7EYHLWU7.js}

@@ -4,20 +4,21 @@ import {
 } from "./chunk-5WIGXA4T.js";
 import {
   loadMemoryRecordsSync
-} from "./chunk-PFEFKVGL.js";
+} from "./chunk-J5HN4RYU.js";
+import {
+  sha256
+} from "./chunk-6EJV5X2W.js";
 import {
   WIKI_INDEX,
   WIKI_PLAN_FILE,
   WIKI_QUICKSTART,
   changedPathsSince,
-  compileGlobRegex,
   computeWikiContentHash,
   computeWikiContentHashOfDir,
   currentWikiGitHead,
   isGeneratedWikiFile,
   listWikiPages,
   listWikiPagesInDir,
-  normalizeGlobInput,
   readWikiMeta,
   readWikiPage,
   readWikiPlanFile,
@@ -32,49 +33,53 @@ import {
   wikiStaleness,
   writeWikiMeta,
   writeWikiPlanFile
-} from "./chunk-7SS2CTV2.js";
+} from "./chunk-X4RCMKVQ.js";
 import {
-  computeFingerprint,
-  computeFingerprintAsync,
-  computeFingerprintCached,
-  isStale,
+  buildCodewikiCandidate,
+  coordinateCodewikiExclusive,
+  coordinateCodewikiWrite,
+  drainCodewikiWrites,
   readClioState,
   statePath,
   writeClioState
-} from "./chunk-BSU2YIWB.js";
+} from "./chunk-MVVUPGPW.js";
+import {
+  compileGlobRegex,
+  normalizeGlobInput
+} from "./chunk-VG7TBQIY.js";
+import {
+  detectProjectType
+} from "./chunk-YHZX5GEU.js";
+import {
+  computeFingerprintCached,
+  isStale
+} from "./chunk-VJWL6YS5.js";
 import {
-  buildCodewiki,
-  codewikiNeedsBackfill,
   codewikiPath,
-  createSlicer,
-  detectProjectType,
-  enumerateWorkspaceFiles,
-  parseCodewikiRaw,
-  readCodewiki,
-  readCodewikiAsync,
-  syncCodewiki,
-  updateCodewikiPaths,
-  writeCodewiki
-} from "./chunk-N6F52NLF.js";
+  readCodewiki
+} from "./chunk-LBMZMYH2.js";
 import {
-  classifyProjectPreload
-} from "./chunk-K5XEMXTI.js";
+  enumerateWorkspaceFiles
+} from "./chunk-EKMEHE4H.js";
 import {
   ceilChars
-} from "./chunk-H6F6BYOH.js";
+} from "./chunk-LZSJBIVT.js";
 import {
   INTEROP_AGENT_KINDS
 } from "./chunk-IHXBNWMM.js";
-import {
-  BusChannels
-} from "./chunk-Q5WJOSJ7.js";
 import {
   require_dist
-} from "./chunk-GB6QRBXN.js";
+} from "./chunk-APJ265NV.js";
 import {
   clioDataDir,
   resolveClioDirs
 } from "./chunk-BNAZZHFG.js";
+import {
+  BusChannels
+} from "./chunk-OQ33BKR3.js";
+import {
+  classifyProjectPreload
+} from "./chunk-JVCV3ICN.js";
 import {
   resolvePackageRoot
 } from "./chunk-IWHMRKLL.js";
@@ -86,12 +91,6 @@ import {
 // src/domains/context/index.ts
 init_esm_shims();
 
-// src/domains/context/extension.ts
-init_esm_shims();
-import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
-import { isAbsolute, relative as relative3 } from "node:path";
-
 // src/domains/context/adoption.ts
 init_esm_shims();
 import { createHash } from "node:crypto";
@@ -159,7 +158,7 @@ var SECRET_LINE_PATTERNS = [
   /\bxox[baprs]-[A-Za-z0-9-]{20,}\b/,
   /\bAIza[0-9A-Za-z_-]{20,}\b/
 ];
-function sha256(text) {
+function sha2562(text) {
   return createHash("sha256").update(text).digest("hex");
 }
 function normalizeText(text) {
@@ -236,8 +235,8 @@ function discoverCandidateSpecs(cwd, home, includeGlobal) {
   const specs = [];
   const seen = /* @__PURE__ */ new Set();
   let order = 0;
-  const add = (path, scope, provider, kind) => {
-    const abs = resolve(path);
+  const add = (path2, scope, provider, kind) => {
+    const abs = resolve(path2);
     if (seen.has(abs)) return;
     seen.add(abs);
     const scopedDir = scope === "project" && kind === "instructions" ? relative(cwd, dirname(abs)) : "";
@@ -509,7 +508,7 @@ function rejectedCandidate(spec, displayPath2, reason, evidence) {
     kind: spec.kind,
     ...spec.directoryScope ? { directoryScope: spec.directoryScope } : {},
     reason,
-    fingerprintSha256: sha256(`rejected\0${reason}\0${evidence}`)
+    fingerprintSha256: sha2562(`rejected\0${reason}\0${evidence}`)
   };
 }
 function statEvidence(stat) {
@@ -558,7 +557,7 @@ function readCandidate(spec, cwd, home) {
     kindLabel: KIND_LABELS[spec.kind],
     ...spec.directoryScope ? { directoryScope: spec.directoryScope } : {},
     content,
-    contentSha256: sha256(content),
+    contentSha256: sha2562(content),
     byteLength: Buffer.byteLength(content, "utf8"),
     itemCount: rules.length,
     order: spec.order
@@ -622,7 +621,7 @@ function scanAgentConfigs(options) {
         kind: result.kind,
         ...result.directoryScope ? { directoryScope: result.directoryScope } : {},
         reason: "aggregate source byte budget exceeded",
-        fingerprintSha256: sha256(`rejected\0aggregate source byte budget exceeded\0${result.contentSha256}`)
+        fingerprintSha256: sha2562(`rejected\0aggregate source byte budget exceeded\0${result.contentSha256}`)
       });
       continue;
     }
@@ -648,8 +647,8 @@ function scanAgentConfigs(options) {
   };
 }
 function renderSourceList(paths) {
-  if (paths.length <= 3) return paths.map((path) => `\`${path}\``).join(", ");
-  return `${paths.slice(0, 3).map((path) => `\`${path}\``).join(", ")} +${paths.length - 3} more`;
+  if (paths.length <= 3) return paths.map((path2) => `\`${path2}\``).join(", ");
+  return `${paths.slice(0, 3).map((path2) => `\`${path2}\``).join(", ")} +${paths.length - 3} more`;
 }
 function quoteShort(text) {
   const cleaned = text.replace(/\s+/g, " ").trim();
@@ -756,12 +755,12 @@ function adoptionSourcesChanged(snapshots, options = {}) {
 init_esm_shims();
 import { execFileSync } from "node:child_process";
 import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "node:fs";
-import { dirname as dirname2, join as join4, parse } from "node:path";
+import { dirname as dirname3, join as join4, parse } from "node:path";
 
 // src/domains/context/clio-md.ts
 init_esm_shims();
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { basename as basename2, dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
 var FOOTER_RE = /<!--\s*clio:fingerprint v1\s*\n([\s\S]*?)\n\s*-->/;
 var H1_RE = /^#\s+(.+?)\s*$/gm;
 var H2_RE = /^##\s+(.+?)\s*$/gm;
@@ -973,7 +972,10 @@ function serializeClioMd(input) {
 function renderProjectTypeFragment(projectType) {
   return `<project-type>${projectType}</project-type>`;
 }
-function renderProjectContextFragment(parsed) {
+function escapeXmlAttribute(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function renderProjectContextFragment(parsed, sourcePath) {
   const sections = [`# ${parsed.projectName}`, parsed.identity];
   if (parsed.conventions.length > 0) {
     sections.push("## Conventions", ...parsed.conventions.map((item) => `- ${item}`));
@@ -987,24 +989,82 @@ function renderProjectContextFragment(parsed) {
   if (parsed.importedAgentContext) {
     sections.push("## Imported agent context", parsed.importedAgentContext);
   }
-  return `<project-context>
+  const source = sourcePath ? ` path="${escapeXmlAttribute(sourcePath)}"` : "";
+  return `<project-context${source}>
 ${sections.join("\n\n")}
 </project-context>`;
 }
-function tryReadClioMd(cwd) {
-  const filePath = join2(cwd, "CLIO-CODER.md");
-  if (!existsSync2(filePath)) return null;
+var PROJECT_CONTEXT_CANDIDATES = ["CLIO-CODER.override.md", "CLIO-CODER.md"];
+function selectedClioMdPath(directory) {
+  for (const filename of PROJECT_CONTEXT_CANDIDATES) {
+    const filePath = join2(directory, filename);
+    if (!existsSync2(filePath)) continue;
+    try {
+      if (statSync2(filePath).isFile()) return filePath;
+    } catch {
+      return filePath;
+    }
+  }
+  return null;
+}
+function readClioMdPath(filePath) {
   let content;
   try {
     content = readFileSync2(filePath, "utf8");
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { ok: false, error: message };
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
   const parsed = parseClioMd(content);
   if (!parsed.ok) return { ok: false, error: parsed.errors.join("; ") };
   return { ok: true, value: parsed.value };
 }
+function mergeClioMdFiles(files) {
+  const nearest = files.at(-1)?.value;
+  if (!nearest) return null;
+  return {
+    projectName: nearest.projectName,
+    identity: files.map((file) => file.value.identity).join("\n\n"),
+    conventions: files.flatMap((file) => file.value.conventions),
+    invariants: files.flatMap((file) => file.value.invariants),
+    sections: files.flatMap((file) => file.value.sections),
+    importedAgentContext: files.map((file) => file.value.importedAgentContext).filter((value) => value !== null).join("\n\n") || null,
+    fingerprint: nearest.fingerprint,
+    firstInit: nearest.firstInit,
+    warnings: files.flatMap((file) => file.value.warnings)
+  };
+}
+function loadProjectClioMd(cwd) {
+  const directories = [];
+  let directory = resolve2(cwd);
+  while (true) {
+    directories.unshift(directory);
+    const parent = dirname2(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  const selectedPaths = [];
+  for (const current of directories) {
+    const selected = selectedClioMdPath(current);
+    if (!selected) continue;
+    if (basename2(selected) === "CLIO-CODER.override.md") {
+      selectedPaths.length = 0;
+    }
+    selectedPaths.push(selected);
+  }
+  const files = [];
+  const errors = [];
+  for (const filePath of selectedPaths) {
+    const read = readClioMdPath(filePath);
+    if (read.ok) files.push({ path: filePath, value: read.value });
+    else errors.push({ path: filePath, error: read.error });
+  }
+  return { files, errors, value: mergeClioMdFiles(files) };
+}
+function tryReadClioMd(cwd) {
+  const filePath = join2(cwd, "CLIO-CODER.md");
+  if (!existsSync2(filePath)) return null;
+  return readClioMdPath(filePath);
+}
 
 // src/domains/context/project-metadata.ts
 init_esm_shims();
@@ -1062,6 +1122,14 @@ function tomlTableValue(raw, table, key) {
   }
   return null;
 }
+function hasTomlTable(raw, table) {
+  const header = `[${table}]`;
+  return raw.split(/\r?\n/u).some((line) => {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith(header)) return false;
+    return /^\s*(?:#.*)?$/u.test(trimmed.slice(header.length));
+  });
+}
 function keyEqualsValue(raw, key) {
   const match = new RegExp(`^[ \\t]*${key}[ \\t]*(?:\\+?=)[ \\t]*(.+)$`, "mu").exec(raw);
   const value = match?.[1]?.trim();
@@ -1354,13 +1422,12 @@ function renderPromptContext(cwd) {
   const projectType = detectProjectType(cwd);
   const pieces = [renderProjectTypeFragment(projectType)];
   const warnings = [];
-  const clio = tryReadClioMd(cwd);
-  let clioMd = null;
-  if (clio?.ok) {
-    clioMd = clio.value;
-    pieces.push(renderProjectContextFragment(clio.value));
+  const loadedClioMd = loadProjectClioMd(cwd);
+  const clioMd = loadedClioMd.value;
+  for (const file of loadedClioMd.files) pieces.push(renderProjectContextFragment(file.value, file.path));
+  for (const issue of loadedClioMd.errors) {
+    warnings.push(`clio: malformed ${issue.path} ignored: ${issue.error}`);
   }
-  if (clio && !clio.ok) warnings.push(`clio: malformed CLIO-CODER.md ignored: ${clio.error}`);
   const codewiki = readCodewiki(cwd);
   if (codewiki) {
     const state = readClioState(cwd);
@@ -1382,7 +1449,7 @@ function renderPromptContext(cwd) {
     const suffix = notes.length > 0 ? ` (${notes.join("; ")}; run clio-coder context wiki --update)` : "";
     pieces.push(`<wiki>${pages.length} pages at .clio-coder/wiki (start: quickstart.md)${suffix}</wiki>`);
   }
-  return { text: pieces.join("\n\n"), clioMd, warnings };
+  return { text: pieces.join("\n\n"), clioMd, warnings, handbookFiles: loadedClioMd.files.map((file) => file.path) };
 }
 
 // src/domains/context/bootstrap.ts
@@ -1597,6 +1664,44 @@ function packageManager(cwd) {
   return "npm";
 }
 var MUTATING_SCRIPT_RE = /(?:^|\s)--(?:fix|write)(?:\s|$)/;
+function cmakePresetName(presets, key) {
+  if (typeof presets !== "object" || presets === null || Array.isArray(presets)) return null;
+  const list = presets[key];
+  if (!Array.isArray(list)) return null;
+  for (const entry of list) {
+    if (entry?.hidden === true) continue;
+    const name2 = stringField2(entry, "name");
+    if (name2 !== null) return name2;
+  }
+  return null;
+}
+function cmakeVerificationLines(cwd) {
+  const presets = readJsonFile(join4(cwd, "CMakePresets.json"));
+  if (presets === null) return [];
+  const configure = cmakePresetName(presets, "configurePresets");
+  const build = cmakePresetName(presets, "buildPresets");
+  const test = cmakePresetName(presets, "testPresets");
+  const lines = [];
+  if (configure !== null) lines.push(`Configure with \`cmake --preset ${configure}\`.`);
+  if (build !== null) lines.push(`Build with \`cmake --build --preset ${build}\`.`);
+  if (test !== null) lines.push(`Run tests with \`ctest --preset ${test}\`.`);
+  return lines;
+}
+function pythonVerificationLines(cwd) {
+  let pyproject = "";
+  try {
+    pyproject = readFileSync4(join4(cwd, "pyproject.toml"), "utf8");
+  } catch {
+    pyproject = "";
+  }
+  if (existsSync4(join4(cwd, "tox.ini")) || hasTomlTable(pyproject, "tool.tox")) {
+    return ["Run `tox` before handoff."];
+  }
+  if (existsSync4(join4(cwd, "pytest.ini")) || hasTomlTable(pyproject, "tool.pytest.ini_options")) {
+    return ["Run `pytest` before handoff."];
+  }
+  return [];
+}
 function verificationSection(cwd) {
   const scripts = packageScripts(cwd);
   const pm = packageManager(cwd);
@@ -1624,6 +1729,14 @@ function verificationSection(cwd) {
   if (hasScript("ci")) {
     lines.push(`Use ${command("ci")} for the full local gate before committing broad or shared behavior changes.`);
   }
+  lines.push(...cmakeVerificationLines(cwd));
+  if (existsSync4(join4(cwd, "Cargo.toml"))) {
+    lines.push("Run `cargo build` and `cargo test` before handoff.");
+  }
+  if (existsSync4(join4(cwd, "go.mod"))) {
+    lines.push("Run `go build ./...` and `go test ./...` before handoff.");
+  }
+  lines.push(...pythonVerificationLines(cwd));
   if (lines.length === 0) return null;
   return { title: "Verification expectations", body: lines.join(" ") };
 }
@@ -1751,12 +1864,10 @@ function stabilizeGeneratedOutput(input, base, onModelSectionRetained, groundMod
 function codewikiSections(codewiki) {
   const sections = [];
   const entryPoints = codewikiEntryPoints(codewiki, 8);
-  const indexedCount = indexedSourceFileCount(codewiki);
   if (entryPoints.length > 0) {
     sections.push({
       title: "Context retrieval",
       body: [
-        `The codewiki currently indexes ${indexedCount} source file${indexedCount === 1 ? "" : "s"}.`,
         `Start orientation with these indexed entry points: ${entryPoints.map((entry) => `\`${entry}\``).join(", ")}.`,
         "Use `code_nav` (modes: symbol, path, entries, outline, deps, dependents, wiki) before broad reads when the task is navigational."
       ].join(" ")
@@ -1852,7 +1963,7 @@ function countStatusLines(status) {
   return status.split("\n").map((line) => line.trim()).filter(Boolean).length;
 }
 function basenameList(paths) {
-  const names = paths.map((path) => parse(path).base).sort((a, b) => a.localeCompare(b));
+  const names = paths.map((path2) => parse(path2).base).sort((a, b) => a.localeCompare(b));
   if (names.length === 0) return "";
   if (names.length <= 3) return names.join(", ");
   return `${names.slice(0, 3).join(", ")} +${names.length - 3}`;
@@ -1974,7 +2085,7 @@ function serializeBootstrapOutput(output) {
 }
 function writeClioMdFile(cwd, output) {
   const clioMdPath = join4(cwd, "CLIO-CODER.md");
-  mkdirSync(dirname2(clioMdPath), { recursive: true });
+  mkdirSync(dirname3(clioMdPath), { recursive: true });
   const serialized = serializeBootstrapOutput(output);
   const parsed = parseClioMd(serialized);
   if (!parsed.ok) throw new Error(`bootstrap produced invalid CLIO-CODER.md: ${parsed.errors.join("; ")}`);
@@ -2032,8 +2143,7 @@ function durableGenerationTelemetry(telemetry) {
   }
   return state;
 }
-function writeProjectState(cwd, projectType, now, indexedAt, adoption, recordAdoption, codewikiVersion, generation, generated) {
-  const finalFingerprint = computeFingerprint(cwd);
+function writeProjectState(cwd, projectType, now, indexedAt, adoption, recordAdoption, codewikiVersion, fingerprint, generation, generated) {
   const statePath2 = statePath(cwd);
   const prev = readClioState(cwd);
   const lastBootstrap = generated ? durableGenerationTelemetry(generation) : prev?.lastBootstrap ?? durableGenerationTelemetry(generation);
@@ -2042,7 +2152,7 @@ function writeProjectState(cwd, projectType, now, indexedAt, adoption, recordAdo
   writeClioState(cwd, {
     version: 1,
     projectType,
-    fingerprint: finalFingerprint,
+    fingerprint,
     codewikiVersion,
     lastInitAt: now.toISOString(),
     lastSessionAt: now.toISOString(),
@@ -2053,13 +2163,12 @@ function writeProjectState(cwd, projectType, now, indexedAt, adoption, recordAdo
   });
   return statePath2;
 }
-function persistCodewikiForGeneration(cwd, projectType, indexedAt, codewiki) {
-  writeCodewiki(cwd, codewiki);
+function persistCodewikiForGeneration(cwd, projectType, indexedAt, codewiki, fingerprint) {
   const prev = readClioState(cwd);
   writeClioState(cwd, {
     version: 1,
     projectType,
-    fingerprint: computeFingerprint(cwd, codewiki),
+    fingerprint,
     codewikiVersion: codewiki.version,
     ...prev?.contextSources ? { contextSources: prev.contextSources } : {},
     ...prev?.contextSourceHash ? { contextSourceHash: prev.contextSourceHash } : {},
@@ -2096,7 +2205,7 @@ function codewikiEntryPoints(codewiki, limit = 6) {
     if (!("toFileId" in edge)) continue;
     inDegree.set(edge.toFileId, (inDegree.get(edge.toFileId) ?? 0) + 1);
   }
-  const ranked = [...inDegree.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([fileId]) => fileById.get(fileId)?.path).filter((path) => typeof path === "string").filter((path) => !tagged.includes(path));
+  const ranked = [...inDegree.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([fileId]) => fileById.get(fileId)?.path).filter((path2) => typeof path2 === "string").filter((path2) => !tagged.includes(path2));
   return [...tagged, ...ranked].slice(0, limit);
 }
 async function runBootstrap(input = {}) {
@@ -2124,7 +2233,21 @@ async function runBootstrap(input = {}) {
   const now = input.now?.() ?? /* @__PURE__ */ new Date();
   const indexedAt = now.toISOString();
   progress(input, { phase: "codewiki", status: "started", message: "building codewiki index" });
-  const codewiki = await buildCodewiki({ cwd, language: projectType, generatedAt: indexedAt });
+  let codewiki;
+  let codewikiFingerprint;
+  if (input.preview === true) {
+    const candidate = await buildCodewikiCandidate(cwd, projectType);
+    codewiki = candidate.codewiki;
+    codewikiFingerprint = candidate.fingerprint;
+  } else {
+    const coordinated = await coordinateCodewikiWrite(cwd, () => ({ kind: "build", cwd, language: projectType }), {
+      beforeCommit: (_result, workspace) => ensureGitignore(workspace, input),
+      afterCommit: ({ codewiki: committed, fingerprint }, workspace) => persistCodewikiForGeneration(workspace, projectType, indexedAt, committed, fingerprint)
+    });
+    if (!coordinated) throw new Error("codewiki bootstrap transaction did not commit");
+    codewiki = coordinated.codewiki;
+    codewikiFingerprint = coordinated.worker.fingerprint;
+  }
   const codewikiEntryCount = indexedSourceFileCount(codewiki);
   progress(input, {
     phase: "codewiki",
@@ -2133,10 +2256,6 @@ async function runBootstrap(input = {}) {
     current: codewikiEntryCount,
     total: codewikiEntryCount
   });
-  if (input.preview !== true) {
-    await ensureGitignore(cwd, input);
-    persistCodewikiForGeneration(cwd, projectType, indexedAt, codewiki);
-  }
   const hadClioMd = existsSync4(join4(cwd, "CLIO-CODER.md"));
   const useExistingClioMdAsSource = hadClioMd && input.rewriteClioMd !== true;
   const existingClioMdText = useExistingClioMdAsSource ? readExistingClioMdText(cwd) : null;
@@ -2282,6 +2401,7 @@ async function runBootstrap(input = {}) {
     adoption,
     adoptionApplied,
     codewiki.version,
+    codewikiFingerprint,
     generation,
     shouldGenerate
   );
@@ -2341,6 +2461,7 @@ var ACCUMULATED_CONTEXT_PATHS = [
 ];
 var PRESERVED_CONTEXT_PATHS = [
   "CLIO-CODER.md",
+  "CLIO-CODER.override.md",
   ".clio-coder/agents",
   ".clio-coder/skills",
   ".clio-coder/wiki"
@@ -2364,17 +2485,20 @@ async function runContextClear(input = {}) {
     out2(input.io, "clio-coder context reset cancelled; no files removed.\n");
     return { action: "cancelled", removed: [], preserved: [...PRESERVED_CONTEXT_PATHS] };
   }
-  const removed = [];
-  for (const relPath of ACCUMULATED_CONTEXT_PATHS) removeIfPresent(cwd, relPath, removed);
-  const preserved = [...PRESERVED_CONTEXT_PATHS];
-  if (input.all === true) {
-    const confirmedAll = await input.confirmAll?.();
-    if (confirmedAll === true) {
-      removeIfPresent(cwd, "CLIO-CODER.md", removed);
-      const index = preserved.indexOf("CLIO-CODER.md");
-      if (index !== -1) preserved.splice(index, 1);
+  const { removed, preserved } = await coordinateCodewikiExclusive(cwd, async (workspace) => {
+    const removed2 = [];
+    for (const relPath of ACCUMULATED_CONTEXT_PATHS) removeIfPresent(workspace, relPath, removed2);
+    const preserved2 = [...PRESERVED_CONTEXT_PATHS];
+    if (input.all === true) {
+      const confirmedAll = await input.confirmAll?.();
+      if (confirmedAll === true) {
+        removeIfPresent(workspace, "CLIO-CODER.md", removed2);
+        const index = preserved2.indexOf("CLIO-CODER.md");
+        if (index !== -1) preserved2.splice(index, 1);
+      }
     }
-  }
+    return { removed: removed2, preserved: preserved2 };
+  });
   out2(
     input.io,
     [
@@ -2386,130 +2510,378 @@ async function runContextClear(input = {}) {
   return { action: "cleared", removed, preserved };
 }
 
-// src/domains/context/refresh.ts
-init_esm_shims();
-import { writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join8 } from "node:path";
-
-// src/domains/context/wiki/generate.ts
-init_esm_shims();
-import {
-  closeSync,
-  copyFileSync,
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync3,
-  mkdtempSync,
-  openSync,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
-  renameSync,
-  rmSync as rmSync3,
-  statSync as statSync2,
-  writeSync
-} from "node:fs";
-import { dirname as dirname4, join as join7 } from "node:path";
-
-// src/domains/context/wiki/assemble.ts
+// src/domains/context/operator-profile.ts
 init_esm_shims();
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename as basename2, dirname as dirname3, join as join6, normalize, posix, relative as relative2 } from "node:path";
-var SOURCE_CITATION = /`((?:src|tests?|scripts|benchmarks|docs|packages|apps|lib|config|\.github)\/[^`\s:#]+)(?::(\d+)(?:-\d+)?)?(?::[A-Za-z_$][\w$.-]*)?`/g;
-var INTERNAL_LINK = /\[[^\]]*\]\((?![a-z][a-z\d+.-]*:|\/\/|#)([^)\s]+\.md)(?:#[^)\s]*)?\)/gi;
-var REPAIR_NOTE = /^<!-- clio:wiki .*-->$/gm;
-function readText2(filePath) {
-  try {
-    return readFileSync5(filePath, "utf8");
-  } catch {
-    return "";
-  }
-}
-function writeText(filePath, text) {
-  mkdirSync2(dirname3(filePath), { recursive: true });
-  writeFileSync2(filePath, text, "utf8");
+var import_yaml2 = __toESM(require_dist(), 1);
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+import { join as join6 } from "node:path";
+var RESPONSE_POSTURES = ["concise", "balanced", "thorough"];
+var VALIDATION_PREFERENCES = ["tests-first", "manual", "trust"];
+var COMMIT_MESSAGE_STYLES = ["conventional", "descriptive", "terse"];
+var OPERATOR_PROFILE_MAX_CHARS = 700;
+var OPERATOR_PROFILE_MAX_LOCAL_PATHS = 8;
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function stripRepairNotes(body) {
-  return body.replace(REPAIR_NOTE, "").replace(/\n{3,}/g, "\n\n");
+function readEnum(value, allowed, field, issues) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string" && allowed.includes(value)) return value;
+  issues.push(`${field} must be one of ${allowed.join(", ")}`);
+  return void 0;
 }
-function renderRepairNote(issues) {
-  const links = issues.filter((issue) => issue.kind === "link").map((issue) => issue.reference);
-  const citations = issues.filter((issue) => issue.kind === "citation").map((issue) => issue.reference);
-  const parts = [];
-  if (links.length > 0) parts.push(`unresolved links: ${[...new Set(links)].join(", ")}`);
-  if (citations.length > 0) parts.push(`unresolved sources: ${[...new Set(citations)].join(", ")}`);
-  return parts.length === 0 ? "" : `
-<!-- clio:wiki ${parts.join("; ")} -->
-`;
+function readProfileBlob(value, issues) {
+  if (!isRecord2(value)) {
+    if (value !== null && value !== void 0) issues.push("profile must be a mapping at the root");
+    return {};
+  }
+  const profile = {};
+  const posture = readEnum(value.responsePosture, RESPONSE_POSTURES, "responsePosture", issues);
+  if (posture) profile.responsePosture = posture;
+  const validation = readEnum(value.validationPreference, VALIDATION_PREFERENCES, "validationPreference", issues);
+  if (validation) profile.validationPreference = validation;
+  const commit = readEnum(value.commitMessageStyle, COMMIT_MESSAGE_STYLES, "commitMessageStyle", issues);
+  if (commit) profile.commitMessageStyle = commit;
+  if (value.localOnlyPaths !== void 0) {
+    if (Array.isArray(value.localOnlyPaths)) {
+      const paths = value.localOnlyPaths.filter((item) => typeof item === "string" && item.length > 0);
+      if (paths.length > 0) profile.localOnlyPaths = paths.slice(0, OPERATOR_PROFILE_MAX_LOCAL_PATHS);
+    } else {
+      issues.push("localOnlyPaths must be an array of strings");
+    }
+  }
+  return profile;
 }
-function repairPage(dir, sourceRoot, relPath, knownPages) {
-  const filePath = join6(dir, relPath);
-  const original = readText2(filePath);
-  const parsed = readWikiPage({ pagePath: relPath, content: original, sourceRoot });
-  const body = stripRepairNotes(parsed.body);
-  if (body.replace(/^#.*$/gm, "").trim().length === 0) {
-    return { metadata: parsed.metadata, changed: false, issues: [], empty: true };
+function readProfileFile(path2, issues) {
+  if (!existsSync6(path2)) return { profile: {}, present: false };
+  try {
+    return { profile: readProfileBlob((0, import_yaml2.parse)(readFileSync5(path2, "utf8")), issues), present: true };
+  } catch (err) {
+    issues.push(`${path2}: invalid YAML: ${err instanceof Error ? err.message : String(err)}`);
+    return { profile: {}, present: false };
   }
+}
+function loadOperatorProfile(cwd, options = {}) {
   const issues = [];
-  for (const cited of parsed.unresolvedPaths) {
-    issues.push({ page: relPath, kind: "citation", reference: cited });
-  }
-  for (const match of body.matchAll(SOURCE_CITATION)) {
-    const cited = match[1] ?? "";
-    if (resolveSourcePath(sourceRoot, cited) === null) {
-      issues.push({ page: relPath, kind: "citation", reference: cited });
-    }
+  const userPath = options.userPath ?? join6(resolveClioDirs().config, "profile.yaml");
+  const projectPath = join6(cwd, ".clio-coder", "profile.yaml");
+  const user = readProfileFile(userPath, issues);
+  const project = readProfileFile(projectPath, issues);
+  const profile = { ...user.profile, ...project.profile };
+  let origin = "none";
+  let sourcePath;
+  if (project.present) {
+    origin = "project";
+    sourcePath = projectPath;
+  } else if (user.present) {
+    origin = "user";
+    sourcePath = userPath;
   }
-  for (const match of body.matchAll(INTERNAL_LINK)) {
-    const href = match[1] ?? "";
-    const target = posix.normalize(posix.join(posix.dirname(relPath), href));
-    if (target.startsWith("..") || !knownPages.has(target)) {
-      issues.push({ page: relPath, kind: "link", reference: href });
-    }
+  const result = { profile, origin, issues };
+  if (sourcePath !== void 0) {
+    result.sourcePath = sourcePath;
+    result.hash = createHash2("sha256").update(JSON.stringify(profile)).digest("hex").slice(0, 16);
   }
-  const rebuilt = `${renderWikiPage(parsed.metadata, body).trimEnd()}
-${renderRepairNote(issues)}`;
-  if (rebuilt !== original) writeText(filePath, rebuilt);
-  return { metadata: parsed.metadata, changed: rebuilt !== original, issues, empty: false };
+  return result;
 }
-function linkTo(fromDir, target) {
-  const href = posix.relative(fromDir === "." ? "" : fromDir, target);
-  return href.length > 0 ? href : posix.basename(target);
+function renderOperatorProfile(profile) {
+  const lines = [];
+  if (profile.responsePosture) lines.push(`- Response posture: ${profile.responsePosture}.`);
+  if (profile.validationPreference) lines.push(`- Validation preference: ${profile.validationPreference}.`);
+  if (profile.commitMessageStyle) lines.push(`- Commit-message style: ${profile.commitMessageStyle}.`);
+  if (profile.localOnlyPaths && profile.localOnlyPaths.length > 0) {
+    lines.push(`- Keep local-only (do not push or share): ${profile.localOnlyPaths.join(", ")}.`);
+  }
+  if (lines.length === 0) return { text: "", tokenEstimate: 0 };
+  const full = `## Operator profile
+${lines.join("\n")}`;
+  const text = full.length > OPERATOR_PROFILE_MAX_CHARS ? `${full.slice(0, OPERATOR_PROFILE_MAX_CHARS - 1)}\u2026` : full;
+  return { text, tokenEstimate: ceilChars(text.length) };
 }
-function escapeCell(value) {
-  return value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+
+// src/domains/context/project-rules.ts
+init_esm_shims();
+var import_yaml3 = __toESM(require_dist(), 1);
+import { createHash as createHash3 } from "node:crypto";
+import { readdirSync as readdirSync3, readFileSync as readFileSync6 } from "node:fs";
+import { join as join7, relative as relative2, sep as sep2 } from "node:path";
+var FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?/;
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function codeList(values, limit) {
-  if (values.length === 0) return "\u2014";
-  const shown = values.slice(0, limit).map((value) => `\`${escapeCell(value)}\``);
-  return values.length > limit ? `${shown.join(", ")}, \u2026` : shown.join(", ");
+function readStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out3 = [];
+  for (const item of value) {
+    if (typeof item === "string" && item.length > 0) out3.push(item);
+  }
+  return out3.length > 0 ? out3 : void 0;
 }
-function renderQuickstart(sourceRoot, plan, pages) {
-  const content = pages.filter((page) => page.path !== WIKI_QUICKSTART);
-  const lines = [`# ${basename2(sourceRoot)} wiki`, ""];
-  if (plan.overview.trim().length > 0) lines.push(plan.overview.trim(), "");
-  lines.push(
-    `This wiki is generated by \`clio-coder context wiki\` from ${content.length} page${content.length === 1 ? "" : "s"}. Each page opens with front matter naming the sources, symbols, and tests it documents.`,
-    "",
-    "## Pages",
-    ""
-  );
-  let currentSection = null;
-  for (const page of content) {
-    const section = posix.dirname(page.path);
-    if (section !== "." && section !== currentSection) {
-      lines.push(`- **${section}/**`);
-      currentSection = section;
-    }
-    const indent = section === "." ? "" : "  ";
-    const summary = page.metadata.summary.length > 0 ? ` \u2014 ${page.metadata.summary}` : "";
-    lines.push(`${indent}- [${page.metadata.title}](${page.path})${summary}`);
+function validateGlobArray(value, field, id, issues) {
+  const parsed = readStringArray(value);
+  if (parsed === void 0) {
+    issues.push(`${id}: frontmatter ${field} must be a non-empty string array`);
+    return void 0;
   }
-  const routable = content.filter(
-    (page) => page.metadata.sources.length > 0 || page.metadata.symbols.length > 0 || page.metadata.tests.length > 0
-  );
-  if (routable.length > 0) {
-    lines.push(
-      "",
-      "## Task routing",
+  for (const pattern of parsed) {
+    try {
+      compileGlobRegex(pattern);
+    } catch (err) {
+      issues.push(
+        `${id}: invalid ${field} glob ${JSON.stringify(pattern)}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return void 0;
+    }
+  }
+  return parsed;
+}
+function walkMarkdown(dir, root, out3) {
+  let entries;
+  try {
+    entries = readdirSync3(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = join7(dir, entry.name);
+    if (entry.isDirectory()) walkMarkdown(full, root, out3);
+    else if (entry.isFile() && entry.name.endsWith(".md")) out3.push(full);
+  }
+}
+function parseRule(filePath, root, issues) {
+  let text;
+  try {
+    text = readFileSync6(filePath, "utf8").replace(/\r\n/g, "\n");
+  } catch (err) {
+    issues.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+    return { excludes: [] };
+  }
+  const id = relative2(root, filePath).split(sep2).join("/");
+  let body = text;
+  let paths;
+  let excludes = [];
+  let enabled = true;
+  let description2;
+  let invalidFrontmatter = false;
+  const match = FRONTMATTER_RE.exec(text);
+  if (match) {
+    body = text.slice(match[0].length);
+    try {
+      const front = (0, import_yaml3.parse)(match[1] ?? "");
+      if (isRecord3(front)) {
+        if (Object.hasOwn(front, "paths")) {
+          const parsedPaths = validateGlobArray(front.paths, "paths", id, issues);
+          if (parsedPaths === void 0) invalidFrontmatter = true;
+          else paths = parsedPaths;
+        }
+        if (Object.hasOwn(front, "excludes")) {
+          const parsedExcludes = validateGlobArray(front.excludes, "excludes", id, issues);
+          if (parsedExcludes === void 0) invalidFrontmatter = true;
+          else excludes = parsedExcludes;
+        }
+        if (Object.hasOwn(front, "enabled")) {
+          if (typeof front.enabled === "boolean") enabled = front.enabled;
+          else {
+            issues.push(`${id}: frontmatter enabled must be a boolean`);
+            invalidFrontmatter = true;
+          }
+        }
+        if (Object.hasOwn(front, "description")) {
+          if (typeof front.description === "string") description2 = front.description;
+          else {
+            issues.push(`${id}: frontmatter description must be a string`);
+            invalidFrontmatter = true;
+          }
+        }
+      } else if (front !== null && front !== void 0) {
+        issues.push(`${id}: frontmatter must be a mapping`);
+        invalidFrontmatter = true;
+      }
+    } catch (err) {
+      issues.push(`${id}: invalid frontmatter: ${err instanceof Error ? err.message : String(err)}`);
+      invalidFrontmatter = true;
+    }
+  } else if (text.startsWith("---\n")) {
+    issues.push(`${id}: invalid frontmatter: missing closing marker`);
+    invalidFrontmatter = true;
+  }
+  if (invalidFrontmatter) return { excludes: [] };
+  const trimmedBody = body.trim();
+  const hash = createHash3("sha256").update(trimmedBody).digest("hex").slice(0, 16);
+  const rule = {
+    id,
+    sourcePath: join7(".clio-coder", "rules", id),
+    hash,
+    tokenEstimate: ceilChars(trimmedBody.length),
+    enabled,
+    body: trimmedBody
+  };
+  if (paths !== void 0) rule.paths = paths;
+  if (description2 !== void 0) rule.description = description2;
+  return { rule, excludes };
+}
+function loadProjectRules(cwd) {
+  const root = join7(cwd, ".clio-coder", "rules");
+  const issues = [];
+  const files = [];
+  walkMarkdown(root, root, files);
+  files.sort();
+  const rules = [];
+  const excludeSet = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const parsed = parseRule(file, root, issues);
+    if (parsed.rule) rules.push(parsed.rule);
+    for (const glob of parsed.excludes) excludeSet.add(glob);
+  }
+  rules.sort((a, b) => a.id.localeCompare(b.id));
+  return { rules, excludes: [...excludeSet], issues };
+}
+function ruleMatchesAnyPath(rule, workingPaths) {
+  for (const pattern of rule.paths ?? []) {
+    let regex;
+    try {
+      regex = compileGlobRegex(pattern);
+    } catch {
+      continue;
+    }
+    for (const path2 of workingPaths) {
+      if (regex.test(normalizeGlobInput(path2))) return true;
+    }
+  }
+  return false;
+}
+function selectActiveRules(rules, workingContextPaths) {
+  return rules.filter((rule) => {
+    if (!rule.enabled) return false;
+    if (rule.paths === void 0) return true;
+    return ruleMatchesAnyPath(rule, workingContextPaths);
+  });
+}
+
+// src/domains/context/refresh.ts
+init_esm_shims();
+import { writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join10 } from "node:path";
+
+// src/domains/context/wiki/generate.ts
+init_esm_shims();
+import {
+  closeSync,
+  copyFileSync,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync3,
+  mkdtempSync,
+  openSync,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync8,
+  renameSync,
+  rmSync as rmSync3,
+  statSync as statSync3,
+  writeSync
+} from "node:fs";
+import { dirname as dirname5, join as join9 } from "node:path";
+
+// src/domains/context/wiki/assemble.ts
+init_esm_shims();
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename as basename3, dirname as dirname4, join as join8, normalize, posix, relative as relative3 } from "node:path";
+var SOURCE_CITATION = /`((?:src|tests?|scripts|benchmarks|docs|packages|apps|lib|config|\.github)\/[^`\s:#]+)(?::(\d+)(?:-\d+)?)?(?::[A-Za-z_$][\w$.-]*)?`/g;
+var INTERNAL_LINK = /\[[^\]]*\]\((?![a-z][a-z\d+.-]*:|\/\/|#)([^)\s]+\.md)(?:#[^)\s]*)?\)/gi;
+var REPAIR_NOTE = /^<!-- clio:wiki .*-->$/gm;
+function readText2(filePath) {
+  try {
+    return readFileSync7(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+function writeText(filePath, text) {
+  mkdirSync2(dirname4(filePath), { recursive: true });
+  writeFileSync2(filePath, text, "utf8");
+}
+function stripRepairNotes(body) {
+  return body.replace(REPAIR_NOTE, "").replace(/\n{3,}/g, "\n\n");
+}
+function renderRepairNote(issues) {
+  const links = issues.filter((issue) => issue.kind === "link").map((issue) => issue.reference);
+  const citations = issues.filter((issue) => issue.kind === "citation").map((issue) => issue.reference);
+  const parts = [];
+  if (links.length > 0) parts.push(`unresolved links: ${[...new Set(links)].join(", ")}`);
+  if (citations.length > 0) parts.push(`unresolved sources: ${[...new Set(citations)].join(", ")}`);
+  return parts.length === 0 ? "" : `
+<!-- clio:wiki ${parts.join("; ")} -->
+`;
+}
+function repairPage(dir, sourceRoot, relPath, knownPages) {
+  const filePath = join8(dir, relPath);
+  const original = readText2(filePath);
+  const parsed = readWikiPage({ pagePath: relPath, content: original, sourceRoot });
+  const body = stripRepairNotes(parsed.body);
+  if (body.replace(/^#.*$/gm, "").trim().length === 0) {
+    return { metadata: parsed.metadata, changed: false, issues: [], empty: true };
+  }
+  const issues = [];
+  for (const cited of parsed.unresolvedPaths) {
+    issues.push({ page: relPath, kind: "citation", reference: cited });
+  }
+  for (const match of body.matchAll(SOURCE_CITATION)) {
+    const cited = match[1] ?? "";
+    if (resolveSourcePath(sourceRoot, cited) === null) {
+      issues.push({ page: relPath, kind: "citation", reference: cited });
+    }
+  }
+  for (const match of body.matchAll(INTERNAL_LINK)) {
+    const href = match[1] ?? "";
+    const target = posix.normalize(posix.join(posix.dirname(relPath), href));
+    if (target.startsWith("..") || !knownPages.has(target)) {
+      issues.push({ page: relPath, kind: "link", reference: href });
+    }
+  }
+  const rebuilt = `${renderWikiPage(parsed.metadata, body).trimEnd()}
+${renderRepairNote(issues)}`;
+  if (rebuilt !== original) writeText(filePath, rebuilt);
+  return { metadata: parsed.metadata, changed: rebuilt !== original, issues, empty: false };
+}
+function linkTo(fromDir, target) {
+  const href = posix.relative(fromDir === "." ? "" : fromDir, target);
+  return href.length > 0 ? href : posix.basename(target);
+}
+function escapeCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
+function codeList(values, limit) {
+  if (values.length === 0) return "\u2014";
+  const shown = values.slice(0, limit).map((value) => `\`${escapeCell(value)}\``);
+  return values.length > limit ? `${shown.join(", ")}, \u2026` : shown.join(", ");
+}
+function renderQuickstart(sourceRoot, plan, pages) {
+  const content = pages.filter((page) => page.path !== WIKI_QUICKSTART);
+  const lines = [`# ${basename3(sourceRoot)} wiki`, ""];
+  if (plan.overview.trim().length > 0) lines.push(plan.overview.trim(), "");
+  lines.push(
+    `This wiki is generated by \`clio-coder context wiki\` from ${content.length} page${content.length === 1 ? "" : "s"}. Each page opens with front matter naming the sources, symbols, and tests it documents.`,
+    "",
+    "## Pages",
+    ""
+  );
+  let currentSection = null;
+  for (const page of content) {
+    const section = posix.dirname(page.path);
+    if (section !== "." && section !== currentSection) {
+      lines.push(`- **${section}/**`);
+      currentSection = section;
+    }
+    const indent = section === "." ? "" : "  ";
+    const summary = page.metadata.summary.length > 0 ? ` \u2014 ${page.metadata.summary}` : "";
+    lines.push(`${indent}- [${page.metadata.title}](${page.path})${summary}`);
+  }
+  const routable = content.filter(
+    (page) => page.metadata.sources.length > 0 || page.metadata.symbols.length > 0 || page.metadata.tests.length > 0
+  );
+  if (routable.length > 0) {
+    lines.push(
+      "",
+      "## Task routing",
       "",
       "| Area | Page | Sources | Symbols | Tests | Validate |",
       "| --- | --- | --- | --- | --- | --- |"
@@ -2553,7 +2925,7 @@ function assembleWikiTree(input) {
   for (const relPath of authored) {
     const result = repairPage(dir, sourceRoot, relPath, knownPages);
     if (result.empty) {
-      rmSync2(join6(dir, relPath), { force: true });
+      rmSync2(join8(dir, relPath), { force: true });
       dropped.push(relPath);
       continue;
     }
@@ -2561,7 +2933,7 @@ function assembleWikiTree(input) {
     issues.push(...result.issues);
     assembled.push({ path: relPath, metadata: result.metadata });
   }
-  writeText(join6(dir, WIKI_QUICKSTART), renderQuickstart(sourceRoot, input.plan, assembled));
+  writeText(join8(dir, WIKI_QUICKSTART), renderQuickstart(sourceRoot, input.plan, assembled));
   const directories = /* @__PURE__ */ new Set(["."]);
   for (const page of assembled) {
     let section = posix.dirname(page.path);
@@ -2574,12 +2946,12 @@ function assembleWikiTree(input) {
     const pagesHere = assembled.filter((page) => posix.dirname(page.path) === directory);
     const sectionsHere = [...directories].filter((candidate) => candidate !== "." && posix.dirname(candidate) === directory).sort();
     const indexPath = directory === "." ? WIKI_INDEX : `${directory}/${WIKI_INDEX}`;
-    writeText(join6(dir, indexPath), renderIndex(directory, pagesHere, sectionsHere));
+    writeText(join8(dir, indexPath), renderIndex(directory, pagesHere, sectionsHere));
   }
   for (const relPath of wikiMarkdownFilesInDir(dir)) {
     if (!isGeneratedWikiFile(relPath) || relPath === WIKI_QUICKSTART) continue;
     const directory = posix.dirname(relPath);
-    if (!directories.has(directory)) rmSync2(join6(dir, relPath), { force: true });
+    if (!directories.has(directory)) rmSync2(join8(dir, relPath), { force: true });
   }
   return { pages: listWikiPagesInDir(dir), repaired, dropped, issues };
 }
@@ -2587,14 +2959,14 @@ function pageSourceIndex(dir, sourceRoot) {
   const index = /* @__PURE__ */ new Map();
   for (const relPath of wikiMarkdownFilesInDir(dir)) {
     if (isGeneratedWikiFile(relPath)) continue;
-    const { metadata } = readWikiPage({ pagePath: relPath, content: readText2(join6(dir, relPath)), sourceRoot });
+    const { metadata } = readWikiPage({ pagePath: relPath, content: readText2(join8(dir, relPath)), sourceRoot });
     index.set(relPath, [...metadata.sources, ...metadata.tests]);
   }
   return index;
 }
 function normalizeRepoPath(sourceRoot, candidate) {
-  const resolved = normalize(join6(sourceRoot, candidate));
-  const rel = relative2(sourceRoot, resolved);
+  const resolved = normalize(join8(sourceRoot, candidate));
+  const rel = relative3(sourceRoot, resolved);
   return rel.split("\\").join("/");
 }
 
@@ -2606,8 +2978,8 @@ var WIKI_DEPTH_STRATEGY = {
   detailed: { areaDepth: 3, areaShare: 8e-3, minAreaLines: 150 }
 };
 var MAX_PAGE_SOURCES = 8;
-function areaForPath(path, maxDepth) {
-  const directories = path.split("/").filter(Boolean).slice(0, -1);
+function areaForPath(path2, maxDepth) {
+  const directories = path2.split("/").filter(Boolean).slice(0, -1);
   if (directories.length === 0) return ".";
   return directories.slice(0, Math.max(1, maxDepth)).join("/");
 }
@@ -2699,14 +3071,14 @@ function dedupePagePaths(plan) {
   const seen = /* @__PURE__ */ new Set();
   const pages = [];
   for (const page of plan.pages) {
-    let path = page.path;
+    let path2 = page.path;
     let suffix = 2;
-    while (seen.has(path)) {
-      path = page.path.replace(/\.md$/, `-${suffix}.md`);
+    while (seen.has(path2)) {
+      path2 = page.path.replace(/\.md$/, `-${suffix}.md`);
       suffix += 1;
     }
-    seen.add(path);
-    pages.push({ ...page, path });
+    seen.add(path2);
+    pages.push({ ...page, path: path2 });
   }
   return { ...plan, pages };
 }
@@ -2726,29 +3098,38 @@ function indexedSourceFileCount2(codewiki) {
   return codewiki.files.filter((file) => file.lang !== "config").length;
 }
 async function loadOrBuildCodewiki(cwd) {
-  const existing = readCodewiki(cwd);
-  const prev = readClioState(cwd);
-  if (existing && !codewikiNeedsBackfill(existing)) {
-    const fingerprint = computeFingerprint(cwd, existing);
-    if (prev && !isStale(prev.fingerprint, fingerprint)) return existing;
-  }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const projectType = detectProjectType(cwd);
-  const rebuilt = await buildCodewiki({ cwd, language: projectType, generatedAt });
-  writeCodewiki(cwd, rebuilt);
-  writeClioState(cwd, {
-    version: 1,
-    projectType: prev?.projectType ?? projectType,
-    fingerprint: computeFingerprint(cwd, rebuilt),
-    codewikiVersion: rebuilt.version,
-    ...prev?.contextSources ? { contextSources: prev.contextSources } : {},
-    ...prev?.contextSourceHash ? { contextSourceHash: prev.contextSourceHash } : {},
-    ...prev?.lastBootstrap ? { lastBootstrap: prev.lastBootstrap } : {},
-    ...prev?.lastInitAt ? { lastInitAt: prev.lastInitAt } : {},
-    lastSessionAt: prev?.lastSessionAt ?? generatedAt,
-    lastIndexedAt: generatedAt
-  });
-  return rebuilt;
+  const coordinated = await coordinateCodewikiWrite(
+    cwd,
+    (current, workspace) => ({
+      kind: "ensure",
+      cwd: workspace,
+      language: projectType,
+      current,
+      previous: readClioState(workspace)?.fingerprint ?? null
+    }),
+    {
+      afterCommit: ({ codewiki, fingerprint, changed }, workspace) => {
+        const prev = readClioState(workspace);
+        if (!changed && prev) return;
+        writeClioState(workspace, {
+          version: 1,
+          projectType: prev?.projectType ?? projectType,
+          fingerprint,
+          codewikiVersion: codewiki.version,
+          ...prev?.contextSources ? { contextSources: prev.contextSources } : {},
+          ...prev?.contextSourceHash ? { contextSourceHash: prev.contextSourceHash } : {},
+          ...prev?.lastBootstrap ? { lastBootstrap: prev.lastBootstrap } : {},
+          ...prev?.lastInitAt ? { lastInitAt: prev.lastInitAt } : {},
+          lastSessionAt: prev?.lastSessionAt ?? generatedAt,
+          lastIndexedAt: generatedAt
+        });
+      }
+    }
+  );
+  if (!coordinated) throw new Error("codewiki wiki transaction did not commit");
+  return { codewiki: coordinated.codewiki, fingerprint: coordinated.worker.fingerprint };
 }
 function failed(problems, pages) {
   return { status: "failed", pages, problems };
@@ -2757,7 +3138,7 @@ var STAGING_PREFIX = "wiki-staging-";
 var WIKI_PREV_DIR = "wiki-prev";
 var WIKI_LOCK_FILE = "wiki.lock";
 function clioDir(cwd) {
-  return join7(cwd, ".clio-coder");
+  return join9(cwd, ".clio-coder");
 }
 function isProcessAlive(pid) {
   try {
@@ -2769,7 +3150,7 @@ function isProcessAlive(pid) {
 }
 function readLockPid(lockPath) {
   try {
-    const parsed = Number.parseInt(readFileSync6(lockPath, "utf8").trim(), 10);
+    const parsed = Number.parseInt(readFileSync8(lockPath, "utf8").trim(), 10);
     return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
   } catch {
     return null;
@@ -2778,7 +3159,7 @@ function readLockPid(lockPath) {
 function acquireWikiLock(cwd) {
   const dir = clioDir(cwd);
   mkdirSync3(dir, { recursive: true });
-  const lockPath = join7(dir, WIKI_LOCK_FILE);
+  const lockPath = join9(dir, WIKI_LOCK_FILE);
   const release = () => {
     try {
       rmSync3(lockPath, { force: true });
@@ -2828,10 +3209,10 @@ function removeDir(dir) {
 function seedStaging(cwd, stagingDir) {
   const source = wikiDir(cwd);
   for (const relPath of wikiMarkdownFilesInDir(source)) {
-    const target = join7(stagingDir, relPath);
-    mkdirSync3(dirname4(target), { recursive: true });
+    const target = join9(stagingDir, relPath);
+    mkdirSync3(dirname5(target), { recursive: true });
     try {
-      copyFileSync(join7(source, relPath), target);
+      copyFileSync(join9(source, relPath), target);
     } catch {
     }
   }
@@ -2841,29 +3222,29 @@ function adoptOrCreateStaging(cwd) {
   mkdirSync3(dir, { recursive: true });
   let entries;
   try {
-    entries = readdirSync3(dir, { withFileTypes: true });
+    entries = readdirSync4(dir, { withFileTypes: true });
   } catch {
     entries = [];
   }
-  const candidates = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(STAGING_PREFIX)).map((entry) => join7(dir, entry.name)).sort((a, b) => {
-    const at = statSync2(a).mtimeMs;
-    const bt = statSync2(b).mtimeMs;
+  const candidates = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(STAGING_PREFIX)).map((entry) => join9(dir, entry.name)).sort((a, b) => {
+    const at = statSync3(a).mtimeMs;
+    const bt = statSync3(b).mtimeMs;
     return bt - at;
   });
-  const resumable = candidates.find((candidate) => existsSync6(join7(candidate, WIKI_PLAN_FILE)));
+  const resumable = candidates.find((candidate) => existsSync7(join9(candidate, WIKI_PLAN_FILE)));
   for (const candidate of candidates) {
     if (candidate !== resumable) removeDir(candidate);
   }
   if (resumable !== void 0) return { dir: resumable, adopted: true };
-  const fresh = mkdtempSync(join7(dir, STAGING_PREFIX));
+  const fresh = mkdtempSync(join9(dir, STAGING_PREFIX));
   seedStaging(cwd, fresh);
   return { dir: fresh, adopted: false };
 }
 function promoteStaging(cwd, stagingDir, writeMeta) {
   const wiki = wikiDir(cwd);
-  const prev = join7(clioDir(cwd), WIKI_PREV_DIR);
+  const prev = join9(clioDir(cwd), WIKI_PREV_DIR);
   removeDir(prev);
-  const hadWiki = existsSync6(wiki);
+  const hadWiki = existsSync7(wiki);
   if (hadWiki) renameSync(wiki, prev);
   try {
     renameSync(stagingDir, wiki);
@@ -2891,7 +3272,7 @@ function resolvePlan(input) {
   if (input.mode === "update" && input.previousPlan !== void 0) {
     const pageSources = pageSourceIndex(input.stagingDir, input.cwd);
     const changed = new Set(
-      changedPathsSince(input.cwd, input.gitHead).map((path) => normalizeRepoPath(input.cwd, path))
+      changedPathsSince(input.cwd, input.gitHead).map((path2) => normalizeRepoPath(input.cwd, path2))
     );
     return {
       plan: scopePlanForUpdate({
@@ -2940,8 +3321,8 @@ async function runWikiGenerate(input = { model: "configured-clio-target" }) {
   }
   try {
     progress2(input, { phase: "codewiki", status: "started", message: "loading codewiki for wiki generation" });
-    const codewiki = await loadOrBuildCodewiki(cwd);
-    const sourceTreeHash = computeFingerprint(cwd, codewiki).treeHash;
+    const { codewiki, fingerprint } = await loadOrBuildCodewiki(cwd);
+    const sourceTreeHash = fingerprint.treeHash;
     const generation = planWikiGeneration(codewiki, input.depth ?? "auto");
     progress2(input, {
       phase: "codewiki",
@@ -3015,7 +3396,7 @@ async function runWikiGenerate(input = { model: "configured-clio-target" }) {
       message: `assembled ${report.pages.length} page${report.pages.length === 1 ? "" : "s"}`,
       detail: `${report.repaired} repaired; ${report.issues.length} unresolved reference${report.issues.length === 1 ? "" : "s"}` + (report.dropped.length > 0 ? `; ${report.dropped.length} empty page dropped` : "") + (pendingCount > 0 ? `; ${pendingCount} page${pendingCount === 1 ? "" : "s"} still to write` : "")
     });
-    rmSync3(join7(staging.dir, WIKI_PLAN_FILE), { force: true });
+    rmSync3(join9(staging.dir, WIKI_PLAN_FILE), { force: true });
     const afterHash = computeWikiContentHashOfDir(staging.dir);
     const stagedPages = listWikiPagesInDir(staging.dir);
     const problems = report.issues.map((issue) => `${issue.page} has an unresolved ${issue.kind}: ${issue.reference}`);
@@ -3098,7 +3479,7 @@ function curateClioMd(cwd, codewiki) {
     });
     if (!changed) return "unchanged";
     writeFileSync3(
-      join8(cwd, "CLIO-CODER.md"),
+      join10(cwd, "CLIO-CODER.md"),
       serializeClioMd({
         projectName: handbook.projectName,
         identity: handbook.identity,
@@ -3133,23 +3514,30 @@ async function runContextRefresh(input = {}) {
   const projectType = prev?.projectType ?? detectProjectType(cwd);
   const indexedAt = now().toISOString();
   input.onProgress?.({ phase: "codewiki", status: "started", message: "rebuilding codewiki" });
-  const codewiki = await buildCodewiki({ cwd, language: projectType, generatedAt: indexedAt });
-  writeCodewiki(cwd, codewiki);
-  const fingerprint = computeFingerprint(cwd, codewiki);
-  const clioMd = curateClioMd(cwd, codewiki);
-  input.onProgress?.({ phase: "state", status: "running", message: "writing state" });
-  writeClioState(cwd, {
-    version: 1,
-    projectType,
-    fingerprint,
-    codewikiVersion: codewiki.version,
-    ...prev?.contextSources ? { contextSources: prev.contextSources } : {},
-    ...prev?.contextSourceHash ? { contextSourceHash: prev.contextSourceHash } : {},
-    ...prev?.lastBootstrap ? { lastBootstrap: prev.lastBootstrap } : {},
-    ...prev?.lastInitAt ? { lastInitAt: prev.lastInitAt } : {},
-    lastSessionAt: prev?.lastSessionAt ?? indexedAt,
-    lastIndexedAt: indexedAt
+  let fingerprint;
+  let clioMd = "absent";
+  const coordinated = await coordinateCodewikiWrite(cwd, () => ({ kind: "build", cwd, language: projectType }), {
+    afterCommit: (result, workspace) => {
+      fingerprint = result.fingerprint;
+      clioMd = curateClioMd(workspace, result.codewiki);
+      input.onProgress?.({ phase: "state", status: "running", message: "writing state" });
+      const latest = readClioState(workspace);
+      writeClioState(workspace, {
+        version: 1,
+        projectType,
+        fingerprint: result.fingerprint,
+        codewikiVersion: result.codewiki.version,
+        ...latest?.contextSources ? { contextSources: latest.contextSources } : {},
+        ...latest?.contextSourceHash ? { contextSourceHash: latest.contextSourceHash } : {},
+        ...latest?.lastBootstrap ? { lastBootstrap: latest.lastBootstrap } : {},
+        ...latest?.lastInitAt ? { lastInitAt: latest.lastInitAt } : {},
+        lastSessionAt: latest?.lastSessionAt ?? indexedAt,
+        lastIndexedAt: indexedAt
+      });
+    }
   });
+  if (!coordinated || !fingerprint) throw new Error("codewiki refresh transaction did not commit");
+  const codewiki = coordinated.codewiki;
   const entries = indexedSourceFileCount3(codewiki);
   let wikiResult;
   let hint;
@@ -3166,7 +3554,8 @@ async function runContextRefresh(input = {}) {
   } else if (hasWiki) {
     hint = incompleteWikiHint(cwd) ?? (wikiStaleness(cwd).state === "stale" ? STALE_WIKI_REFRESH_HINT : void 0);
   }
-  const handbookNote = clioMd === "updated" ? "; CLIO-CODER.md index sections updated" : "";
+  const committedClioMd = clioMd;
+  const handbookNote = committedClioMd === "updated" ? "; CLIO-CODER.md index sections updated" : "";
   input.io?.stdout(
     `clio-coder context refresh: codewiki rebuilt (${entries} source file${entries === 1 ? "" : "s"})${handbookNote}
 `
@@ -3176,17 +3565,23 @@ async function runContextRefresh(input = {}) {
     action: "refreshed",
     codewikiEntries: entries,
     fingerprint,
-    clioMd,
+    clioMd: committedClioMd,
     ...wikiResult ? { wiki: wikiResult } : {},
     ...hint ? { hint } : {}
   };
 }
 
+// src/domains/context/runtime.ts
+init_esm_shims();
+
 // src/domains/context/extension.ts
-function persistState(cwd, fingerprint, indexedAt, prev, codewikiVersion) {
+init_esm_shims();
+import { existsSync as existsSync8 } from "node:fs";
+import { isAbsolute, join as join11, relative as relative4, resolve as resolve3 } from "node:path";
+function persistState(cwd, fingerprint, indexedAt, prev, codewikiVersion, projectType) {
   writeClioState(cwd, {
     version: 1,
-    projectType: prev?.projectType ?? detectProjectType(cwd),
+    projectType: prev?.projectType ?? projectType,
     fingerprint,
     codewikiVersion,
     ...prev?.contextSources ? { contextSources: prev.contextSources } : {},
@@ -3200,23 +3595,26 @@ function persistState(cwd, fingerprint, indexedAt, prev, codewikiVersion) {
 async function ensureCodewikiFresh(cwd) {
   if (process.env.CLIO_CODER_BOOTSTRAP_GENERATE_CHILD === "1") return;
   const state = readClioState(cwd);
-  if (!state && !existsSync7(codewikiPath(cwd))) return;
-  const slicer = createSlicer();
-  const codewiki = await readCodewikiAsync(cwd);
-  const fingerprint = await computeFingerprintAsync(cwd, codewiki, { slicer });
-  const stale = !state || isStale(state.fingerprint, fingerprint) || !existsSync7(codewikiPath(cwd)) || !codewiki || codewikiNeedsBackfill(codewiki);
-  if (!stale) return;
+  if (!state && !existsSync8(codewikiPath(cwd))) return;
   const indexedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const projectType = state?.projectType ?? detectProjectType(cwd);
-  const synced = codewiki ? await syncCodewiki(cwd, codewiki, { slicer }) : await buildCodewiki({ cwd, language: projectType, generatedAt: indexedAt }, { slicer });
-  writeCodewiki(cwd, synced);
-  persistState(cwd, await computeFingerprintAsync(cwd, synced, { slicer }), indexedAt, state, synced.version);
+  await coordinateCodewikiWrite(
+    cwd,
+    (current, workspace) => {
+      const language = readClioState(workspace)?.projectType ?? current?.language;
+      return {
+        kind: "ensure",
+        cwd,
+        ...language ? { language } : {},
+        current,
+        previous: readClioState(workspace)?.fingerprint ?? null
+      };
+    },
+    {
+      afterCommit: ({ codewiki, fingerprint }, workspace) => persistState(workspace, fingerprint, indexedAt, readClioState(workspace), codewiki.version, codewiki.language)
+    }
+  );
 }
 var CONTEXT_STATE_CACHE_TTL_MS = 1500;
-var CODEWIKI_CACHE_LIMIT = 4;
-function codewikiContentHash(raw) {
-  return createHash2("sha256").update(raw).digest("hex");
-}
 function memoryCount() {
   try {
     return loadMemoryRecordsSync(clioDataDir()).length;
@@ -3225,11 +3623,12 @@ function memoryCount() {
   }
 }
 function resolveClioMdState(cwd) {
-  const clio = tryReadClioMd(cwd);
-  if (!clio) return "none";
-  if (!clio.ok) return "malformed";
+  const clio = loadProjectClioMd(cwd);
+  if (clio.files.length === 0 && clio.errors.length === 0) return "none";
+  if (clio.errors.length > 0) return "malformed";
   const state = readClioState(cwd);
-  if (state?.contextSources !== void 0 && adoptionSourcesChanged(state.contextSources, { cwd })) {
+  const localStandardIsEffective = clio.files.some((file) => file.path === join11(resolve3(cwd), "CLIO-CODER.md"));
+  if (localStandardIsEffective && state?.contextSources !== void 0 && adoptionSourcesChanged(state.contextSources, { cwd })) {
     return "stale";
   }
   return "ok";
@@ -3258,12 +3657,12 @@ function collectStartupHints(cwd, options = {}) {
   } catch {
     projectType = "unknown";
   }
-  const clio = tryReadClioMd(cwd);
-  if (!clio && projectType !== "unknown" && options.noContextFiles !== true) {
+  const clio = loadProjectClioMd(cwd);
+  if (clio.files.length === 0 && clio.errors.length === 0 && projectType !== "unknown" && options.noContextFiles !== true) {
     hints.push("clio: No CLIO-CODER.md detected. Run /context init to explore the repo and bootstrap context.");
   }
-  if (clio && !clio.ok) {
-    hints.push(`clio: malformed CLIO-CODER.md ignored: ${clio.error}`);
+  for (const issue of clio.errors) {
+    hints.push(`clio: malformed ${issue.path} ignored: ${issue.error}`);
   }
   const state = readClioState(cwd);
   if (!state) return hints;
@@ -3274,44 +3673,9 @@ function collectStartupHints(cwd, options = {}) {
 }
 function createContextBundle(_context, options = {}) {
   let lastCwd = process.cwd();
+  let stopping = false;
   let startupHints = [];
   const contextState = createContextStateReader();
-  const codewikiCache = /* @__PURE__ */ new Map();
-  const rememberCodewiki = (cwd, hash, codewiki) => {
-    codewikiCache.delete(cwd);
-    codewikiCache.set(cwd, { hash, codewiki });
-    while (codewikiCache.size > CODEWIKI_CACHE_LIMIT) {
-      const oldest = codewikiCache.keys().next().value;
-      if (oldest === void 0) break;
-      codewikiCache.delete(oldest);
-    }
-  };
-  const readCachedCodewiki = (cwd) => {
-    let raw;
-    try {
-      raw = readFileSync7(codewikiPath(cwd), "utf8");
-    } catch {
-      codewikiCache.delete(cwd);
-      return null;
-    }
-    const hash = codewikiContentHash(raw);
-    const cached = codewikiCache.get(cwd);
-    if (cached && cached.hash === hash) {
-      rememberCodewiki(cwd, hash, cached.codewiki);
-      return cached.codewiki;
-    }
-    const codewiki = parseCodewikiRaw(raw);
-    if (!codewiki) {
-      codewikiCache.delete(cwd);
-      return null;
-    }
-    rememberCodewiki(cwd, hash, codewiki);
-    return codewiki;
-  };
-  const writeCachedCodewiki = (cwd, codewiki) => {
-    const serialized = writeCodewiki(cwd, codewiki);
-    rememberCodewiki(cwd, codewikiContentHash(serialized), codewiki);
-  };
   const onStart = () => {
     lastCwd = process.cwd();
     void ensureCodewikiFresh(lastCwd).catch(() => {
@@ -3323,23 +3687,30 @@ function createContextBundle(_context, options = {}) {
   };
   let incrementalQueue = Promise.resolve();
   const noteFileChanges = (paths, cwd = lastCwd) => {
+    if (stopping) return;
+    const workspace = resolve3(cwd);
     incrementalQueue = incrementalQueue.then(async () => {
       if (paths.length === 0) return;
-      const codewiki = readCachedCodewiki(cwd);
-      if (!codewiki) return;
-      const rel = paths.map((p) => isAbsolute(p) ? relative3(cwd, p) : p).filter((p) => p.length > 0 && !p.startsWith(".."));
-      const slicer = createSlicer();
-      const updated = await updateCodewikiPaths(cwd, codewiki, rel, { slicer });
-      if (updated === codewiki) return;
-      writeCachedCodewiki(cwd, updated);
-      persistState(
-        cwd,
-        await computeFingerprintAsync(cwd, updated, { slicer }),
-        (/* @__PURE__ */ new Date()).toISOString(),
-        readClioState(cwd),
-        updated.version
+      const rel = paths.map((p) => isAbsolute(p) ? relative4(workspace, p) : p).filter((p) => p.length > 0 && !p.startsWith(".."));
+      await coordinateCodewikiWrite(
+        workspace,
+        (current) => current ? { kind: "incremental", cwd: workspace, current, paths: rel } : null,
+        {
+          requireExisting: true,
+          afterCommit: ({ codewiki, fingerprint, changed }, committedWorkspace) => {
+            if (!changed) return;
+            persistState(
+              committedWorkspace,
+              fingerprint,
+              (/* @__PURE__ */ new Date()).toISOString(),
+              readClioState(committedWorkspace),
+              codewiki.version,
+              codewiki.language
+            );
+          }
+        }
       );
-      contextState.invalidate(cwd);
+      contextState.invalidate(workspace);
     }).catch(() => {
     });
   };
@@ -3349,33 +3720,13 @@ function createContextBundle(_context, options = {}) {
       unsubscribeSessionStart = _context.bus.on(BusChannels.SessionStart, onStart);
     },
     async stop() {
+      stopping = true;
       unsubscribeSessionStart?.();
       unsubscribeSessionStart = null;
-      await incrementalQueue;
-      const slicer = createSlicer();
-      const projectType = detectProjectType(lastCwd);
+      await Promise.all([incrementalQueue, drainCodewikiWrites(lastCwd)]);
       const state = readClioState(lastCwd);
-      let codewiki = readCachedCodewiki(lastCwd);
-      let fingerprint = await computeFingerprintAsync(lastCwd, codewiki, { slicer });
-      let lastIndexedAt = state?.lastIndexedAt;
-      if (!state || isStale(state.fingerprint, fingerprint) || !codewiki || codewikiNeedsBackfill(codewiki)) {
-        lastIndexedAt = (/* @__PURE__ */ new Date()).toISOString();
-        codewiki = codewiki ? await syncCodewiki(lastCwd, codewiki, { slicer }) : await buildCodewiki({ cwd: lastCwd, language: projectType, generatedAt: lastIndexedAt }, { slicer });
-        writeCachedCodewiki(lastCwd, codewiki);
-        fingerprint = await computeFingerprintAsync(lastCwd, codewiki, { slicer });
-      }
-      writeClioState(lastCwd, {
-        version: 1,
-        projectType,
-        fingerprint,
-        ...codewiki ? { codewikiVersion: codewiki.version } : {},
-        ...state?.contextSources ? { contextSources: state.contextSources } : {},
-        ...state?.contextSourceHash ? { contextSourceHash: state.contextSourceHash } : {},
-        ...state?.lastBootstrap ? { lastBootstrap: state.lastBootstrap } : {},
-        ...state?.lastInitAt ? { lastInitAt: state.lastInitAt } : {},
-        lastSessionAt: (/* @__PURE__ */ new Date()).toISOString(),
-        ...lastIndexedAt ? { lastIndexedAt } : {}
-      });
+      if (!state) return;
+      writeClioState(lastCwd, { ...state, lastSessionAt: (/* @__PURE__ */ new Date()).toISOString() });
     }
   };
   const contract = {
@@ -3466,16 +3817,13 @@ function createContextBundle(_context, options = {}) {
     },
     renderPromptContext,
     projectStructuredContext(cwd = process.cwd()) {
-      const clio = tryReadClioMd(cwd);
-      if (!clio?.ok) return null;
-      const verification = clio.value.sections.find(
-        (section) => section.title.toLowerCase() === "verification expectations"
-      );
-      const verificationBody = verification?.body.trim() ?? "";
+      const clio = loadProjectClioMd(cwd).value;
+      if (!clio) return null;
+      const verificationBody = clio.sections.filter((section) => section.title.toLowerCase() === "verification expectations").map((section) => section.body.trim()).filter((body) => body.length > 0).join("\n\n");
       return {
-        projectName: clio.value.projectName,
-        conventions: [...clio.value.conventions],
-        invariants: [...clio.value.invariants],
+        projectName: clio.projectName,
+        conventions: [...clio.conventions],
+        invariants: [...clio.invariants],
         ...verificationBody.length > 0 ? { verificationExpectations: verificationBody } : {}
       };
     },
@@ -3493,264 +3841,128 @@ var ContextManifest = {
   dependsOn: ["resources"]
 };
 
-// src/domains/context/operator-profile.ts
-init_esm_shims();
-var import_yaml2 = __toESM(require_dist(), 1);
-import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "node:fs";
-import { join as join9 } from "node:path";
-var RESPONSE_POSTURES = ["concise", "balanced", "thorough"];
-var VALIDATION_PREFERENCES = ["tests-first", "manual", "trust"];
-var COMMIT_MESSAGE_STYLES = ["conventional", "descriptive", "terse"];
-var OPERATOR_PROFILE_MAX_CHARS = 700;
-var OPERATOR_PROFILE_MAX_LOCAL_PATHS = 8;
-function isRecord2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function readEnum(value, allowed, field, issues) {
-  if (value === void 0) return void 0;
-  if (typeof value === "string" && allowed.includes(value)) return value;
-  issues.push(`${field} must be one of ${allowed.join(", ")}`);
-  return void 0;
-}
-function readProfileBlob(value, issues) {
-  if (!isRecord2(value)) {
-    if (value !== null && value !== void 0) issues.push("profile must be a mapping at the root");
-    return {};
-  }
-  const profile = {};
-  const posture = readEnum(value.responsePosture, RESPONSE_POSTURES, "responsePosture", issues);
-  if (posture) profile.responsePosture = posture;
-  const validation = readEnum(value.validationPreference, VALIDATION_PREFERENCES, "validationPreference", issues);
-  if (validation) profile.validationPreference = validation;
-  const commit = readEnum(value.commitMessageStyle, COMMIT_MESSAGE_STYLES, "commitMessageStyle", issues);
-  if (commit) profile.commitMessageStyle = commit;
-  if (value.localOnlyPaths !== void 0) {
-    if (Array.isArray(value.localOnlyPaths)) {
-      const paths = value.localOnlyPaths.filter((item) => typeof item === "string" && item.length > 0);
-      if (paths.length > 0) profile.localOnlyPaths = paths.slice(0, OPERATOR_PROFILE_MAX_LOCAL_PATHS);
-    } else {
-      issues.push("localOnlyPaths must be an array of strings");
-    }
-  }
-  return profile;
-}
-function readProfileFile(path, issues) {
-  if (!existsSync8(path)) return { profile: {}, present: false };
-  try {
-    return { profile: readProfileBlob((0, import_yaml2.parse)(readFileSync8(path, "utf8")), issues), present: true };
-  } catch (err) {
-    issues.push(`${path}: invalid YAML: ${err instanceof Error ? err.message : String(err)}`);
-    return { profile: {}, present: false };
-  }
-}
-function loadOperatorProfile(cwd, options = {}) {
-  const issues = [];
-  const userPath = options.userPath ?? join9(resolveClioDirs().config, "profile.yaml");
-  const projectPath = join9(cwd, ".clio-coder", "profile.yaml");
-  const user = readProfileFile(userPath, issues);
-  const project = readProfileFile(projectPath, issues);
-  const profile = { ...user.profile, ...project.profile };
-  let origin = "none";
-  let sourcePath;
-  if (project.present) {
-    origin = "project";
-    sourcePath = projectPath;
-  } else if (user.present) {
-    origin = "user";
-    sourcePath = userPath;
-  }
-  const result = { profile, origin, issues };
-  if (sourcePath !== void 0) {
-    result.sourcePath = sourcePath;
-    result.hash = createHash3("sha256").update(JSON.stringify(profile)).digest("hex").slice(0, 16);
-  }
-  return result;
-}
-function renderOperatorProfile(profile) {
-  const lines = [];
-  if (profile.responsePosture) lines.push(`- Response posture: ${profile.responsePosture}.`);
-  if (profile.validationPreference) lines.push(`- Validation preference: ${profile.validationPreference}.`);
-  if (profile.commitMessageStyle) lines.push(`- Commit-message style: ${profile.commitMessageStyle}.`);
-  if (profile.localOnlyPaths && profile.localOnlyPaths.length > 0) {
-    lines.push(`- Keep local-only (do not push or share): ${profile.localOnlyPaths.join(", ")}.`);
-  }
-  if (lines.length === 0) return { text: "", tokenEstimate: 0 };
-  const full = `## Operator profile
-${lines.join("\n")}`;
-  const text = full.length > OPERATOR_PROFILE_MAX_CHARS ? `${full.slice(0, OPERATOR_PROFILE_MAX_CHARS - 1)}\u2026` : full;
-  return { text, tokenEstimate: ceilChars(text.length) };
+// src/domains/context/runtime.ts
+var ContextDomainModule = {
+  manifest: ContextManifest,
+  createExtension: createContextBundle
+};
+function createContextDomainModule(options = {}) {
+  return {
+    manifest: ContextManifest,
+    createExtension: (context) => createContextBundle(context, options)
+  };
 }
 
-// src/domains/context/project-rules.ts
+// src/domains/context/wiki/prompts.ts
 init_esm_shims();
-var import_yaml3 = __toESM(require_dist(), 1);
-import { createHash as createHash4 } from "node:crypto";
-import { readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
-import { join as join10, relative as relative4, sep as sep2 } from "node:path";
-var FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?/;
-function isRecord3(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function readStringArray(value) {
-  if (!Array.isArray(value)) return void 0;
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { existsSync as existsSync9, realpathSync, statSync as statSync4 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join12, relative as relative5 } from "node:path";
+
+// src/domains/prompts/fragment-loader.ts
+init_esm_shims();
+var import_yaml4 = __toESM(require_dist(), 1);
+import { readdirSync as readdirSync5, readFileSync as readFileSync9 } from "node:fs";
+import path from "node:path";
+var frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+var fragmentIdRegex = /^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/;
+function defaultRootDir() {
+  return path.join(resolvePackageRoot(), "src", "domains", "prompts", "fragments");
+}
+function walk(root) {
   const out3 = [];
-  for (const item of value) {
-    if (typeof item === "string" && item.length > 0) out3.push(item);
-  }
-  return out3.length > 0 ? out3 : void 0;
-}
-function validateGlobArray(value, field, id, issues) {
-  const parsed = readStringArray(value);
-  if (parsed === void 0) {
-    issues.push(`${id}: frontmatter ${field} must be a non-empty string array`);
-    return void 0;
-  }
-  for (const pattern of parsed) {
-    try {
-      compileGlobRegex(pattern);
-    } catch (err) {
-      issues.push(
-        `${id}: invalid ${field} glob ${JSON.stringify(pattern)}: ${err instanceof Error ? err.message : String(err)}`
-      );
-      return void 0;
-    }
-  }
-  return parsed;
-}
-function walkMarkdown(dir, root, out3) {
   let entries;
   try {
-    entries = readdirSync4(dir, { withFileTypes: true });
+    entries = readdirSync5(root, { withFileTypes: true });
   } catch {
-    return;
+    return out3;
   }
   for (const entry of entries) {
-    const full = join10(dir, entry.name);
-    if (entry.isDirectory()) walkMarkdown(full, root, out3);
-    else if (entry.isFile() && entry.name.endsWith(".md")) out3.push(full);
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      out3.push(...walk(full));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".md")) {
+      out3.push(full);
+    }
   }
+  return out3.sort((left, right) => left.localeCompare(right));
 }
-function parseRule(filePath, root, issues) {
-  let text;
+function parseFragment(filePath, rootDir) {
+  const raw = readFileSync9(filePath, "utf8");
+  const rawRel = path.relative(rootDir, filePath);
+  const relPath = rawRel.split(path.sep).join("/");
+  const match = raw.match(frontmatterRegex);
+  if (!match) {
+    throw new Error(`fragment-loader: ${relPath}: missing or malformed YAML frontmatter`);
+  }
+  const frontmatterText = match[1] ?? "";
+  const body = match[2] ?? "";
+  let parsed;
   try {
-    text = readFileSync9(filePath, "utf8").replace(/\r\n/g, "\n");
+    parsed = import_yaml4.default.parse(frontmatterText);
   } catch (err) {
-    issues.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
-    return { excludes: [] };
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`fragment-loader: ${relPath}: invalid YAML frontmatter (${reason})`);
   }
-  const id = relative4(root, filePath).split(sep2).join("/");
-  let body = text;
-  let paths;
-  let excludes = [];
-  let enabled = true;
-  let description2;
-  let invalidFrontmatter = false;
-  const match = FRONTMATTER_RE.exec(text);
-  if (match) {
-    body = text.slice(match[0].length);
-    try {
-      const front = (0, import_yaml3.parse)(match[1] ?? "");
-      if (isRecord3(front)) {
-        if (Object.hasOwn(front, "paths")) {
-          const parsedPaths = validateGlobArray(front.paths, "paths", id, issues);
-          if (parsedPaths === void 0) invalidFrontmatter = true;
-          else paths = parsedPaths;
-        }
-        if (Object.hasOwn(front, "excludes")) {
-          const parsedExcludes = validateGlobArray(front.excludes, "excludes", id, issues);
-          if (parsedExcludes === void 0) invalidFrontmatter = true;
-          else excludes = parsedExcludes;
-        }
-        if (Object.hasOwn(front, "enabled")) {
-          if (typeof front.enabled === "boolean") enabled = front.enabled;
-          else {
-            issues.push(`${id}: frontmatter enabled must be a boolean`);
-            invalidFrontmatter = true;
-          }
-        }
-        if (Object.hasOwn(front, "description")) {
-          if (typeof front.description === "string") description2 = front.description;
-          else {
-            issues.push(`${id}: frontmatter description must be a string`);
-            invalidFrontmatter = true;
-          }
-        }
-      } else if (front !== null && front !== void 0) {
-        issues.push(`${id}: frontmatter must be a mapping`);
-        invalidFrontmatter = true;
-      }
-    } catch (err) {
-      issues.push(`${id}: invalid frontmatter: ${err instanceof Error ? err.message : String(err)}`);
-      invalidFrontmatter = true;
-    }
-  } else if (text.startsWith("---\n")) {
-    issues.push(`${id}: invalid frontmatter: missing closing marker`);
-    invalidFrontmatter = true;
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter must be a YAML object`);
   }
-  if (invalidFrontmatter) return { excludes: [] };
-  const trimmedBody = body.trim();
-  const hash = createHash4("sha256").update(trimmedBody).digest("hex").slice(0, 16);
-  const rule = {
+  const fm = parsed;
+  const id = fm.id;
+  if (typeof id !== "string" || !fragmentIdRegex.test(id)) {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.id must be a dot-separated namespace`);
+  }
+  const version = fm.version;
+  if (version !== 1) {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.version must be 1`);
+  }
+  const description2 = fm.description;
+  if (typeof description2 !== "string" || description2.trim() === "") {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.description must be a non-empty string`);
+  }
+  const dynamicRaw = fm.dynamic;
+  if (dynamicRaw !== void 0 && typeof dynamicRaw !== "boolean") {
+    throw new Error(`fragment-loader: ${relPath}: frontmatter.dynamic must be a boolean when present`);
+  }
+  return {
+    path: filePath,
+    relPath,
     id,
-    sourcePath: join10(".clio-coder", "rules", id),
-    hash,
-    tokenEstimate: ceilChars(trimmedBody.length),
-    enabled,
-    body: trimmedBody
+    version,
+    description: description2,
+    dynamic: dynamicRaw === true,
+    body,
+    contentHash: sha256(raw)
   };
-  if (paths !== void 0) rule.paths = paths;
-  if (description2 !== void 0) rule.description = description2;
-  return { rule, excludes };
 }
-function loadProjectRules(cwd) {
-  const root = join10(cwd, ".clio-coder", "rules");
-  const issues = [];
-  const files = [];
-  walkMarkdown(root, root, files);
-  files.sort();
-  const rules = [];
-  const excludeSet = /* @__PURE__ */ new Set();
+function loadFragments(options) {
+  const rootDir = typeof options === "string" ? options : options?.rootDir;
+  const resolvedRoot = rootDir ? path.resolve(rootDir) : defaultRootDir();
+  const files = walk(resolvedRoot);
+  const byId = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const parsed = parseRule(file, root, issues);
-    if (parsed.rule) rules.push(parsed.rule);
-    for (const glob of parsed.excludes) excludeSet.add(glob);
-  }
-  rules.sort((a, b) => a.id.localeCompare(b.id));
-  return { rules, excludes: [...excludeSet], issues };
-}
-function ruleMatchesAnyPath(rule, workingPaths) {
-  for (const pattern of rule.paths ?? []) {
-    let regex;
-    try {
-      regex = compileGlobRegex(pattern);
-    } catch {
-      continue;
-    }
-    for (const path of workingPaths) {
-      if (regex.test(normalizeGlobInput(path))) return true;
+    const fragment = parseFragment(file, resolvedRoot);
+    const existing = byId.get(fragment.id);
+    if (existing) {
+      throw new Error(
+        `fragment-loader: duplicate fragment id "${fragment.id}" in ${existing.relPath} and ${fragment.relPath}`
+      );
     }
+    byId.set(fragment.id, fragment);
   }
-  return false;
-}
-function selectActiveRules(rules, workingContextPaths) {
-  return rules.filter((rule) => {
-    if (!rule.enabled) return false;
-    if (rule.paths === void 0) return true;
-    return ruleMatchesAnyPath(rule, workingContextPaths);
-  });
+  return { byId, rootDir: resolvedRoot };
 }
 
 // src/domains/context/wiki/prompts.ts
-init_esm_shims();
-import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync10, realpathSync, statSync as statSync3 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join11, relative as relative5 } from "node:path";
-function fragmentPath(fragment) {
-  return join11(resolvePackageRoot(), "src", "domains", "prompts", "fragments", "wiki", `${fragment}.md`);
-}
 function readWikiFragment(fragment, substitutions) {
-  let text = readFileSync10(fragmentPath(fragment), "utf8").trim();
+  const id = `wiki.${fragment}`;
+  const loaded = loadFragments().byId.get(id);
+  if (!loaded) {
+    throw new Error(`context/wiki: fragment "${id}" not found; check prompts/fragments/wiki/${fragment}.md frontmatter`);
+  }
+  let text = loaded.body.trim();
   for (const [token, value] of Object.entries(substitutions)) {
     text = text.split(`{{${token}}}`).join(value);
   }
@@ -3780,11 +3992,11 @@ function repositoryGuidancePaths(cwd) {
   const seen = /* @__PURE__ */ new Set();
   const paths = [];
   for (const relPath of REPOSITORY_GUIDANCE_CANDIDATES) {
-    const absPath = join11(cwd, relPath);
+    const absPath = join12(cwd, relPath);
     if (!existsSync9(absPath)) continue;
     try {
       const resolved = realpathSync(absPath);
-      const stat = statSync3(resolved);
+      const stat = statSync4(resolved);
       if (!isWithin(root, resolved) || !stat.isFile() || stat.size === 0 || seen.has(resolved)) continue;
       seen.add(resolved);
       paths.push(relPath);
@@ -3800,7 +4012,7 @@ function repositoryGuidance(cwd) {
   }
   return [
     "Read every detected instruction file before drafting:",
-    ...paths.map((path) => `- ${path}`),
+    ...paths.map((path2) => `- ${path2}`),
     "Treat these files as repository instructions, not implementation proof. If one designates a planning, specification, or engineering-truth authority, read that authority before making status claims, then verify mutable implementation claims against live source, configuration, and tests."
   ].join("\n");
 }
@@ -3851,7 +4063,7 @@ function buildWikiPlanPrompt(input) {
   const plan = input.plan ?? generation.plan;
   const unclaimed = input.unclaimedAreas ?? [];
   const sections = [
-    readWikiFragment("plan", { planPath: join11(input.outputDir, WIKI_PLAN_FILE) }),
+    readWikiFragment("plan", { planPath: join12(input.outputDir, WIKI_PLAN_FILE) }),
     "## Repository scale",
     `${generation.sourceFiles} indexed source files, ${generation.sourceLines} source lines, decomposed at ${generation.depth} depth into ${generation.plan.pages.length} candidate pages.`,
     "## Candidate plan",
@@ -3901,7 +4113,7 @@ function buildWikiPagePrompt(input) {
   const siblingLines = input.siblings.filter((sibling) => sibling.path !== page.path).map((sibling) => `- ${sibling.path} \u2014 ${sibling.title}`);
   const sections = [
     readWikiFragment("page", {
-      pagePath: join11(input.outputDir, page.path),
+      pagePath: join12(input.outputDir, page.path),
       pageRelPath: page.path,
       pageTitle: page.title
     }),
@@ -3922,25 +4134,13 @@ ${page.sources.map((source) => `- ${source}`).join("\n")}` : "No anchor sources
   if (input.seeded) {
     sections.push(
       "## Revision",
-      `A previous version of this page is already at ${join11(input.outputDir, page.path)}. Read it first and revise it in place. Correct what the current source contradicts and fill what it omits; keep accurate prose as it stands.`
+      `A previous version of this page is already at ${join12(input.outputDir, page.path)}. Read it first and revise it in place. Correct what the current source contradicts and fill what it omits; keep accurate prose as it stands.`
     );
   }
   return `${sections.join("\n\n")}
 `;
 }
 
-// src/domains/context/index.ts
-var ContextDomainModule = {
-  manifest: ContextManifest,
-  createExtension: createContextBundle
-};
-function createContextDomainModule(options = {}) {
-  return {
-    manifest: ContextManifest,
-    createExtension: (context) => createContextBundle(context, options)
-  };
-}
-
 export {
   adoptionSnapshotsHash,
   scanAgentConfigs,
@@ -3948,11 +4148,17 @@ export {
   adoptionSourcesChanged,
   parseClioMd,
   serializeClioMd,
+  loadProjectClioMd,
   tryReadClioMd,
   renderPromptContext,
   fallbackBootstrapOutput,
   runBootstrap,
   runContextClear,
+  OPERATOR_PROFILE_MAX_CHARS,
+  loadOperatorProfile,
+  renderOperatorProfile,
+  loadProjectRules,
+  selectActiveRules,
   assembleWikiTree,
   WIKI_DEPTH_STRATEGY,
   pagePathForArea,
@@ -3960,14 +4166,10 @@ export {
   planWikiGeneration,
   runWikiGenerate,
   runContextRefresh,
-  OPERATOR_PROFILE_MAX_CHARS,
-  loadOperatorProfile,
-  renderOperatorProfile,
-  loadProjectRules,
-  selectActiveRules,
-  buildWikiPlanPrompt,
-  buildWikiPagePrompt,
   ContextDomainModule,
-  createContextDomainModule
+  createContextDomainModule,
+  loadFragments,
+  buildWikiPlanPrompt,
+  buildWikiPagePrompt
 };
-//# sourceMappingURL=chunk-M5T5VO65.js.map
+//# sourceMappingURL=chunk-7EYHLWU7.js.map