@iowarp/clio-coder 0.3.0

package/dist/chunk-UWIJNAOB.js

@@ -0,0 +1,3906 @@
+import {
+  renderCodewikiDigest
+} from "./chunk-X3BR7HWV.js";
+import {
+  loadMemoryRecordsSync
+} from "./chunk-VOO7NYPP.js";
+import {
+  WIKI_INDEX,
+  WIKI_PLAN_FILE,
+  WIKI_QUICKSTART,
+  changedPathsSince,
+  compileGlobRegex,
+  computeWikiContentHash,
+  computeWikiContentHashOfDir,
+  currentWikiGitHead,
+  isGeneratedWikiFile,
+  listWikiPages,
+  listWikiPagesInDir,
+  normalizeGlobInput,
+  readWikiMeta,
+  readWikiPage,
+  readWikiPlanFile,
+  renderWikiPage,
+  resolveSourcePath,
+  scopePlanForUpdate,
+  unclaimedCandidates,
+  wikiCompleteness,
+  wikiDir,
+  wikiMarkdownFilesInDir,
+  wikiMetaPath,
+  wikiStaleness,
+  writeWikiMeta,
+  writeWikiPlanFile
+} from "./chunk-GNGDQYDU.js";
+import {
+  computeFingerprint,
+  computeFingerprintAsync,
+  computeFingerprintCached,
+  isStale,
+  readClioState,
+  statePath,
+  writeClioState
+} from "./chunk-RQDWMVRB.js";
+import {
+  buildCodewiki,
+  codewikiNeedsBackfill,
+  codewikiPath,
+  createSlicer,
+  detectProjectType,
+  enumerateWorkspaceFiles,
+  parseCodewikiRaw,
+  readCodewiki,
+  readCodewikiAsync,
+  syncCodewiki,
+  updateCodewikiPaths,
+  writeCodewiki
+} from "./chunk-TPOCL34A.js";
+import {
+  classifyProjectPreload
+} from "./chunk-KBR4MZZR.js";
+import {
+  ceilChars
+} from "./chunk-TKHQ4DGZ.js";
+import {
+  BusChannels
+} from "./chunk-D5YD55AR.js";
+import {
+  clioDataDir,
+  resolveClioDirs
+} from "./chunk-X3NE4WVW.js";
+import {
+  resolvePackageRoot
+} from "./chunk-DXQNI4PC.js";
+
+// src/domains/context/extension.ts
+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
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+var MAX_SOURCE_BYTES = 128 * 1024;
+var MAX_TOTAL_SOURCE_BYTES = 1024 * 1024;
+var MAX_RECURSIVE_FILES = 80;
+var MAX_RULES_PER_SOURCE = 4;
+var MAX_IMPORTED_RULES = 20;
+var PROVIDER_LABELS = {
+  "claude-code": "Claude Code",
+  agents: "Agent Skills",
+  codex: "Codex",
+  gemini: "Gemini",
+  cursor: "Cursor",
+  copilot: "GitHub Copilot",
+  opencode: "OpenCode"
+};
+var KIND_LABELS = {
+  instructions: "instructions",
+  settings: "settings",
+  command: "command",
+  agent: "agent",
+  skill: "skill",
+  rule: "rule"
+};
+var GENERATED_OR_SECRET_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".clio-coder",
+  ".antigravitycli",
+  "node_modules",
+  "dist",
+  "build",
+  "target",
+  ".venv",
+  "venv",
+  "cache",
+  "caches",
+  "history",
+  "histories",
+  "sessions",
+  "logs",
+  "tmp",
+  "temp",
+  "state",
+  "projects"
+]);
+var UNSAFE_FILE_NAME_RE = /(^\.env(?:\.|$)|secret|credential|token|password|history|cache|session|\.log$|state\.json$)/i;
+var RULE_KEYWORDS = /\b(always|never|must|should|prefer|avoid|do not|don't|use|run|keep|write|allow|allows|deny|denies|enable|enables|define|defines)\b/i;
+var SECRET_LINE_PATTERNS = [
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----/i,
+  /\bauthorization\s*[:=]\s*bearer\s+\S+/i,
+  /\b(?:api[_-]?key|auth[_-]?token|access[_-]?token|refresh[_-]?token|password|secret|credential)\b\s*[:=]\s*["']?[^\s"'`,;]{8,}/i,
+  /\b(?:ghp|gho|ghu|ghs|github_pat)_[A-Za-z0-9_]{20,}\b/,
+  /\bsk-[A-Za-z0-9_-]{20,}\b/,
+  /\bxox[baprs]-[A-Za-z0-9-]{20,}\b/,
+  /\bAIza[0-9A-Za-z_-]{20,}\b/
+];
+function sha256(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function normalizeText(text) {
+  return text.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSubpath(parent, child) {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !rel.includes(`..${sep}`);
+}
+function displayPath(filePath, cwd, home) {
+  const abs = resolve(filePath);
+  const cwdAbs = resolve(cwd);
+  const homeAbs = resolve(home);
+  if (isSubpath(cwdAbs, abs)) {
+    const rel = relative(cwdAbs, abs).split(sep).join("/");
+    return rel.length > 0 ? rel : basename(abs);
+  }
+  if (isSubpath(homeAbs, abs)) {
+    const rel = relative(homeAbs, abs).split(sep).join("/");
+    return rel.length > 0 ? `~/${rel}` : "~";
+  }
+  return abs;
+}
+function unsafePathName(filePath) {
+  const name2 = basename(filePath);
+  return UNSAFE_FILE_NAME_RE.test(name2);
+}
+function safeDirEntryName(name2) {
+  const lower = name2.toLowerCase();
+  if (GENERATED_OR_SECRET_DIRS.has(lower)) return false;
+  if (lower.includes("secret") || lower.includes("credential") || lower.includes("token")) return false;
+  return true;
+}
+function hasSecretLikeLine(text) {
+  for (const line of text.split("\n")) {
+    if (SECRET_LINE_PATTERNS.some((pattern) => pattern.test(line))) return true;
+  }
+  return false;
+}
+function collectFiles(dir, maxDepth, accept, out3 = [], depth = 0) {
+  if (out3.length >= MAX_RECURSIVE_FILES) return out3;
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return out3;
+  }
+  for (const entry of entries) {
+    if (out3.length >= MAX_RECURSIVE_FILES) break;
+    if (entry.isSymbolicLink()) continue;
+    const filePath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (depth >= maxDepth || !safeDirEntryName(entry.name)) continue;
+      collectFiles(filePath, maxDepth, accept, out3, depth + 1);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (unsafePathName(filePath)) continue;
+    if (accept(filePath)) out3.push(filePath);
+  }
+  return out3;
+}
+function markdownLike(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return ext === ".md" || ext === ".mdc";
+}
+function jsonLike(filePath) {
+  return extname(filePath).toLowerCase() === ".json";
+}
+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);
+    if (seen.has(abs)) return;
+    seen.add(abs);
+    const scopedDir = scope === "project" && kind === "instructions" ? relative(cwd, dirname(abs)) : "";
+    specs.push({
+      path: abs,
+      scope,
+      provider,
+      kind,
+      ...scope === "project" && kind === "instructions" ? { directoryScope: scopedDir.length === 0 ? "." : scopedDir.split(sep).join("/") } : {},
+      order
+    });
+    order += 1;
+  };
+  const addProject = (relPath, provider, kind) => {
+    add(join(cwd, relPath), "project", provider, kind);
+  };
+  const addProjectDir = (relPath, provider, kind, maxDepth, accept) => {
+    for (const filePath of collectFiles(join(cwd, relPath), maxDepth, accept)) add(filePath, "project", provider, kind);
+  };
+  addProject("CLAUDE.md", "claude-code", "instructions");
+  addProject(join(".claude", "CLAUDE.md"), "claude-code", "instructions");
+  addProject("AGENTS.md", "codex", "instructions");
+  addProject("CODEX.md", "codex", "instructions");
+  addProject(join(".codex", "AGENTS.md"), "codex", "instructions");
+  addProject("GEMINI.md", "gemini", "instructions");
+  addProject(join(".gemini", "GEMINI.md"), "gemini", "instructions");
+  addProject(join(".github", "copilot-instructions.md"), "copilot", "instructions");
+  const visibleWorkspaceFiles = enumerateWorkspaceFiles(cwd);
+  for (const relPath of visibleWorkspaceFiles) {
+    const parts = relPath.split("/");
+    if (parts.length - 1 > 6) continue;
+    const name2 = parts.at(-1);
+    if (name2 !== "CLAUDE.md" && name2 !== "AGENTS.md" && name2 !== "CODEX.md" && name2 !== "GEMINI.md") continue;
+    const filePath = join(cwd, relPath);
+    const provider = name2 === "CLAUDE.md" ? "claude-code" : name2 === "GEMINI.md" ? "gemini" : "codex";
+    add(filePath, "project", provider, "instructions");
+  }
+  addProject(join(".claude", "settings.json"), "claude-code", "settings");
+  addProjectDir(join(".claude", "commands"), "claude-code", "command", 3, markdownLike);
+  addProjectDir(join(".claude", "agents"), "claude-code", "agent", 2, markdownLike);
+  addProjectDir(join(".claude", "skills"), "claude-code", "skill", 4, markdownLike);
+  addProjectDir(join(".agents", "skills"), "agents", "skill", 4, markdownLike);
+  addProjectDir(join(".codex", "skills"), "codex", "skill", 4, markdownLike);
+  addProjectDir(join(".opencode", "skills"), "opencode", "skill", 4, markdownLike);
+  addProject(join(".gemini", "settings.json"), "gemini", "settings");
+  addProject(join(".gemini", "config.json"), "gemini", "settings");
+  addProjectDir(
+    join(".gemini", "rules"),
+    "gemini",
+    "rule",
+    2,
+    (filePath) => markdownLike(filePath) || jsonLike(filePath)
+  );
+  addProjectDir(
+    join(".gemini", "config"),
+    "gemini",
+    "rule",
+    2,
+    (filePath) => markdownLike(filePath) || jsonLike(filePath)
+  );
+  addProjectDir(join(".cursor", "rules"), "cursor", "rule", 0, markdownLike);
+  addProjectDir(join(".github", "skills"), "copilot", "skill", 4, markdownLike);
+  if (includeGlobal) add(join(home, ".codex", "AGENTS.md"), "global", "codex", "instructions");
+  return specs.filter((spec) => existsSync(spec.path));
+}
+function stripFrontmatter(text) {
+  if (!text.startsWith("---\n")) return text;
+  const end = text.indexOf("\n---", 4);
+  if (end === -1) return text;
+  return text.slice(end + "\n---".length).replace(/^\n+/, "");
+}
+function stripCodeFences(text) {
+  const lines = [];
+  let inFence = false;
+  for (const line of text.split("\n")) {
+    if (/^\s*```/.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence) lines.push(line);
+  }
+  return lines.join("\n");
+}
+function isBarePathOrFileName(text) {
+  const token = /^`([^`]+)`$/.exec(text)?.[1] ?? text;
+  if (/\s/.test(token)) return false;
+  if (!/^[A-Za-z0-9_@.+~/-]+$/.test(token)) return false;
+  return token.includes("/") || extname(token).length > 1;
+}
+function cleanRuleText(raw) {
+  let text = raw.replace(/<!--.*?-->/g, "").replace(/^\[[ xX]\]\s+/, "").replace(/\s+/g, " ").trim();
+  text = text.replace(/^[#>\s]+/, "").trim();
+  if (text.length < 8 || text.length > 260) return null;
+  if (/^(todo|note|example|marker)\b/i.test(text)) return null;
+  if (/\$[A-Z][A-Z0-9_]*|\{\{[^}]+\}\}|<\/?[A-Z][A-Z0-9_-]*>/i.test(text)) return null;
+  if (isBarePathOrFileName(text)) return null;
+  if (!RULE_KEYWORDS.test(text)) return null;
+  if (hasSecretLikeLine(text)) return null;
+  if (text.length > 200) text = `${text.slice(0, 197).trimEnd()}\u2026`;
+  return text;
+}
+function extractMarkdownRules(content) {
+  const text = stripCodeFences(stripFrontmatter(content));
+  const rules = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("|") || /^#{1,6}\s/.test(trimmed)) continue;
+    const bullet = /^(?:[-*+]\s+|\d+\.\s+)(.+?)\s*$/.exec(trimmed)?.[1] ?? null;
+    const candidate = bullet ?? (/^[A-Z][^.!?]{8,220}[.!?]?$/.test(trimmed) ? trimmed : null);
+    if (!candidate) continue;
+    const cleaned = cleanRuleText(candidate);
+    if (!cleaned) continue;
+    const key = normalizeRuleKey(cleaned);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    rules.push(cleaned);
+    if (rules.length >= MAX_RULES_PER_SOURCE) break;
+  }
+  return rules;
+}
+function stringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim());
+}
+function stringField(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function formatShortList(items, limit = 4) {
+  const cleaned = items.map((item) => item.replace(/\s+/g, " ").trim()).filter(Boolean);
+  const shown = cleaned.slice(0, limit).map((item) => `\`${item.length > 48 ? `${item.slice(0, 45)}\u2026` : item}\``);
+  if (cleaned.length > limit) shown.push(`+${cleaned.length - limit} more`);
+  return shown.join(", ");
+}
+function extractSettingsRules(provider, content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return [];
+  }
+  if (!isRecord(parsed)) return [];
+  const rules = [];
+  if (provider === "claude-code") {
+    const permissions = parsed.permissions;
+    if (isRecord(permissions)) {
+      const allow = stringArray(permissions.allow);
+      const deny = stringArray(permissions.deny);
+      const claudePermissionSetting = stringField(permissions, "defaultMode");
+      if (allow.length > 0) rules.push(`Claude Code allows tools: ${formatShortList(allow)}.`);
+      if (deny.length > 0) rules.push(`Claude Code denies tools: ${formatShortList(deny)}.`);
+      if (claudePermissionSetting)
+        rules.push(`Claude Code declares permission setting \`${claudePermissionSetting}\` for this project.`);
+    }
+    if (parsed.enableAllProjectMcpServers === true) rules.push("Claude Code enables all project MCP servers.");
+  }
+  if (provider === "gemini") {
+    const contextFileName = stringField(parsed, "contextFileName");
+    if (contextFileName) rules.push(`Gemini uses \`${contextFileName}\` as an additional context file.`);
+    const mcpServers = parsed.mcpServers;
+    if (isRecord(mcpServers) && Object.keys(mcpServers).length > 0) {
+      rules.push(`Gemini project settings define MCP servers: ${formatShortList(Object.keys(mcpServers))}.`);
+    }
+  }
+  return rules.map((rule) => cleanRuleText(rule)).filter((rule) => Boolean(rule));
+}
+function extractRules(spec, content) {
+  if (spec.kind === "settings" || jsonLike(spec.path)) return extractSettingsRules(spec.provider, content);
+  return extractMarkdownRules(content);
+}
+function normalizeRuleKey(text) {
+  return text.toLowerCase().replace(/`([^`]+)`/g, "$1").replace(/[^a-z0-9.+:#/-]+/g, " ").replace(/\s+/g, " ").trim().replace(/[.!?]+$/, "");
+}
+function classifyConflict(text) {
+  const normalized = text.toLowerCase().replace(/`/g, "");
+  const packageManager2 = /\b(?:always\s+|must\s+|should\s+|prefer\s+|use\s+|run\s+)*(?:use|prefer|run)\s+(pnpm|npm|yarn|bun)\b/.exec(
+    normalized
+  );
+  if (packageManager2?.[1]) return { key: "package-manager", value: packageManager2[1] };
+  const testRunner = /\b(?:always\s+|must\s+|should\s+|prefer\s+|use\s+|run\s+)*(?:use|prefer|run)\s+(node:test|vitest|jest|pytest|cargo test|go test)\b/.exec(
+    normalized
+  );
+  if (testRunner?.[1]) return { key: "test-runner", value: testRunner[1] };
+  return void 0;
+}
+function sourcePriority(source) {
+  const kindPriority = {
+    instructions: 0,
+    rule: 1e3,
+    settings: 2e3,
+    command: 3e3,
+    agent: 4e3,
+    skill: 5e3
+  };
+  const scopeDepth = source.directoryScope ? source.directoryScope.split("/").filter((part) => part !== ".").length : 0;
+  return (source.scope === "project" ? 0 : 1e4) + kindPriority[source.kind] + scopeDepth * 10 + source.order;
+}
+function buildImportPlan(sources) {
+  const candidates = [];
+  for (const source of sources) {
+    const rules = extractRules(
+      { path: source.path, scope: source.scope, provider: source.provider, kind: source.kind, order: 0 },
+      source.content
+    );
+    rules.forEach((text, index) => {
+      const conflict = classifyConflict(text);
+      candidates.push({ text, source, index, ...conflict ? { conflict } : {} });
+    });
+  }
+  candidates.sort((a, b) => {
+    const sourceDelta = sourcePriority(a.source) - sourcePriority(b.source);
+    return sourceDelta !== 0 ? sourceDelta : a.index - b.index;
+  });
+  const accepted = [];
+  const byNormalizedText = /* @__PURE__ */ new Map();
+  const byConflictKey = /* @__PURE__ */ new Map();
+  const conflicts = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const normalized = normalizeRuleKey(candidate.text);
+    const existing = byNormalizedText.get(normalized);
+    if (existing) {
+      if (!existing.sources.includes(candidate.source.displayPath)) existing.sources.push(candidate.source.displayPath);
+      if (!existing.providers.includes(candidate.source.providerLabel))
+        existing.providers.push(candidate.source.providerLabel);
+      if (candidate.source.directoryScope) {
+        existing.directoryScopes ??= [];
+        if (!existing.directoryScopes.includes(candidate.source.directoryScope)) {
+          existing.directoryScopes.push(candidate.source.directoryScope);
+        }
+      }
+      continue;
+    }
+    if (candidate.conflict) {
+      const prior = byConflictKey.get(candidate.conflict.key);
+      if (prior && prior.value !== candidate.conflict.value) {
+        let conflict = conflicts.get(candidate.conflict.key);
+        if (!conflict) {
+          conflict = {
+            key: candidate.conflict.key,
+            kept: prior.rule.text,
+            keptSources: [...prior.rule.sources],
+            skipped: []
+          };
+          conflicts.set(candidate.conflict.key, conflict);
+        }
+        conflict.skipped.push({
+          text: candidate.text,
+          source: candidate.source.displayPath,
+          provider: candidate.source.providerLabel
+        });
+        continue;
+      }
+    }
+    const rule = {
+      text: candidate.text,
+      sources: [candidate.source.displayPath],
+      providers: [candidate.source.providerLabel],
+      ...candidate.source.directoryScope ? { directoryScopes: [candidate.source.directoryScope] } : {},
+      ...candidate.conflict ? { conflictKey: candidate.conflict.key } : {}
+    };
+    accepted.push(rule);
+    byNormalizedText.set(normalized, rule);
+    if (candidate.conflict) byConflictKey.set(candidate.conflict.key, { value: candidate.conflict.value, rule });
+    if (accepted.length >= MAX_IMPORTED_RULES) break;
+  }
+  return { importedRules: accepted, conflicts: [...conflicts.values()] };
+}
+function rejectedCandidate(spec, displayPath2, reason, evidence) {
+  return {
+    path: spec.path,
+    displayPath: displayPath2,
+    scope: spec.scope,
+    provider: spec.provider,
+    kind: spec.kind,
+    ...spec.directoryScope ? { directoryScope: spec.directoryScope } : {},
+    reason,
+    fingerprintSha256: sha256(`rejected\0${reason}\0${evidence}`)
+  };
+}
+function statEvidence(stat) {
+  return `${stat.size}:${Math.floor(stat.mtimeMs)}:${stat.mode}`;
+}
+function readCandidate(spec, cwd, home) {
+  const shown = displayPath(spec.path, cwd, home);
+  if (unsafePathName(spec.path)) {
+    return rejectedCandidate(spec, shown, "unsafe path name", "");
+  }
+  let stat;
+  try {
+    const lst = lstatSync(spec.path);
+    if (lst.isSymbolicLink()) {
+      return rejectedCandidate(spec, shown, "symlink skipped", statEvidence(lst));
+    }
+    stat = statSync(spec.path);
+  } catch {
+    return null;
+  }
+  if (!stat.isFile()) return null;
+  if (stat.size > MAX_SOURCE_BYTES) {
+    return rejectedCandidate(spec, shown, "file too large", statEvidence(stat));
+  }
+  let raw;
+  try {
+    raw = readFileSync(spec.path, "utf8");
+  } catch {
+    return rejectedCandidate(spec, shown, "unreadable", statEvidence(stat));
+  }
+  if (raw.includes("\0")) {
+    return rejectedCandidate(spec, shown, "binary content", raw);
+  }
+  const content = normalizeText(raw);
+  if (hasSecretLikeLine(content)) {
+    return rejectedCandidate(spec, shown, "secret-like content", content);
+  }
+  const rules = extractRules(spec, content);
+  return {
+    path: spec.path,
+    displayPath: shown,
+    scope: spec.scope,
+    provider: spec.provider,
+    providerLabel: PROVIDER_LABELS[spec.provider],
+    kind: spec.kind,
+    kindLabel: KIND_LABELS[spec.kind],
+    ...spec.directoryScope ? { directoryScope: spec.directoryScope } : {},
+    content,
+    contentSha256: sha256(content),
+    byteLength: Buffer.byteLength(content, "utf8"),
+    itemCount: rules.length,
+    order: spec.order
+  };
+}
+function sourceSnapshot(source) {
+  if ("content" in source) {
+    return {
+      path: source.path,
+      scope: source.scope,
+      provider: source.provider,
+      kind: source.kind,
+      ...source.directoryScope ? { directoryScope: source.directoryScope } : {},
+      sha256: source.contentSha256
+    };
+  }
+  return {
+    path: source.path,
+    scope: source.scope,
+    provider: source.provider,
+    kind: source.kind,
+    ...source.directoryScope ? { directoryScope: source.directoryScope } : {},
+    sha256: source.fingerprintSha256,
+    status: "rejected",
+    reason: source.reason
+  };
+}
+function sourceSetHash(snapshots) {
+  const hash = createHash("sha256");
+  for (const snapshot of snapshots) {
+    hash.update(
+      `${snapshot.scope}\0${snapshot.provider}\0${snapshot.kind}\0${snapshot.path}\0${snapshot.directoryScope ?? ""}\0${snapshot.status ?? "accepted"}\0${snapshot.reason ?? ""}\0${snapshot.sha256}
+`
+    );
+  }
+  return hash.digest("hex");
+}
+function adoptionSnapshotsHash(snapshots) {
+  return sourceSetHash([...snapshots].sort((a, b) => a.path.localeCompare(b.path)));
+}
+function scanAgentConfigs(options) {
+  const cwd = resolve(options.cwd);
+  const home = resolve(options.homeDir ?? homedir());
+  const includeGlobal = options.includeGlobal === true;
+  const sources = [];
+  const rejected = [];
+  let acceptedSourceBytes = 0;
+  for (const spec of discoverCandidateSpecs(cwd, home, includeGlobal)) {
+    const result = readCandidate(spec, cwd, home);
+    if (!result) continue;
+    if (!("content" in result)) {
+      rejected.push(result);
+      continue;
+    }
+    if (acceptedSourceBytes + result.byteLength > MAX_TOTAL_SOURCE_BYTES) {
+      rejected.push({
+        path: result.path,
+        displayPath: result.displayPath,
+        scope: result.scope,
+        provider: result.provider,
+        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}`)
+      });
+      continue;
+    }
+    acceptedSourceBytes += result.byteLength;
+    sources.push(result);
+  }
+  sources.sort((a, b) => {
+    const scopeDelta = (a.scope === "project" ? 0 : 1) - (b.scope === "project" ? 0 : 1);
+    return scopeDelta !== 0 ? scopeDelta : a.order - b.order;
+  });
+  const plan = buildImportPlan(sources);
+  const sourceSnapshots = [...sources.map(sourceSnapshot), ...rejected.map(sourceSnapshot)];
+  return {
+    cwd,
+    homeDir: home,
+    includeGlobal,
+    sources,
+    rejected,
+    importedRules: plan.importedRules,
+    conflicts: plan.conflicts,
+    sourceHash: sourceSetHash(sourceSnapshots),
+    sourceSnapshots
+  };
+}
+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`;
+}
+function quoteShort(text) {
+  const cleaned = text.replace(/\s+/g, " ").trim();
+  return `\u201C${cleaned.length > 120 ? `${cleaned.slice(0, 117).trimEnd()}\u2026` : cleaned}\u201D`;
+}
+function renderImportedAgentContext(scan) {
+  if (scan.sources.length === 0 && scan.rejected.length === 0) return "";
+  const lines = [
+    "Conflict policy: CLIO-CODER.md conventions and hard invariants are canonical; project-local imports win over explicit global imports; duplicate rules are merged by normalized text.",
+    "",
+    "### Adopted rules",
+    ""
+  ];
+  if (scan.importedRules.length === 0) {
+    lines.push("- No project-specific rules were adopted from external agent configs.");
+  } else {
+    for (const rule of scan.importedRules) {
+      const scoped = rule.directoryScopes?.filter((scope) => scope !== ".") ?? [];
+      lines.push(
+        `- ${rule.text} Sources: ${renderSourceList(rule.sources)}.${scoped.length > 0 ? ` Scopes: ${renderSourceList(scoped.map((scope) => `${scope}/**`))}.` : ""}`
+      );
+    }
+  }
+  lines.push("", "### Source provenance", "");
+  for (const source of scan.sources) {
+    const adopted = source.itemCount === 1 ? "1 candidate" : `${source.itemCount} candidates`;
+    const scoped = source.directoryScope && source.directoryScope !== "." ? `, scope ${source.directoryScope}/**` : "";
+    lines.push(
+      `- ${source.providerLabel} ${source.kindLabel} (${source.scope}${scoped}): \`${source.displayPath}\`; ${adopted}.`
+    );
+  }
+  if (scan.sources.length === 0) lines.push("- No supported project-local agent config files were found.");
+  if (scan.conflicts.length > 0) {
+    lines.push("", "### Skipped conflicts", "");
+    for (const conflict of scan.conflicts) {
+      for (const skipped of conflict.skipped) {
+        lines.push(
+          `- ${quoteShort(skipped.text)} from \`${skipped.source}\` conflicted with ${renderSourceList(conflict.keptSources)} on ${conflict.key}; kept ${quoteShort(conflict.kept)}.`
+        );
+      }
+    }
+  }
+  if (scan.rejected.length > 0) {
+    lines.push("", "### Rejected sources", "");
+    for (const rejected of scan.rejected.slice(0, 8)) {
+      const provider = rejected.provider ? `${PROVIDER_LABELS[rejected.provider]} ` : "";
+      lines.push(`- ${provider}\`${rejected.displayPath}\`: skipped ${rejected.reason}.`);
+    }
+    if (scan.rejected.length > 8) lines.push(`- ${scan.rejected.length - 8} more rejected sources omitted.`);
+  }
+  return lines.join("\n");
+}
+function inferAdoptionCwd(snapshots, home) {
+  for (const snapshot of snapshots) {
+    if (snapshot.scope !== "project") continue;
+    let candidate = resolve(snapshot.path, "..");
+    for (; ; ) {
+      const match = discoverCandidateSpecs(candidate, home, false).some(
+        (spec) => spec.path === resolve(snapshot.path) && spec.scope === snapshot.scope && spec.provider === snapshot.provider && spec.kind === snapshot.kind
+      );
+      if (match) return candidate;
+      const parent = resolve(candidate, "..");
+      if (parent === candidate) break;
+      candidate = parent;
+    }
+  }
+  return null;
+}
+function inferAdoptionHome(snapshots) {
+  const global = snapshots.find((snapshot) => snapshot.scope === "global");
+  return global ? resolve(global.path, "..", "..") : null;
+}
+function adoptionSourcesChanged(snapshots, options = {}) {
+  const homeDir = resolve(options.homeDir ?? inferAdoptionHome(snapshots) ?? homedir());
+  const cwd = options.cwd ? resolve(options.cwd) : inferAdoptionCwd(snapshots, homeDir);
+  if (!cwd) {
+    for (const snapshot of snapshots) {
+      const current2 = readCandidate(
+        {
+          path: snapshot.path,
+          scope: snapshot.scope,
+          provider: snapshot.provider,
+          kind: snapshot.kind,
+          order: 0
+        },
+        resolve(snapshot.path, ".."),
+        homeDir
+      );
+      if (!current2 || adoptionSnapshotsHash([sourceSnapshot(current2)]) !== adoptionSnapshotsHash([snapshot])) {
+        return true;
+      }
+    }
+    return false;
+  }
+  const current = scanAgentConfigs({
+    cwd,
+    homeDir,
+    includeGlobal: options.includeGlobal ?? snapshots.some((snapshot) => snapshot.scope === "global")
+  }).sourceSnapshots;
+  return adoptionSnapshotsHash(current) !== adoptionSnapshotsHash(snapshots);
+}
+
+// src/domains/context/bootstrap.ts
+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";
+
+// src/domains/context/clio-md.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } 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;
+function normalizeSource(source) {
+  return source.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").trimStart();
+}
+function normalizeInline(value) {
+  return value.replace(/\s+/g, " ").trim().replace(/^#{1,6}\s+/, "").trim();
+}
+function normalizeNestedMarkdown(value) {
+  return normalizeSource(value).trim().replace(/^(#{1,2})(\s+)/gm, "###$2");
+}
+function charLen(value) {
+  return [...value].length;
+}
+function parseFooter(source) {
+  const warnings = [];
+  const markerCount = (source.match(/clio:fingerprint v1/g) ?? []).length;
+  const match = FOOTER_RE.exec(source);
+  if (!match) {
+    if (markerCount > 0) {
+      return {
+        body: source,
+        footer: null,
+        firstInit: false,
+        errors: ["malformed fingerprint footer"],
+        warnings
+      };
+    }
+    return { body: source, footer: null, firstInit: true, errors: [], warnings };
+  }
+  const footerEnd = match.index + match[0].length;
+  const trailing = source.slice(footerEnd).trim();
+  if (trailing.length > 0) warnings.push("trailing content after fingerprint footer ignored");
+  let parsed;
+  try {
+    parsed = JSON.parse(match[1] ?? "");
+  } catch {
+    return {
+      body: source.slice(0, match.index),
+      footer: null,
+      firstInit: false,
+      errors: ["fingerprint footer is not valid JSON"],
+      warnings
+    };
+  }
+  const footer = validateFooter(parsed);
+  if (!footer) {
+    return {
+      body: source.slice(0, match.index),
+      footer: null,
+      firstInit: false,
+      errors: ["fingerprint footer has invalid shape"],
+      warnings
+    };
+  }
+  return {
+    body: source.slice(0, match.index),
+    footer,
+    firstInit: false,
+    errors: [],
+    warnings
+  };
+}
+function validateFooter(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const obj = value;
+  if (typeof obj.initAt !== "string" || obj.initAt.length === 0) return null;
+  if (typeof obj.model !== "string" || obj.model.length === 0) return null;
+  if (!(typeof obj.gitHead === "string" || obj.gitHead === null)) return null;
+  if (typeof obj.treeHash !== "string" || !/^[0-9a-f]{64}$/.test(obj.treeHash)) return null;
+  if (typeof obj.loc !== "number" || !Number.isInteger(obj.loc) || obj.loc < 0) return null;
+  return {
+    initAt: obj.initAt,
+    model: obj.model,
+    gitHead: obj.gitHead,
+    treeHash: obj.treeHash,
+    loc: obj.loc
+  };
+}
+function readSections(body) {
+  const headings = [...body.matchAll(H2_RE)];
+  const sections = [];
+  for (let i = 0; i < headings.length; i += 1) {
+    const heading = headings[i];
+    if (!heading || heading.index === void 0) continue;
+    const next = headings[i + 1];
+    const title = (heading[1] ?? "").trim();
+    const start = heading.index + heading[0].length;
+    const end = next?.index ?? body.length;
+    sections.push({ title, body: body.slice(start, end).trim() });
+  }
+  return sections;
+}
+function sectionBody(sections, title) {
+  return sections.find((section) => section.title.toLowerCase() === title.toLowerCase())?.body ?? "";
+}
+var RESERVED_SECTION_TITLES = /* @__PURE__ */ new Set(["conventions", "hard invariants", "imported agent context"]);
+function extraSections(sections) {
+  return sections.filter((section) => !RESERVED_SECTION_TITLES.has(section.title.toLowerCase()));
+}
+function identityParagraph(afterH1) {
+  const beforeFirstSection = afterH1.split(/^##\s+/m)[0] ?? "";
+  const paragraphs = beforeFirstSection.trim().split(/\n\s*\n/).map((part) => part.replace(/\s+/g, " ").trim()).filter((part) => part.length > 0);
+  return paragraphs[0] ?? "";
+}
+function parseBullets(section) {
+  if (section.trim().length === 0) return [];
+  return section.split("\n").map((line) => /^[-*]\s+(.+?)\s*$/.exec(line)?.[1]?.trim()).filter((line) => Boolean(line));
+}
+function parseNumbered(section) {
+  if (section.trim().length === 0) return [];
+  return section.split("\n").map((line) => /^\d+\.\s+(.+?)\s*$/.exec(line)?.[1]?.trim()).filter((line) => Boolean(line));
+}
+function parseClioMd(source) {
+  const normalized = normalizeSource(source);
+  const warnings = [];
+  const footerResult = parseFooter(normalized);
+  warnings.push(...footerResult.warnings);
+  if (footerResult.errors.length > 0) return { ok: false, errors: footerResult.errors, warnings };
+  const h1Matches = [...footerResult.body.matchAll(H1_RE)];
+  if (h1Matches.length === 0) return { ok: false, errors: ["missing H1 heading"], warnings };
+  if (h1Matches.length > 1) return { ok: false, errors: ["more than one H1 heading"], warnings };
+  const h1 = h1Matches[0];
+  if (!h1 || h1.index === void 0) return { ok: false, errors: ["missing H1 heading"], warnings };
+  const projectName2 = (h1[1] ?? "").trim();
+  const errors = [];
+  if (projectName2.length === 0) errors.push("project name must not be empty");
+  if (charLen(projectName2) > 80) warnings.push("project name is longer than the generator target");
+  const afterH1 = footerResult.body.slice(h1.index + h1[0].length);
+  const identity = identityParagraph(afterH1);
+  if (identity.length === 0) errors.push("identity paragraph is required");
+  if (charLen(identity) > 600) warnings.push("identity paragraph is longer than the generator target");
+  const sections = readSections(afterH1);
+  const conventions = parseBullets(sectionBody(sections, "conventions"));
+  const invariants = parseNumbered(sectionBody(sections, "hard invariants"));
+  const customSections = extraSections(sections);
+  const importedAgentContext = sectionBody(sections, "imported agent context") || null;
+  if (conventions.length > 6) warnings.push("conventions exceed the generator target of six bullets");
+  if (invariants.length > 3) warnings.push("hard invariants exceed the generator target of three numbered rules");
+  if (customSections.length > 8) warnings.push("custom sections exceed the generator target of eight H2 sections");
+  for (const [index, item] of conventions.entries()) {
+    if (charLen(item) > 200) warnings.push(`convention ${index + 1} is longer than the generator target`);
+  }
+  for (const [index, item] of invariants.entries()) {
+    if (charLen(item) > 280) warnings.push(`hard invariant ${index + 1} is longer than the generator target`);
+  }
+  for (const [index, section] of customSections.entries()) {
+    if (charLen(section.title) > 80)
+      warnings.push(`custom section ${index + 1} title is longer than the generator target`);
+    if (charLen(section.body) > 2500)
+      warnings.push(`custom section ${index + 1} body is longer than the generator target`);
+  }
+  if (errors.length > 0) return { ok: false, errors, warnings };
+  return {
+    ok: true,
+    value: {
+      projectName: projectName2,
+      identity,
+      conventions,
+      invariants,
+      sections: customSections,
+      importedAgentContext,
+      fingerprint: footerResult.footer,
+      firstInit: footerResult.firstInit,
+      warnings
+    }
+  };
+}
+function validateForSerialization(input) {
+  const test = parseClioMd(renderWithoutParse(input));
+  if (!test.ok) {
+    throw new Error(`CLIO-CODER.md serialization failed validation: ${test.errors.join("; ")}`);
+  }
+}
+function renderWithoutParse(input) {
+  const lines = [`# ${normalizeInline(input.projectName)}`, "", normalizeInline(input.identity)];
+  const conventions = input.conventions.map((item) => normalizeInline(item)).filter((item) => item.length > 0);
+  if (conventions.length > 0) {
+    lines.push("", "## Conventions", "", ...conventions.map((item) => `- ${item}`));
+  }
+  const invariants = input.invariants.map((item) => normalizeInline(item)).filter((item) => item.length > 0);
+  if (invariants.length > 0) {
+    lines.push("", "## Hard invariants", "", ...invariants.map((item, index) => `${index + 1}. ${item}`));
+  }
+  for (const section of input.sections ?? []) {
+    const title = normalizeInline(section.title);
+    const body = normalizeNestedMarkdown(section.body);
+    if (title.length > 0 && body.length > 0) lines.push("", `## ${title}`, "", body);
+  }
+  const imported = input.importedAgentContext ? normalizeNestedMarkdown(input.importedAgentContext) : void 0;
+  if (imported && imported.length > 0) {
+    lines.push("", "## Imported agent context", "", imported);
+  }
+  if (!input.fingerprint) return `${lines.join("\n")}
+`;
+  const footer = JSON.stringify(input.fingerprint, null, 2);
+  return `${lines.join("\n")}
+
+<!-- clio:fingerprint v1
+${footer}
+-->
+`;
+}
+function serializeClioMd(input) {
+  validateForSerialization(input);
+  return renderWithoutParse(input);
+}
+function renderProjectTypeFragment(projectType) {
+  return `<project-type>${projectType}</project-type>`;
+}
+function renderProjectContextFragment(parsed) {
+  const sections = [`# ${parsed.projectName}`, parsed.identity];
+  if (parsed.conventions.length > 0) {
+    sections.push("## Conventions", ...parsed.conventions.map((item) => `- ${item}`));
+  }
+  if (parsed.invariants.length > 0) {
+    sections.push("## Hard invariants", ...parsed.invariants.map((item, index) => `${index + 1}. ${item}`));
+  }
+  for (const section of parsed.sections) {
+    sections.push(`## ${section.title}`, section.body);
+  }
+  if (parsed.importedAgentContext) {
+    sections.push("## Imported agent context", parsed.importedAgentContext);
+  }
+  return `<project-context>
+${sections.join("\n\n")}
+</project-context>`;
+}
+function tryReadClioMd(cwd) {
+  const filePath = join2(cwd, "CLIO-CODER.md");
+  if (!existsSync2(filePath)) return null;
+  let content;
+  try {
+    content = readFileSync2(filePath, "utf8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+  const parsed = parseClioMd(content);
+  if (!parsed.ok) return { ok: false, error: parsed.errors.join("; ") };
+  return { ok: true, value: parsed.value };
+}
+
+// src/domains/context/project-metadata.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+import { parse as parseYaml } from "yaml";
+var MAX_DESCRIPTION_CHARS = 400;
+var MAX_NAME_CHARS = 80;
+function readText(cwd, relative6) {
+  try {
+    return readFileSync3(join3(cwd, relative6), "utf8");
+  } catch {
+    return null;
+  }
+}
+function clean(value, max) {
+  if (typeof value !== "string") return null;
+  const collapsed = value.replace(/\s+/gu, " ").trim();
+  if (collapsed.length === 0) return null;
+  return collapsed.length > max ? `${collapsed.slice(0, max - 1).trimEnd()}\u2026` : collapsed;
+}
+function name(value) {
+  return clean(value, MAX_NAME_CHARS);
+}
+function description(value) {
+  const cleaned = clean(value, MAX_DESCRIPTION_CHARS);
+  return cleaned === null ? null : clean(cleaned.replace(/\.$/u, ""), MAX_DESCRIPTION_CHARS) ?? null;
+}
+function jsonRecord(cwd, relative6) {
+  const raw = readText(cwd, relative6);
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function tomlTableValue(raw, table, key) {
+  const lines = raw.split(/\r?\n/u);
+  let inTable = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[")) {
+      inTable = trimmed === `[${table}]`;
+      continue;
+    }
+    if (!inTable) continue;
+    const match = /^([A-Za-z0-9_-]+)\s*=\s*(.*)$/u.exec(trimmed);
+    if (!match || match[1] !== key) continue;
+    const value = (match[2] ?? "").trim();
+    const quoted = /^"((?:[^"\\]|\\.)*)"$/u.exec(value) ?? /^'([^']*)'$/u.exec(value);
+    if (!quoted) return null;
+    return (quoted[1] ?? "").replace(/\\"/gu, '"');
+  }
+  return null;
+}
+function keyEqualsValue(raw, key) {
+  const match = new RegExp(`^[ \\t]*${key}[ \\t]*(?:\\+?=)[ \\t]*(.+)$`, "mu").exec(raw);
+  const value = match?.[1]?.trim();
+  if (!value) return null;
+  return value.replace(/^"(.*)"$/su, "$1").trim();
+}
+function iniSectionValue(raw, section, key) {
+  const lines = raw.split(/\r?\n/u);
+  let inSection = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      inSection = trimmed === `[${section}]`;
+      continue;
+    }
+    if (!inSection) continue;
+    const match = /^([A-Za-z0-9_.-]+)\s*=\s*(.*)$/u.exec(trimmed);
+    if (!match || match[1] !== key) continue;
+    const value = (match[2] ?? "").trim();
+    return value.length > 0 ? value : null;
+  }
+  return null;
+}
+function xmlTagValue(raw, tag) {
+  const match = new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`, "u").exec(raw);
+  return match?.[1] ?? null;
+}
+function yamlRecord(cwd, relative6) {
+  const raw = readText(cwd, relative6);
+  if (raw === null) return null;
+  try {
+    const parsed = parseYaml(raw);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var packageJson = (cwd) => {
+  const record = jsonRecord(cwd, "package.json");
+  if (!record) return null;
+  return { file: "package.json", fragment: { name: name(record.name), description: description(record.description) } };
+};
+var pyprojectToml = (cwd) => {
+  const raw = readText(cwd, "pyproject.toml");
+  if (raw === null) return null;
+  const projectName2 = tomlTableValue(raw, "project", "name") ?? tomlTableValue(raw, "tool.poetry", "name");
+  const projectDescription = tomlTableValue(raw, "project", "description") ?? tomlTableValue(raw, "tool.poetry", "description");
+  return {
+    file: "pyproject.toml",
+    fragment: { name: name(projectName2), description: description(projectDescription) }
+  };
+};
+var cargoToml = (cwd) => {
+  const raw = readText(cwd, "Cargo.toml");
+  if (raw === null) return null;
+  return {
+    file: "Cargo.toml",
+    fragment: {
+      name: name(tomlTableValue(raw, "package", "name")),
+      description: description(tomlTableValue(raw, "package", "description"))
+    }
+  };
+};
+var setupCfg = (cwd) => {
+  const raw = readText(cwd, "setup.cfg");
+  if (raw === null) return null;
+  return {
+    file: "setup.cfg",
+    fragment: {
+      name: name(iniSectionValue(raw, "metadata", "name")),
+      description: description(iniSectionValue(raw, "metadata", "description"))
+    }
+  };
+};
+var composerJson = (cwd) => {
+  const record = jsonRecord(cwd, "composer.json");
+  if (!record) return null;
+  return {
+    file: "composer.json",
+    fragment: { name: name(record.name), description: description(record.description) }
+  };
+};
+var pomXml = (cwd) => {
+  const raw = readText(cwd, "pom.xml");
+  if (raw === null) return null;
+  return {
+    file: "pom.xml",
+    fragment: {
+      name: name(xmlTagValue(raw, "name") ?? xmlTagValue(raw, "artifactId")),
+      description: description(xmlTagValue(raw, "description"))
+    }
+  };
+};
+var cmakeLists = (cwd) => {
+  const raw = readText(cwd, "CMakeLists.txt");
+  if (raw === null) return null;
+  const call = /^[ \t]*project[ \t]*\(([\s\S]*?)\)/imu.exec(raw)?.[1];
+  if (!call) return { file: "CMakeLists.txt", fragment: {} };
+  const projectName2 = /^\s*([A-Za-z0-9_.+-]+)/u.exec(call)?.[1];
+  const projectDescription = /\bDESCRIPTION\s+"((?:[^"\\]|\\.)*)"/u.exec(call)?.[1];
+  return {
+    file: "CMakeLists.txt",
+    fragment: { name: name(projectName2), description: description(projectDescription) }
+  };
+};
+var doxyfile = (cwd) => {
+  for (const relative6 of ["Doxyfile", "Doxyfile.in", "docs/Doxyfile", "doc/Doxyfile"]) {
+    const raw = readText(cwd, relative6);
+    if (raw === null) continue;
+    return {
+      file: relative6,
+      fragment: {
+        name: name(keyEqualsValue(raw, "PROJECT_NAME")),
+        description: description(keyEqualsValue(raw, "PROJECT_BRIEF"))
+      }
+    };
+  }
+  return null;
+};
+var rDescription = (cwd) => {
+  const raw = readText(cwd, "DESCRIPTION");
+  if (raw === null || !/^Package:\s*\S/mu.test(raw)) return null;
+  const field = (key) => {
+    const match = new RegExp(`^${key}:[ \\t]*([\\s\\S]*?)(?=\\n\\S|$)`, "mu").exec(raw);
+    return match?.[1] ?? null;
+  };
+  return {
+    file: "DESCRIPTION",
+    fragment: {
+      name: name(field("Package")),
+      description: description(field("Title") ?? field("Description"))
+    }
+  };
+};
+var gemspec = (cwd) => {
+  let entries;
+  try {
+    entries = readdirSync2(cwd).filter((entry) => entry.endsWith(".gemspec"));
+  } catch {
+    return null;
+  }
+  entries.sort();
+  const relative6 = entries[0];
+  if (!relative6) return null;
+  const raw = readText(cwd, relative6);
+  if (raw === null) return null;
+  const field = (key) => new RegExp(`\\.${key}\\s*=\\s*["']([^"']+)["']`, "u").exec(raw)?.[1] ?? null;
+  return {
+    file: relative6,
+    fragment: { name: name(field("name")), description: description(field("summary") ?? field("description")) }
+  };
+};
+var citationCff = (cwd) => {
+  const record = yamlRecord(cwd, "CITATION.cff");
+  if (!record) return null;
+  return { file: "CITATION.cff", fragment: { name: name(record.title), description: description(record.abstract) } };
+};
+var codemetaJson = (cwd) => {
+  const record = jsonRecord(cwd, "codemeta.json");
+  if (!record) return null;
+  return { file: "codemeta.json", fragment: { name: name(record.name), description: description(record.description) } };
+};
+var zenodoJson = (cwd) => {
+  const record = jsonRecord(cwd, ".zenodo.json");
+  if (!record) return null;
+  return { file: ".zenodo.json", fragment: { name: name(record.title), description: description(record.description) } };
+};
+var METADATA_READERS = [
+  packageJson,
+  pyprojectToml,
+  cargoToml,
+  setupCfg,
+  composerJson,
+  pomXml,
+  cmakeLists,
+  doxyfile,
+  rDescription,
+  gemspec,
+  citationCff,
+  codemetaJson,
+  zenodoJson
+];
+var README_CANDIDATES = [
+  "README.md",
+  "README.rst",
+  "README.adoc",
+  "README.asciidoc",
+  "README.org",
+  "README.txt",
+  "README.markdown",
+  "README",
+  "readme.md",
+  "readme.rst",
+  "readme.txt",
+  "docs/README.md",
+  "docs/index.rst",
+  "doc/README.md"
+];
+function findReadme(cwd) {
+  for (const candidate of README_CANDIDATES) {
+    if (!existsSync3(join3(cwd, candidate))) continue;
+    const content = readText(cwd, candidate);
+    if (content !== null && content.trim().length > 0) return { path: candidate, content };
+  }
+  return null;
+}
+function stripReadmeMarkup(raw) {
+  return raw.replace(/<!--[\s\S]*?-->/gu, "").replace(/<picture\b[\s\S]*?<\/picture>/giu, "").replace(/^\s*<h[1-6]\b[^>]*>[\s\S]*?<\/h[1-6]>\s*$/gimu, "").replace(/\[!\[[^\]]*\]\([^)]*\)\]\([^)]*\)/gu, "").replace(/!\[[^\]]*\]\([^)]*\)/gu, "").replace(/\[([^\]]+)\]\([^)]*\)/gu, "$1").replace(/<img\b[^>]*>/giu, "").replace(/<[^>]+>/gu, "").replace(/^\s*\.\.\s+\S+::.*(?:\n(?:[ \t]+.*)?)*/gmu, "").replace(/^\s*\.\.\s+_?\|?[^\n]*\|?:.*$/gmu, "").replace(/\|[A-Za-z0-9_-]+\|/gu, "").replace(/:[a-z]+:`([^`]*)`/gu, "$1").replace(/^\s*:[A-Za-z0-9_-]+:.*$/gmu, "").replace(/^\s*image:{1,2}[^\n]*$/gmu, "").replace(/[*_~`]/gu, "");
+}
+function isStructuralLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return true;
+  if (/^#{1,6}\s+/u.test(trimmed)) return true;
+  if (/^={1,6}\s+/u.test(trimmed)) return true;
+  if (/^[=\-~^"'#*+_]{3,}$/u.test(trimmed)) return true;
+  if (/^[-|:\s]+$/u.test(trimmed)) return true;
+  return false;
+}
+function isCalloutParagraph(lines) {
+  const content = lines.filter((line) => line.trim().length > 0);
+  if (content.length === 0) return false;
+  return content.every((line) => /^\s*>/u.test(line));
+}
+function readmeSummary(content) {
+  const paragraphs = stripReadmeMarkup(content).split(/\n\s*\n/u).map((part) => part.split(/\r?\n/u)).filter((lines) => !isCalloutParagraph(lines)).map(
+    (lines) => lines.filter((line) => !isStructuralLine(line)).join(" ").trim()
+  ).filter(
+    (part) => part.length >= 20 && /[A-Za-z]{3}/u.test(part) && !part.startsWith("```") && !/^table of contents$/iu.test(part)
+  );
+  const first = paragraphs[0];
+  if (!first) return null;
+  return description(first);
+}
+function readmeTitle(content) {
+  const lines = stripReadmeMarkup(content).split(/\r?\n/u);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = (lines[index] ?? "").trim();
+    if (line.length === 0) continue;
+    const hash = /^#{1,3}\s+(.+?)\s*$/u.exec(line)?.[1] ?? /^={1,3}\s+(.+?)\s*$/u.exec(line)?.[1];
+    if (hash) return name(hash);
+    const next = (lines[index + 1] ?? "").trim();
+    if (/^[=\-~^]{3,}$/u.test(next) && !isStructuralLine(line)) return name(line);
+    return null;
+  }
+  return null;
+}
+function readProjectMetadata(cwd) {
+  const out3 = { name: null, description: null, nameSource: null, descriptionSource: null };
+  for (const reader of METADATA_READERS) {
+    if (out3.name !== null && out3.description !== null) break;
+    let read;
+    try {
+      read = reader(cwd);
+    } catch {
+      continue;
+    }
+    if (!read) continue;
+    if (out3.name === null && read.fragment.name) {
+      out3.name = read.fragment.name;
+      out3.nameSource = read.file;
+    }
+    if (out3.description === null && read.fragment.description) {
+      out3.description = read.fragment.description;
+      out3.descriptionSource = read.file;
+    }
+  }
+  if (out3.name !== null && out3.description !== null) return out3;
+  const readme = findReadme(cwd);
+  if (!readme) return out3;
+  if (out3.name === null) {
+    const title = readmeTitle(readme.content);
+    if (title) {
+      out3.name = title;
+      out3.nameSource = readme.path;
+    }
+  }
+  if (out3.description === null) {
+    const summary = readmeSummary(readme.content);
+    if (summary) {
+      out3.description = summary;
+      out3.descriptionSource = readme.path;
+    }
+  }
+  return out3;
+}
+
+// src/domains/context/prompt-context.ts
+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));
+  }
+  if (clio && !clio.ok) warnings.push(`clio: malformed CLIO-CODER.md ignored: ${clio.error}`);
+  const codewiki = readCodewiki(cwd);
+  if (codewiki) {
+    const state = readClioState(cwd);
+    const stale = state ? isStale(state.fingerprint, computeFingerprintCached(cwd, codewiki)) : true;
+    const suffix = stale ? " (stale; run /context refresh)" : "";
+    pieces.push(`<codewiki>available${suffix}; use code_nav</codewiki>`);
+  }
+  const staleness = wikiStaleness(cwd);
+  if (staleness.state !== "absent") {
+    const pages = listWikiPages(cwd);
+    const completeness = wikiCompleteness(cwd);
+    const notes = [];
+    if (completeness && completeness.owed > 0) {
+      notes.push(
+        `incomplete: ${completeness.pagesWritten} of ${completeness.pagesPlanned} planned pages written, ${completeness.owed} owed`
+      );
+    }
+    if (staleness.state === "stale") notes.push("stale");
+    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 };
+}
+
+// src/domains/context/bootstrap.ts
+function out(io, message) {
+  io?.stdout(message);
+}
+function warn(io, message) {
+  io?.stderr(message);
+}
+function progress(input, event) {
+  input.onProgress?.(event);
+}
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync4(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function stringField2(value, key) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const field = value[key];
+  return typeof field === "string" && field.trim().length > 0 ? field.trim() : null;
+}
+function titleFromPackageName(raw) {
+  const base = raw.includes("/") ? raw.split("/").pop() ?? raw : raw;
+  return base.split(/[-_]+/).filter(Boolean).map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`).join(" ");
+}
+function projectNameFrom(metadata, cwd) {
+  const declared = metadata.name;
+  if (declared) {
+    return metadata.nameSource === "package.json" ? titleFromPackageName(declared) : declared.slice(0, 80);
+  }
+  return titleFromPackageName(parse(cwd).base || "Project");
+}
+function projectName(cwd) {
+  return projectNameFrom(readProjectMetadata(cwd), cwd);
+}
+function projectTypeLabel(projectType) {
+  switch (projectType) {
+    case "typescript":
+      return "TypeScript/Node.js";
+    case "javascript":
+      return "JavaScript/Node.js";
+    case "python":
+      return "Python";
+    case "rust":
+      return "Rust";
+    case "go":
+      return "Go";
+    case "c":
+      return "C";
+    case "c++":
+      return "C++";
+    case "java":
+      return "Java";
+    case "ruby":
+      return "Ruby";
+    case "c#":
+      return "C#";
+    case "polyglot":
+      return "polyglot";
+    case "dotfiles":
+      return "dotfiles";
+    case "unknown":
+      return "software";
+  }
+}
+function allContextText(files) {
+  return files.map((file) => file.content).join("\n\n");
+}
+function resolveDefaultIdentity(cwd, projectType, files) {
+  const metadata = readProjectMetadata(cwd);
+  const name2 = projectNameFrom(metadata, cwd);
+  const context = allContextText(files);
+  if (/Clio owns the agent loop/i.test(context) && /pi-(?:ai|SDK)/i.test(context)) {
+    return {
+      text: [
+        "Clio Coder is IOWarp's orchestrator coding agent, named for the Greek muse of history and developed by the Gnosis Research Center at Illinois Tech under PI @akougkas. CLIO stands for Context Layer for Input/Output.",
+        "pi-ai is accessed through the engine boundary.",
+        "Clio owns the agent loop, TUI, session format, tool registry, and identity."
+      ].join(" "),
+      bare: false,
+      descriptionSource: null
+    };
+  }
+  const stack = projectTypeLabel(projectType);
+  const head = `${name2} is a ${stack} project.`;
+  const description2 = metadata.description;
+  if (!description2) return { text: head.slice(0, 600), bare: true, descriptionSource: null };
+  const cleaned = description2.replace(/\.$/, "").trim();
+  const role = /^[a-z]/.test(cleaned) ? `It is ${cleaned}.` : `${cleaned}.`;
+  return { text: `${head} ${role}`.slice(0, 600), bare: false, descriptionSource: metadata.descriptionSource };
+}
+function stabilizedIdentity(input, modelIdentity) {
+  const deterministic = resolveDefaultIdentity(input.cwd, input.projectType, input.siblingFiles);
+  const model = typeof modelIdentity === "string" ? modelIdentity.trim() : "";
+  if (deterministic.bare && model.length > 0) return model;
+  return deterministic.text;
+}
+function pushUnique(target, value) {
+  if (target.includes(value)) return;
+  target.push(value);
+}
+var SKIP_BULLET_PATTERNS = [/^marker\s*[:=]/i, /marker[-_:]\s*\w+-\w+/i, /^todo\b/i, /^note\b/i, /^example\b/i];
+function harvestSiblingBullets(files) {
+  const out3 = [];
+  for (const file of files) {
+    for (const rawLine of file.content.split("\n")) {
+      const match = /^[\s>]*[-*]\s+(.+?)\s*$/.exec(rawLine);
+      if (!match) continue;
+      const bullet = match[1]?.trim();
+      if (!bullet || bullet.length < 5) continue;
+      if (bullet.length > 200) continue;
+      if (SKIP_BULLET_PATTERNS.some((re) => re.test(bullet))) continue;
+      if (!RULE_KEYWORDS.test(bullet)) continue;
+      out3.push(bullet);
+    }
+  }
+  return out3;
+}
+function inferConventions(cwd, projectType, files) {
+  const conventions = [];
+  const context = allContextText(files);
+  const pkg = readJsonFile(join4(cwd, "package.json"));
+  const packageText = typeof pkg === "object" && pkg !== null ? JSON.stringify(pkg) : "";
+  if (/Local imports end in `?\.js`?/i.test(context) || projectType === "typescript" && existsSync4(join4(cwd, "tsconfig.json"))) {
+    pushUnique(conventions, "Local imports end in `.js`. Tests use `node:test`. Avoid `any` without a tracking issue.");
+  } else if (/node:test/i.test(context) || /node --import tsx --test|node --test/.test(packageText)) {
+    pushUnique(conventions, "Tests use `node:test`.");
+  }
+  if (/No em-dash|em-dash/i.test(context)) {
+    pushUnique(
+      conventions,
+      "No em-dash clause separators in code, comments, commits, or responses. Write full sentences."
+    );
+  }
+  if (/Commit subjects|conventional commit|Imperative, lowercase|lowercase-typed subjects/i.test(context)) {
+    pushUnique(
+      conventions,
+      "Commit subjects are imperative, lowercase, conventional, at most 72 characters, and end without a period."
+    );
+  }
+  for (const bullet of harvestSiblingBullets(files)) pushUnique(conventions, bullet);
+  return conventions.slice(0, 6);
+}
+function inferInvariants(files) {
+  const context = allContextText(files);
+  const invariants = [];
+  if (/Engine boundary/i.test(context)) {
+    pushUnique(invariants, "Engine boundary. Only `src/engine/**` may value-import `@earendil-works/pi-*`.");
+  }
+  if (/Worker isolation/i.test(context)) {
+    pushUnique(
+      invariants,
+      "Worker isolation. `src/worker/**` never imports `src/domains/**` except `src/domains/providers`."
+    );
+  }
+  if (/Domain independence/i.test(context)) {
+    pushUnique(
+      invariants,
+      "Domain independence. `src/domains/<x>/**` never imports `src/domains/<y>/extension.ts` for `y != x`."
+    );
+  }
+  return invariants.slice(0, 3);
+}
+function indexedSourceFileCount(codewiki) {
+  return codewiki.files.filter((file) => file.lang !== "config").length;
+}
+function measureProjectPreload(cwd) {
+  const promptContext = renderPromptContext(cwd);
+  return classifyProjectPreload({ hasClioMd: promptContext.clioMd !== null, text: promptContext.text });
+}
+function packageScripts(cwd) {
+  const pkg = readJsonFile(join4(cwd, "package.json"));
+  if (typeof pkg !== "object" || pkg === null || Array.isArray(pkg)) return {};
+  const scripts = pkg.scripts;
+  if (typeof scripts !== "object" || scripts === null || Array.isArray(scripts)) return {};
+  const out3 = {};
+  for (const [name2, command] of Object.entries(scripts)) {
+    if (typeof command === "string" && command.trim().length > 0) out3[name2] = command.trim();
+  }
+  return out3;
+}
+function packageManager(cwd) {
+  const declared = stringField2(readJsonFile(join4(cwd, "package.json")), "packageManager")?.split("@")[0];
+  if (declared === "pnpm" || declared === "yarn" || declared === "bun" || declared === "npm") return declared;
+  if (existsSync4(join4(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync4(join4(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync4(join4(cwd, "bun.lock")) || existsSync4(join4(cwd, "bun.lockb"))) return "bun";
+  return "npm";
+}
+var MUTATING_SCRIPT_RE = /(?:^|\s)--(?:fix|write)(?:\s|$)/;
+function verificationSection(cwd) {
+  const scripts = packageScripts(cwd);
+  const pm = packageManager(cwd);
+  const hasScript = (name2) => typeof scripts[name2] === "string";
+  const command = (name2) => `\`${pm} run ${name2}\``;
+  const gate = (name2) => {
+    if (hasScript(`${name2}:check`)) return `${name2}:check`;
+    return hasScript(name2) && !MUTATING_SCRIPT_RE.test(scripts[name2] ?? "") ? name2 : null;
+  };
+  const lines = [];
+  const baseline = ["typecheck", "lint", "format"].map(gate).filter((name2) => name2 !== null).map(command);
+  if (baseline.length > 0) {
+    lines.push(`Before handoff, run ${baseline.join(", ")}.`);
+  }
+  if (hasScript("build")) {
+    lines.push(`Run ${command("build")} after CLI, worker, packaging, or generated-dist changes.`);
+  }
+  const targeted = ["test:contracts", "test:smoke", "check:boundaries"].filter(hasScript).map(command);
+  if (targeted.length > 0) {
+    lines.push(`Use targeted checks for narrower risk: ${targeted.join(", ")}.`);
+  }
+  if (hasScript("test")) {
+    lines.push(`Run ${command("test")} when behavior crosses domains, tool contracts, smoke flows, or boundaries.`);
+  }
+  if (hasScript("ci")) {
+    lines.push(`Use ${command("ci")} for the full local gate before committing broad or shared behavior changes.`);
+  }
+  if (lines.length === 0) return null;
+  return { title: "Verification expectations", body: lines.join(" ") };
+}
+var VERIFICATION_SECTION_RE = /\bverification\b/i;
+function createModelGroundingCorpus(input) {
+  let siblingBudget = 64e3;
+  const siblingEvidence = [];
+  for (const file of input.siblingFiles) {
+    if (siblingBudget <= 0) break;
+    const chunk = file.content.slice(0, siblingBudget);
+    siblingEvidence.push(chunk);
+    siblingBudget -= chunk.length;
+  }
+  const indexedPaths = new Set(input.codewiki.files.map((file) => file.path));
+  const pm = packageManager(input.cwd);
+  const scripts = packageScripts(input.cwd);
+  const evidence = [
+    ...siblingEvidence,
+    (input.existingClioMdText ?? "").slice(0, 8e3),
+    input.expectedProjectName ?? "",
+    input.projectType,
+    [...indexedPaths].join("\n").slice(0, 64e3),
+    ...Object.entries(scripts).flatMap(([name2, command]) => [`${pm} run ${name2}`, `${pm} ${name2}`, command]),
+    input.codewiki.symbols.map((symbol) => symbol.name).join("\n").slice(0, 128e3)
+  ].join("\n");
+  return { lower: evidence.toLowerCase(), indexedPaths };
+}
+var CODE_TOKEN_RE = /`([^`\n]+)`/g;
+function groundedToken(token, evidence) {
+  return evidence.lower.includes(token.toLowerCase()) || evidence.indexedPaths.has(token.replace(/^\.\//, ""));
+}
+function groundedModelBody(body, evidence) {
+  const kept = [];
+  let inFence = false;
+  for (const rawLine of body.split(/\r?\n/)) {
+    const trimmed = rawLine.trim();
+    if (trimmed.startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (trimmed.length === 0 || /^#{1,6}\s|^---+$/.test(trimmed)) continue;
+    const line = inFence ? `\`${trimmed.replace(/`/g, "")}\`` : trimmed;
+    const codeTokens = [...line.matchAll(CODE_TOKEN_RE)].map((match) => match[1]?.trim()).filter((token) => token !== void 0 && token.length > 0);
+    if (codeTokens.length === 0) continue;
+    if (!codeTokens.every((token) => groundedToken(token, evidence))) continue;
+    if (line.replace(CODE_TOKEN_RE, "").trim().length === 0 && !inFence) continue;
+    kept.push(line);
+  }
+  const bounded = [];
+  let length = 0;
+  for (const line of kept) {
+    const nextLength = length + (bounded.length > 0 ? 1 : 0) + line.length;
+    if (nextLength > 1200) break;
+    bounded.push(line);
+    length = nextLength;
+  }
+  return bounded.join("\n").trim();
+}
+function sanitizeModelSection(section, evidence) {
+  const body = groundedModelBody(section.body, evidence);
+  if (body.length < 40) return null;
+  const title = section.title.replace(/\s+/g, " ").trim();
+  return title.length > 0 ? { title, body } : null;
+}
+function stabilizeGeneratedOutput(input, base, onModelSectionRetained, groundModelOutput = false) {
+  const existing = input.existingClioMd;
+  const conventions = [];
+  for (const convention of existing?.conventions ?? []) pushUnique(conventions, convention);
+  for (const convention of inferConventions(input.cwd, input.projectType, input.siblingFiles)) {
+    pushUnique(conventions, convention);
+  }
+  const invariants = [];
+  for (const invariant of existing?.invariants ?? []) pushUnique(invariants, invariant);
+  for (const invariant of inferInvariants(input.siblingFiles)) pushUnique(invariants, invariant);
+  const verification = verificationSection(input.cwd);
+  const inferredSections = inferHeuristicSections(input);
+  const existingSections = existing?.sections ?? [];
+  const ordinarySections = [];
+  const modelSections = /* @__PURE__ */ new Set();
+  const seenSectionTitles = /* @__PURE__ */ new Set();
+  const addSection = (section) => {
+    if (VERIFICATION_SECTION_RE.test(section.title)) return false;
+    const titleKey = section.title.replace(/\s+/g, " ").trim().toLowerCase();
+    if (seenSectionTitles.has(titleKey)) return false;
+    seenSectionTitles.add(titleKey);
+    ordinarySections.push(section);
+    return true;
+  };
+  for (const section of existing ? [...existingSections, ...inferredSections] : inferredSections) addSection(section);
+  const groundingCorpus = groundModelOutput ? createModelGroundingCorpus(input) : null;
+  for (const section of base.sections ?? []) {
+    const sanitized = groundingCorpus ? sanitizeModelSection(section, groundingCorpus) : section;
+    if (sanitized && addSection(sanitized)) modelSections.add(sanitized);
+  }
+  const ordinaryLimit = verification ? 6 : 7;
+  const retainedOrdinarySections = ordinarySections.slice(0, ordinaryLimit);
+  for (const section of retainedOrdinarySections) {
+    if (modelSections.has(section)) onModelSectionRetained?.();
+  }
+  return {
+    ...base,
+    projectName: existing?.projectName ?? projectName(input.cwd),
+    identity: existing?.identity ?? stabilizedIdentity(input, base.identity),
+    conventions: conventions.slice(0, 6),
+    invariants: invariants.slice(0, 3),
+    sections: [...retainedOrdinarySections, ...verification ? [verification] : []]
+  };
+}
+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(" ")
+    });
+  }
+  return sections;
+}
+function inferHeuristicSections(input) {
+  const sections = [...codewikiSections(input.codewiki)];
+  const invariants = inferInvariants(input.siblingFiles);
+  if (invariants.length > 0) {
+    sections.push({
+      title: "Architecture boundaries",
+      body: invariants.map((item) => `- ${item}`).join("\n")
+    });
+  }
+  if (input.adoption.sources.length > 0) {
+    const sourceNames = input.adoption.sources.map((source) => `\`${source.displayPath}\``).slice(0, 8).join(", ");
+    sections.push({
+      title: "Agent context interop",
+      body: [
+        `Bootstrap scanned ${input.adoption.sources.length} sibling context source${input.adoption.sources.length === 1 ? "" : "s"}: ${sourceNames}${input.adoption.sources.length > 8 ? ", ..." : ""}.`,
+        "Run `clio-coder context init --adopt` to refresh the managed provenance section when those sources change."
+      ].join(" ")
+    });
+  }
+  return sections.slice(0, 6);
+}
+function heuristicBootstrapOutputSync(input) {
+  return stabilizeGeneratedOutput(input, {
+    projectName: projectName(input.cwd),
+    identity: resolveDefaultIdentity(input.cwd, input.projectType, input.siblingFiles).text,
+    conventions: inferConventions(input.cwd, input.projectType, input.siblingFiles),
+    invariants: inferInvariants(input.siblingFiles),
+    sections: inferHeuristicSections(input)
+  });
+}
+var heuristicBootstrapOutput = heuristicBootstrapOutputSync;
+function bootstrapOutputFromParsed(parsed) {
+  const out3 = {
+    projectName: parsed.projectName,
+    identity: parsed.identity,
+    conventions: [...parsed.conventions],
+    invariants: [...parsed.invariants]
+  };
+  if (parsed.sections.length > 0) {
+    out3.sections = parsed.sections.map((section) => ({ title: section.title, body: section.body }));
+  }
+  if (parsed.importedAgentContext) out3.importedAgentContext = parsed.importedAgentContext;
+  return out3;
+}
+function existingClioMdBootstrapOutput(cwd) {
+  const parsed = tryReadClioMd(cwd);
+  if (!parsed?.ok) return null;
+  return bootstrapOutputFromParsed(parsed.value);
+}
+function fallbackBootstrapOutput(input) {
+  const existing = input.existingClioMd ? bootstrapOutputFromParsed(input.existingClioMd) : existingClioMdBootstrapOutput(input.cwd);
+  if (existing) return { mode: "existing", output: existing };
+  return { mode: "heuristic", output: heuristicBootstrapOutputSync(input) };
+}
+function readExistingClioMdText(cwd) {
+  try {
+    return readFileSync4(join4(cwd, "CLIO-CODER.md"), "utf8");
+  } catch {
+    return null;
+  }
+}
+function replaceImportedAgentContext(output, importedAgentContext) {
+  const { importedAgentContext: _old, ...rest } = output;
+  if (importedAgentContext.length === 0) return rest;
+  return { ...rest, importedAgentContext };
+}
+function loadBootstrapSiblingFiles(adoption) {
+  return adoption.sources.map((source) => ({
+    source: source.scope,
+    path: source.path,
+    content: source.content
+  }));
+}
+function gitStatus(cwd) {
+  try {
+    return execFileSync("git", ["status", "--short"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return "";
+  }
+}
+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));
+  if (names.length === 0) return "";
+  if (names.length <= 3) return names.join(", ");
+  return `${names.slice(0, 3).join(", ")} +${names.length - 3}`;
+}
+function formatAdoptionLine(summary) {
+  const adoption = summary.adoption;
+  const shouldRender = summary.action === "previewed" || adoption.mode === "adopt" || adoption.globalSourceCount > 0 || adoption.conflictCount > 0 || adoption.rejectedCount > 0;
+  if (!shouldRender) return null;
+  const global = adoption.includeGlobal ? `${adoption.globalSourceCount} global` : "global off";
+  const verb = adoption.mode === "adopt" ? "imported" : "scanned";
+  return `  adoption ${verb} ${adoption.sourceCount} source${adoption.sourceCount === 1 ? "" : "s"} (${adoption.projectSourceCount} project, ${global}); ${adoption.importedRuleCount} candidate rule${adoption.importedRuleCount === 1 ? "" : "s"}; ${adoption.conflictCount} conflict${adoption.conflictCount === 1 ? "" : "s"}; ${adoption.rejectedCount} rejected`;
+}
+function formatBootstrapSummary(summary) {
+  const contextLine = summary.contextFileCount > 0 ? `folded ${summary.contextFileCount} context file${summary.contextFileCount === 1 ? "" : "s"} (${basenameList(summary.contextFileNames)})` : "no sibling context files found";
+  const dirtyLine = summary.dirtyFiles === 0 ? "workspace clean" : `workspace has ${summary.dirtyFiles} dirty file${summary.dirtyFiles === 1 ? "" : "s"}`;
+  if (summary.action === "previewed") {
+    const adoptionLine2 = formatAdoptionLine(summary);
+    return [
+      "clio-coder context init preview",
+      `  ${contextLine}; codewiki would index ${summary.codewikiEntries} entr${summary.codewikiEntries === 1 ? "y" : "ies"}; ${dirtyLine}; no files written`,
+      ...adoptionLine2 ? [adoptionLine2] : [],
+      ""
+    ].join("\n");
+  }
+  const adoptionLine = formatAdoptionLine(summary);
+  const proposalLine = summary.proposalPath ? `  proposal written ${summary.proposalPath}` : null;
+  if (summary.action === "preserved") {
+    return [
+      "clio-coder context init preserved CLIO-CODER.md",
+      `  ${contextLine}; codewiki rebuilt ${summary.codewikiEntries} entr${summary.codewikiEntries === 1 ? "y" : "ies"}; state refreshed; ${dirtyLine}`,
+      "  CLIO-CODER.md is treated as human-owned. Use --apply to replace it with a generated draft, --propose to write an ignored proposal, or --adopt to refresh only imported agent context.",
+      ...adoptionLine ? [adoptionLine] : [],
+      ""
+    ].join("\n");
+  }
+  if (summary.action === "proposed") {
+    return [
+      "clio-coder context init proposed CLIO-CODER.md",
+      `  ${contextLine}; codewiki rebuilt ${summary.codewikiEntries} entr${summary.codewikiEntries === 1 ? "y" : "ies"}; state refreshed; ${dirtyLine}`,
+      ...proposalLine ? [proposalLine] : [],
+      "  CLIO-CODER.md was not changed. Re-run with --apply only after reviewing the proposal.",
+      ...adoptionLine ? [adoptionLine] : [],
+      ""
+    ].join("\n");
+  }
+  return [
+    `clio-coder context init ${summary.action} CLIO-CODER.md`,
+    `  ${contextLine}; codewiki rebuilt ${summary.codewikiEntries} entr${summary.codewikiEntries === 1 ? "y" : "ies"}; state refreshed; ${dirtyLine}`,
+    "  git policy: .clio-coder/ stays ignored by default; CLIO-CODER.md stays versioned and human-owned. Force-add .clio-coder assets only when you explicitly intend to share them.",
+    ...proposalLine ? [proposalLine] : [],
+    ...adoptionLine ? [adoptionLine] : [],
+    ""
+  ].join("\n");
+}
+var CLIO_GITIGNORE_LINE = ".clio-coder/";
+var CLIO_GITIGNORE_DYNAMIC_LINES = /* @__PURE__ */ new Set([
+  ".clio-coder/codewiki.json",
+  ".clio-coder/state.json",
+  ".clio-coder/handoffs/"
+]);
+function normalizedGitignoreLines(content) {
+  return content.split(/\r?\n/).map((line) => line.trim());
+}
+function hasBlanketClioIgnore(content) {
+  return normalizedGitignoreLines(content).some(isBlanketClioIgnoreLine);
+}
+function isBlanketClioIgnoreLine(line) {
+  if (line.length === 0 || line.startsWith("#") || line.startsWith("!")) return false;
+  return /^(?:\/|\*\*\/)?\.clio-coder(?:\/|\/\*|\/\*\*)?$/.test(line);
+}
+function hasDynamicOnlyClioIgnore(content) {
+  const lines = new Set(normalizedGitignoreLines(content));
+  for (const line of CLIO_GITIGNORE_DYNAMIC_LINES) {
+    if (!lines.has(line)) return false;
+  }
+  return true;
+}
+function migrateClioGitignore(content) {
+  const lines = content.split(/\r?\n/);
+  const kept = lines.filter((line) => {
+    const trimmed = line.trim();
+    return !isBlanketClioIgnoreLine(trimmed) && !CLIO_GITIGNORE_DYNAMIC_LINES.has(trimmed);
+  });
+  while (kept.length > 0 && kept[kept.length - 1]?.trim() === "") kept.pop();
+  const prefix = kept.length > 0 ? [...kept, ""] : [];
+  return `${[...prefix, CLIO_GITIGNORE_LINE].join("\n")}
+`;
+}
+async function ensureGitignore(cwd, input) {
+  const gitignorePath = join4(cwd, ".gitignore");
+  let content = "";
+  try {
+    content = readFileSync4(gitignorePath, "utf8");
+  } catch {
+    content = "";
+  }
+  if (hasBlanketClioIgnore(content)) {
+    if (hasDynamicOnlyClioIgnore(content)) writeFileSync(gitignorePath, migrateClioGitignore(content), "utf8");
+    return;
+  }
+  if (hasDynamicOnlyClioIgnore(content)) {
+    writeFileSync(gitignorePath, migrateClioGitignore(content), "utf8");
+    return;
+  }
+  const confirmed = input.confirmGitignore ? await input.confirmGitignore() : false;
+  if (!confirmed) {
+    warn(
+      input.io,
+      `clio-coder context init: .gitignore does not ignore .clio-coder/; local context, skills, agents, and handoffs may leak into commits.
+  rerun with --yes to append '${CLIO_GITIGNORE_LINE}' to .gitignore without prompting, or add that line yourself.
+`
+    );
+    return;
+  }
+  writeFileSync(gitignorePath, migrateClioGitignore(content), "utf8");
+}
+function serializeBootstrapOutput(output) {
+  return serializeClioMd({ ...output, fingerprint: null });
+}
+function writeClioMdFile(cwd, output) {
+  const clioMdPath = join4(cwd, "CLIO-CODER.md");
+  mkdirSync(dirname2(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("; ")}`);
+  writeFileSync(clioMdPath, serialized, "utf8");
+  return clioMdPath;
+}
+function timestampForPath(now) {
+  return now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function writeClioMdProposal(cwd, now, output) {
+  const dir = join4(cwd, ".clio-coder", "proposals");
+  mkdirSync(dir, { recursive: true });
+  const proposalPath = join4(dir, `CLIO-CODER-${timestampForPath(now)}.md`);
+  writeFileSync(proposalPath, serializeBootstrapOutput(output), "utf8");
+  return proposalPath;
+}
+function boundedStateString(value, maxChars) {
+  if (value === void 0) return void 0;
+  const bounded = value.replace(/\s+/g, " ").trim().slice(0, maxChars);
+  return bounded.length > 0 ? bounded : void 0;
+}
+function safeStateCounter(value) {
+  return value !== void 0 && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function durableGenerationTelemetry(telemetry) {
+  const state = {
+    mode: telemetry.mode,
+    parserOutcome: telemetry.parserOutcome
+  };
+  const fallbackReason = boundedStateString(telemetry.fallbackReason, 500);
+  if (fallbackReason) state.fallbackReason = fallbackReason;
+  const run = telemetry.run;
+  if (!run) return state;
+  state.structuredOutputMode = run.structuredOutputMode;
+  for (const [key, value] of [
+    ["runId", run.runId],
+    ["targetId", run.targetId],
+    ["wireModelId", run.wireModelId],
+    ["runtimeId", run.runtimeId],
+    ["runtimeKind", run.runtimeKind],
+    ["thinkingLevel", run.thinkingLevel]
+  ]) {
+    const bounded = boundedStateString(value, 512);
+    if (bounded) state[key] = bounded;
+  }
+  for (const [key, value] of [
+    ["tokenCount", run.tokens?.total],
+    ["toolCalls", run.toolCalls],
+    ["durationMs", run.durationMs],
+    ["promptBytes", run.promptBytes],
+    ["outputBytes", run.outputBytes]
+  ]) {
+    const counter = safeStateCounter(value);
+    if (counter !== void 0) state[key] = counter;
+  }
+  return state;
+}
+function writeProjectState(cwd, projectType, now, indexedAt, adoption, recordAdoption, codewikiVersion, generation, generated) {
+  const finalFingerprint = computeFingerprint(cwd);
+  const statePath2 = statePath(cwd);
+  const prev = readClioState(cwd);
+  const lastBootstrap = generated ? durableGenerationTelemetry(generation) : prev?.lastBootstrap ?? durableGenerationTelemetry(generation);
+  const contextSources = recordAdoption ? adoption.sourceSnapshots : prev?.contextSources;
+  const contextSourceHash = contextSources ? adoptionSnapshotsHash(contextSources) : void 0;
+  writeClioState(cwd, {
+    version: 1,
+    projectType,
+    fingerprint: finalFingerprint,
+    codewikiVersion,
+    lastInitAt: now.toISOString(),
+    lastSessionAt: now.toISOString(),
+    lastIndexedAt: indexedAt,
+    lastBootstrap,
+    ...contextSources ? { contextSources } : {},
+    ...contextSourceHash ? { contextSourceHash } : {}
+  });
+  return statePath2;
+}
+function persistCodewikiForGeneration(cwd, projectType, indexedAt, codewiki) {
+  writeCodewiki(cwd, codewiki);
+  const prev = readClioState(cwd);
+  writeClioState(cwd, {
+    version: 1,
+    projectType,
+    fingerprint: computeFingerprint(cwd, codewiki),
+    codewikiVersion: codewiki.version,
+    ...prev?.contextSources ? { contextSources: prev.contextSources } : {},
+    ...prev?.contextSourceHash ? { contextSourceHash: prev.contextSourceHash } : {},
+    ...prev?.lastInitAt ? { lastInitAt: prev.lastInitAt } : {},
+    ...prev?.lastBootstrap ? { lastBootstrap: prev.lastBootstrap } : {},
+    lastSessionAt: prev?.lastSessionAt ?? indexedAt,
+    lastIndexedAt: indexedAt
+  });
+}
+function summarizeAdoption(adoption, mode) {
+  let projectSourceCount = 0;
+  let globalSourceCount = 0;
+  for (const source of adoption.sources) {
+    if (source.scope === "global") globalSourceCount += 1;
+    else projectSourceCount += 1;
+  }
+  return {
+    mode,
+    sourceCount: adoption.sources.length,
+    projectSourceCount,
+    globalSourceCount,
+    importedRuleCount: adoption.importedRules.length,
+    conflictCount: adoption.conflicts.length,
+    rejectedCount: adoption.rejected.length,
+    includeGlobal: adoption.includeGlobal
+  };
+}
+function codewikiEntryPoints(codewiki, limit = 6) {
+  const fileById = new Map(codewiki.files.map((file) => [file.id, file]));
+  const tagged = codewiki.files.filter((file) => file.lang !== "config" && file.role === "entry").map((file) => file.path).sort((a, b) => a.localeCompare(b));
+  if (tagged.length >= limit) return tagged.slice(0, limit);
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const edge of codewiki.edges) {
+    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));
+  return [...tagged, ...ranked].slice(0, limit);
+}
+async function runBootstrap(input = {}) {
+  const cwd = input.cwd ?? process.cwd();
+  const projectType = detectProjectType(cwd);
+  progress(input, {
+    phase: "scan",
+    status: "started",
+    message: "scanning project and sibling agent context",
+    detail: projectType
+  });
+  const adoption = scanAgentConfigs({
+    cwd,
+    ...input.homeDir ? { homeDir: input.homeDir } : {},
+    includeGlobal: input.includeGlobalImports === true
+  });
+  const siblingFiles = loadBootstrapSiblingFiles(adoption);
+  progress(input, {
+    phase: "scan",
+    status: "completed",
+    message: siblingFiles.length === 0 ? "no sibling context files found" : `folded ${siblingFiles.length} sibling context file${siblingFiles.length === 1 ? "" : "s"}`,
+    current: siblingFiles.length,
+    total: siblingFiles.length
+  });
+  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 });
+  const codewikiEntryCount = indexedSourceFileCount(codewiki);
+  progress(input, {
+    phase: "codewiki",
+    status: "completed",
+    message: `indexed ${codewikiEntryCount} source file${codewikiEntryCount === 1 ? "" : "s"}`,
+    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;
+  const existingClioMd = useExistingClioMdAsSource ? tryReadClioMd(cwd) : null;
+  const existingParsed = existingClioMd?.ok ? existingClioMd.value : void 0;
+  const replaceClioMd = input.applyClioMd === true || input.rewriteClioMd === true;
+  if (input.adopt === true && input.preview !== true && hadClioMd && !existingParsed && !replaceClioMd && input.proposeClioMd !== true) {
+    const detail = existingClioMd && !existingClioMd.ok ? ` (${existingClioMd.error})` : "";
+    throw new Error(
+      `cannot refresh Imported agent context because CLIO-CODER.md is malformed${detail}; use --apply or --rewrite after reviewing the handbook`
+    );
+  }
+  const shouldGenerate = !hadClioMd || replaceClioMd || input.proposeClioMd === true || input.generate !== void 0;
+  let output;
+  let generation = {
+    mode: shouldGenerate ? "heuristic" : existingParsed ? "existing" : "heuristic",
+    parserOutcome: "not-run"
+  };
+  let reportedGeneration;
+  const reportGeneration = (reported) => {
+    if (reportedGeneration === void 0) reportedGeneration = reported;
+  };
+  if (shouldGenerate) {
+    progress(input, {
+      phase: "generate",
+      status: "started",
+      message: input.generate ? "drafting CLIO-CODER.md with the bootstrap agent" : "drafting CLIO-CODER.md with heuristic"
+    });
+    output = await (input.generate ?? heuristicBootstrapOutput)({
+      cwd,
+      expectedProjectName: projectName(cwd),
+      projectType,
+      siblingFiles,
+      adoption,
+      codewiki,
+      ...existingParsed ? { existingClioMd: existingParsed } : {},
+      ...existingClioMdText ? { existingClioMdText } : {},
+      ...input.onProgress ? { progress: input.onProgress } : {},
+      reportGeneration
+    });
+    generation = reportedGeneration ?? generation;
+    let retainedModelSections = 0;
+    output = stabilizeGeneratedOutput(
+      {
+        cwd,
+        expectedProjectName: projectName(cwd),
+        projectType,
+        siblingFiles,
+        adoption,
+        codewiki,
+        ...existingParsed ? { existingClioMd: existingParsed } : {},
+        ...existingClioMdText ? { existingClioMdText } : {}
+      },
+      output,
+      () => {
+        retainedModelSections += 1;
+      },
+      generation.mode === "model"
+    );
+    if (generation.mode === "model" && retainedModelSections === 0) {
+      generation = {
+        ...generation,
+        mode: "heuristic",
+        fallbackReason: "Scout draft contributed no evidence-grounded custom sections"
+      };
+    }
+    progress(input, {
+      phase: "generate",
+      status: "completed",
+      message: `${output.projectName}: ${output.sections?.length ?? 0} custom section${(output.sections?.length ?? 0) === 1 ? "" : "s"}`,
+      detail: `${generation.mode}; parser=${generation.parserOutcome}`
+    });
+  } else {
+    output = existingParsed ? bootstrapOutputFromParsed(existingParsed) : await heuristicBootstrapOutput({ cwd, projectType, siblingFiles, adoption, codewiki });
+    progress(input, {
+      phase: "generate",
+      status: "completed",
+      message: hadClioMd ? "preserving existing CLIO-CODER.md; no generated rewrite requested" : "using heuristic CLIO-CODER.md draft"
+    });
+  }
+  if (input.adopt === true) {
+    output = replaceImportedAgentContext(output, renderImportedAgentContext(adoption));
+  }
+  const readNames = siblingFiles.map((file) => file.path).sort((a, b) => a.localeCompare(b));
+  const previewStatus = gitStatus(cwd);
+  if (input.preview === true) {
+    progress(input, { phase: "clio-md", status: "completed", message: "preview ready; no files written" });
+    const summary2 = {
+      action: "previewed",
+      contextFileCount: readNames.length,
+      contextFileNames: readNames,
+      codewikiEntries: codewikiEntryCount,
+      dirtyFiles: countStatusLines(previewStatus),
+      adoption: summarizeAdoption(adoption, "preview")
+    };
+    out(input.io, formatBootstrapSummary(summary2));
+    return {
+      clioMdPath: join4(cwd, "CLIO-CODER.md"),
+      statePath: statePath(cwd),
+      siblingFiles,
+      output,
+      projectType,
+      summary: summary2,
+      adoption,
+      telemetry: { generation },
+      preload: measureProjectPreload(cwd)
+    };
+  }
+  let clioMdPath = join4(cwd, "CLIO-CODER.md");
+  let proposalPath;
+  let action = "preserved";
+  progress(input, {
+    phase: "clio-md",
+    status: "started",
+    message: hadClioMd ? "preserving CLIO-CODER.md" : "writing CLIO-CODER.md"
+  });
+  if (!hadClioMd) {
+    clioMdPath = writeClioMdFile(cwd, output);
+    action = "wrote";
+  } else if (replaceClioMd) {
+    clioMdPath = writeClioMdFile(cwd, output);
+    action = "refreshed";
+  } else if (input.adopt === true && existingParsed) {
+    clioMdPath = writeClioMdFile(cwd, output);
+    action = "refreshed";
+  } else if (input.proposeClioMd === true) {
+    proposalPath = writeClioMdProposal(cwd, now, output);
+    action = "proposed";
+  }
+  progress(input, {
+    phase: "clio-md",
+    status: "completed",
+    message: action === "wrote" ? "CLIO-CODER.md written" : action === "refreshed" ? "CLIO-CODER.md refreshed" : action === "proposed" ? "CLIO-CODER.md proposal written" : "CLIO-CODER.md preserved",
+    detail: proposalPath ?? clioMdPath
+  });
+  const adoptionApplied = input.adopt === true && (action === "wrote" || action === "refreshed");
+  progress(input, { phase: "state", status: "started", message: "persisting codewiki and project state" });
+  const statePath2 = writeProjectState(
+    cwd,
+    projectType,
+    now,
+    indexedAt,
+    adoption,
+    adoptionApplied,
+    codewiki.version,
+    generation,
+    shouldGenerate
+  );
+  progress(input, {
+    phase: "state",
+    status: "completed",
+    message: `state updated; ${codewikiEntryCount} codewiki entr${codewikiEntryCount === 1 ? "y" : "ies"}`
+  });
+  const postStatus = gitStatus(cwd);
+  const summary = {
+    action,
+    contextFileCount: readNames.length,
+    contextFileNames: readNames,
+    codewikiEntries: codewikiEntryCount,
+    dirtyFiles: countStatusLines(postStatus),
+    adoption: summarizeAdoption(adoption, adoptionApplied ? "adopt" : "scan"),
+    ...proposalPath ? { proposalPath } : {}
+  };
+  out(input.io, formatBootstrapSummary(summary));
+  const preload = measureProjectPreload(cwd);
+  out(input.io, `  preload: ${preload.label}
+`);
+  if (preload.mode === "full" && preload.nearLimit) {
+    warn(
+      input.io,
+      `  warning: project context is within 10% of the preload limit (${preload.chars} chars of 8000, ${preload.lines} lines of 220); the next growth may flip it to a synopsis
+`
+    );
+  }
+  progress(input, {
+    phase: "done",
+    status: "completed",
+    message: `${summary.action} CLIO-CODER.md; ${summary.dirtyFiles} dirty file${summary.dirtyFiles === 1 ? "" : "s"}; preload: ${preload.label}`
+  });
+  return {
+    clioMdPath,
+    statePath: statePath2,
+    siblingFiles,
+    output,
+    projectType,
+    summary,
+    adoption,
+    telemetry: { generation },
+    preload
+  };
+}
+
+// src/domains/context/clear.ts
+import { existsSync as existsSync5, rmSync } from "node:fs";
+import { join as join5 } from "node:path";
+var ACCUMULATED_CONTEXT_PATHS = [
+  ".clio-coder/codewiki.json",
+  ".clio-coder/state.json",
+  ".clio-coder/handoffs",
+  ".clio-coder/proposals"
+];
+var PRESERVED_CONTEXT_PATHS = [
+  "CLIO-CODER.md",
+  ".clio-coder/agents",
+  ".clio-coder/skills",
+  ".clio-coder/wiki"
+];
+function out2(io, message) {
+  io?.stdout(message);
+}
+function relativeContextPath(cwd, relPath) {
+  return join5(cwd, ...relPath.split("/"));
+}
+function removeIfPresent(cwd, relPath, removed) {
+  const absPath = relativeContextPath(cwd, relPath);
+  if (!existsSync5(absPath)) return;
+  rmSync(absPath, { recursive: true, force: true });
+  removed.push(relPath);
+}
+async function runContextClear(input = {}) {
+  const cwd = input.cwd ?? process.cwd();
+  const confirmed = await input.confirmContext?.();
+  if (confirmed !== true) {
+    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);
+    }
+  }
+  out2(
+    input.io,
+    [
+      `clio-coder context reset removed ${removed.length === 0 ? "nothing" : removed.join(", ")}`,
+      `  preserved ${preserved.join(", ")}`,
+      ""
+    ].join("\n")
+  );
+  return { action: "cleared", removed, preserved };
+}
+
+// src/domains/context/refresh.ts
+import { writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join8 } from "node:path";
+
+// src/domains/context/wiki/generate.ts
+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
+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");
+}
+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 = 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 };
+  }
+  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 = [`# ${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}`);
+  }
+  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 |",
+      "| --- | --- | --- | --- | --- | --- |"
+    );
+    for (const page of routable) {
+      lines.push(
+        `| ${escapeCell(page.metadata.title)} | [${escapeCell(page.metadata.title)}](${page.path}) | ${codeList(page.metadata.sources, 3)} | ${codeList(page.metadata.symbols, 3)} | ${codeList(page.metadata.tests, 2)} | ${codeList(page.metadata.validate, 1)} |`
+      );
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function renderIndex(dir, pages, sections) {
+  const title = dir === "." ? "Wiki" : dir.split("/").join(" / ");
+  const lines = [`# ${title}`, ""];
+  if (pages.length > 0) {
+    for (const page of pages) {
+      const summary = page.metadata.summary.length > 0 ? ` \u2014 ${page.metadata.summary}` : "";
+      lines.push(`- [${page.metadata.title}](${linkTo(dir, page.path)})${summary}`);
+    }
+    lines.push("");
+  }
+  if (sections.length > 0) {
+    lines.push("## Sections", "");
+    for (const section of sections)
+      lines.push(`- [${posix.basename(section)}/](${linkTo(dir, `${section}/${WIKI_INDEX}`)})`);
+    lines.push("");
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function assembleWikiTree(input) {
+  const { dir, sourceRoot } = input;
+  const authored = wikiMarkdownFilesInDir(dir).filter((relPath) => !isGeneratedWikiFile(relPath));
+  const knownPages = /* @__PURE__ */ new Set([...authored, WIKI_QUICKSTART]);
+  const assembled = [];
+  const issues = [];
+  const dropped = [];
+  let repaired = 0;
+  for (const relPath of authored) {
+    const result = repairPage(dir, sourceRoot, relPath, knownPages);
+    if (result.empty) {
+      rmSync2(join6(dir, relPath), { force: true });
+      dropped.push(relPath);
+      continue;
+    }
+    if (result.changed) repaired += 1;
+    issues.push(...result.issues);
+    assembled.push({ path: relPath, metadata: result.metadata });
+  }
+  writeText(join6(dir, WIKI_QUICKSTART), renderQuickstart(sourceRoot, input.plan, assembled));
+  const directories = /* @__PURE__ */ new Set(["."]);
+  for (const page of assembled) {
+    let section = posix.dirname(page.path);
+    while (section !== "." && section.length > 0) {
+      directories.add(section);
+      section = posix.dirname(section);
+    }
+  }
+  for (const directory of directories) {
+    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));
+  }
+  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 });
+  }
+  return { pages: listWikiPagesInDir(dir), repaired, dropped, issues };
+}
+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 });
+    index.set(relPath, [...metadata.sources, ...metadata.tests]);
+  }
+  return index;
+}
+function normalizeRepoPath(sourceRoot, candidate) {
+  const resolved = normalize(join6(sourceRoot, candidate));
+  const rel = relative2(sourceRoot, resolved);
+  return rel.split("\\").join("/");
+}
+
+// src/domains/context/wiki/plan.ts
+var WIKI_DEPTH_STRATEGY = {
+  simple: { areaDepth: 1, areaShare: 0.08, minAreaLines: 400 },
+  medium: { areaDepth: 2, areaShare: 0.03, minAreaLines: 250 },
+  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);
+  if (directories.length === 0) return ".";
+  return directories.slice(0, Math.max(1, maxDepth)).join("/");
+}
+function classifyDepth(sourceFiles, sourceLines) {
+  if (sourceFiles <= 150 && sourceLines <= 3e4) return "simple";
+  if (sourceFiles <= 800 && sourceLines <= 15e4) return "medium";
+  return "detailed";
+}
+function slugSegment(segment) {
+  const slug = segment.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.length > 0 ? slug : "section";
+}
+function areaSegments(area) {
+  const parts = area.split("/").filter((part) => part.length > 0 && part !== ".");
+  if (parts.length === 0) return ["root"];
+  if (parts[0] !== "src") return parts;
+  return parts.length === 1 ? ["source"] : parts.slice(1);
+}
+function pagePathForArea(area) {
+  return `${areaSegments(area).map(slugSegment).join("/")}.md`;
+}
+function titleForArea(area) {
+  const name2 = areaSegments(area).join(" ").replace(/[-_]+/g, " ").trim();
+  return name2.length > 0 ? name2.charAt(0).toUpperCase() + name2.slice(1) : "Overview";
+}
+function rankedSources(files) {
+  return [...files].sort((a, b) => {
+    const roleRank = (file) => file.role === "entry" ? 0 : file.role === "test" ? 2 : 1;
+    return roleRank(a) - roleRank(b) || b.loc - a.loc || a.path.localeCompare(b.path);
+  }).slice(0, MAX_PAGE_SOURCES).map((file) => file.path);
+}
+function collectAreas(source, areaDepth) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const file of source) {
+    const key = areaForPath(file.path, areaDepth);
+    const area = byKey.get(key) ?? { key, files: [], lines: 0 };
+    area.files.push(file);
+    area.lines += Math.max(0, file.loc);
+    byKey.set(key, area);
+  }
+  return [...byKey.values()].sort((a, b) => b.lines - a.lines || a.key.localeCompare(b.key));
+}
+function overviewPage(source) {
+  const entries = source.filter((file) => file.role === "entry");
+  return {
+    path: "architecture.md",
+    title: "Architecture",
+    intent: "Explain what this repository is, its top-level composition, how a request or command flows through it, and where the boundaries between its major areas are.",
+    sources: rankedSources(entries.length > 0 ? entries : source),
+    status: "pending",
+    attempts: 0
+  };
+}
+function buildCandidatePlan(codewiki, depth) {
+  const source = codewiki.files.filter((file) => file.lang !== "config");
+  const totalLines = source.reduce((total, file) => total + Math.max(0, file.loc), 0);
+  const { areaDepth, areaShare, minAreaLines } = WIKI_DEPTH_STRATEGY[depth];
+  const threshold = Math.max(minAreaLines, Math.floor(totalLines * areaShare));
+  const areas = collectAreas(source, areaDepth);
+  const included = areas.filter((area) => area.lines >= threshold);
+  const selected = included.length > 0 ? included : areas.slice(0, 1);
+  const selectedKeys = new Set(selected.map((area) => area.key));
+  const extras = /* @__PURE__ */ new Map();
+  for (const area of areas) {
+    if (selectedKeys.has(area.key)) continue;
+    const ancestor = selected.find((candidate) => area.key.startsWith(`${candidate.key}/`));
+    const host = ancestor?.key ?? selected[0]?.key;
+    if (host === void 0) continue;
+    extras.set(host, [...extras.get(host) ?? [], ...area.files]);
+  }
+  const pages = selected.map((area) => {
+    const files = [...area.files, ...extras.get(area.key) ?? []];
+    return {
+      path: pagePathForArea(area.key),
+      title: titleForArea(area.key),
+      intent: `Document ${area.key} (${area.files.length} indexed files, ${area.lines} lines): what it owns, its entry points and important symbols, the state and lifecycle invariants it enforces, an upstream caller and a downstream dependency, the focused tests that prove its behavior, and what to watch when editing it.`,
+      sources: rankedSources(files),
+      status: "pending",
+      attempts: 0
+    };
+  });
+  return dedupePagePaths({
+    version: 1,
+    overview: "",
+    pages: [overviewPage(source), ...pages]
+  });
+}
+function dedupePagePaths(plan) {
+  const seen = /* @__PURE__ */ new Set();
+  const pages = [];
+  for (const page of plan.pages) {
+    let path = page.path;
+    let suffix = 2;
+    while (seen.has(path)) {
+      path = page.path.replace(/\.md$/, `-${suffix}.md`);
+      suffix += 1;
+    }
+    seen.add(path);
+    pages.push({ ...page, path });
+  }
+  return { ...plan, pages };
+}
+function planWikiGeneration(codewiki, requestedDepth = "auto") {
+  const source = codewiki.files.filter((file) => file.lang !== "config");
+  const sourceFiles = source.length;
+  const sourceLines = source.reduce((total, file) => total + Math.max(0, file.loc), 0);
+  const depth = requestedDepth === "auto" ? classifyDepth(sourceFiles, sourceLines) : requestedDepth;
+  return { requestedDepth, depth, sourceFiles, sourceLines, plan: buildCandidatePlan(codewiki, depth) };
+}
+
+// src/domains/context/wiki/generate.ts
+function progress2(input, event) {
+  input.onProgress?.(event);
+}
+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;
+}
+function failed(problems, pages) {
+  return { status: "failed", pages, problems };
+}
+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");
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function readLockPid(lockPath) {
+  try {
+    const parsed = Number.parseInt(readFileSync6(lockPath, "utf8").trim(), 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function acquireWikiLock(cwd) {
+  const dir = clioDir(cwd);
+  mkdirSync3(dir, { recursive: true });
+  const lockPath = join7(dir, WIKI_LOCK_FILE);
+  const release = () => {
+    try {
+      rmSync3(lockPath, { force: true });
+    } catch {
+    }
+  };
+  const create = () => {
+    const fd = openSync(lockPath, "wx");
+    try {
+      writeSync(fd, String(process.pid));
+    } finally {
+      closeSync(fd);
+    }
+  };
+  try {
+    create();
+    return { ok: true, release };
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+  const holder = readLockPid(lockPath);
+  if (holder !== null && isProcessAlive(holder)) {
+    return {
+      ok: false,
+      problem: `wiki generation is already running (lock held by pid ${holder} at ${lockPath})`
+    };
+  }
+  try {
+    rmSync3(lockPath, { force: true });
+    create();
+    return { ok: true, release };
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+    const racer = readLockPid(lockPath);
+    return {
+      ok: false,
+      problem: `wiki generation is already running (lock held by pid ${racer ?? "unknown"} at ${lockPath})`
+    };
+  }
+}
+function removeDir(dir) {
+  try {
+    rmSync3(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function seedStaging(cwd, stagingDir) {
+  const source = wikiDir(cwd);
+  for (const relPath of wikiMarkdownFilesInDir(source)) {
+    const target = join7(stagingDir, relPath);
+    mkdirSync3(dirname4(target), { recursive: true });
+    try {
+      copyFileSync(join7(source, relPath), target);
+    } catch {
+    }
+  }
+}
+function adoptOrCreateStaging(cwd) {
+  const dir = clioDir(cwd);
+  mkdirSync3(dir, { recursive: true });
+  let entries;
+  try {
+    entries = readdirSync3(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;
+    return bt - at;
+  });
+  const resumable = candidates.find((candidate) => existsSync6(join7(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));
+  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);
+  removeDir(prev);
+  const hadWiki = existsSync6(wiki);
+  if (hadWiki) renameSync(wiki, prev);
+  try {
+    renameSync(stagingDir, wiki);
+    writeMeta();
+  } catch (err) {
+    const problems = [`wiki promotion failed: ${err instanceof Error ? err.message : String(err)}`];
+    removeDir(stagingDir);
+    if (hadWiki) {
+      removeDir(wiki);
+      try {
+        renameSync(prev, wiki);
+      } catch {
+        problems.push(`previous wiki could not be restored and remains at ${prev}`);
+        return { ok: false, problems };
+      }
+    }
+    return { ok: false, problems };
+  }
+  if (hadWiki) removeDir(prev);
+  return { ok: true };
+}
+function resolvePlan(input) {
+  const staged = input.adopted ? readWikiPlanFile(input.stagingDir) : null;
+  if (staged !== null) return { plan: staged, resumed: true, unclaimedAreas: [] };
+  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))
+    );
+    return {
+      plan: scopePlanForUpdate({
+        plan: input.previousPlan,
+        changedPaths: changed,
+        existingPages: new Set(wikiMarkdownFilesInDir(input.stagingDir)),
+        pageSources
+      }),
+      resumed: false,
+      unclaimedAreas: unclaimedCandidates(input.previousPlan, input.candidate, pageSources)
+    };
+  }
+  return { plan: input.candidate, resumed: false, unclaimedAreas: [] };
+}
+function reconcilePlan(plan, stagingDir) {
+  const contentFiles = wikiMarkdownFilesInDir(stagingDir).filter((relPath) => !isGeneratedWikiFile(relPath));
+  const onDisk = new Set(contentFiles);
+  const planned = new Set(plan.pages.map((page) => page.path));
+  const adopted = contentFiles.filter((relPath) => !planned.has(relPath)).map((relPath) => ({
+    path: relPath,
+    title: relPath.replace(/\.md$/, ""),
+    intent: "",
+    sources: [],
+    status: "written",
+    attempts: 1
+  }));
+  return {
+    ...plan,
+    pages: [
+      ...plan.pages.map(
+        (page) => onDisk.has(page.path) ? { ...page, status: "written" } : { ...page, status: "pending" }
+      ),
+      ...adopted
+    ]
+  };
+}
+async function runWikiGenerate(input = { model: "configured-clio-target" }) {
+  const cwd = input.cwd ?? process.cwd();
+  const existingMeta = readWikiMeta(cwd);
+  const mode = input.mode ?? (existingMeta ? "update" : "init");
+  const lock = acquireWikiLock(cwd);
+  if (!lock.ok) {
+    progress2(input, { phase: "generate", status: "failed", message: lock.problem });
+    progress2(input, { phase: "done", status: "failed", message: "wiki generation failed", detail: lock.problem });
+    return failed([lock.problem], listWikiPagesInDir(wikiDir(cwd)).length);
+  }
+  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 generation = planWikiGeneration(codewiki, input.depth ?? "auto");
+    progress2(input, {
+      phase: "codewiki",
+      status: "completed",
+      message: `loaded ${indexedSourceFileCount2(codewiki)} source file${indexedSourceFileCount2(codewiki) === 1 ? "" : "s"}`,
+      current: indexedSourceFileCount2(codewiki),
+      total: indexedSourceFileCount2(codewiki)
+    });
+    const staging = adoptOrCreateStaging(cwd);
+    const resolved = resolvePlan({
+      cwd,
+      stagingDir: staging.dir,
+      adopted: staging.adopted,
+      mode,
+      candidate: generation.plan,
+      previousPlan: existingMeta?.plan,
+      gitHead: existingMeta?.gitHead ?? null
+    });
+    const owed = resolved.plan.pages.filter((page) => page.status !== "written").length;
+    progress2(input, {
+      phase: "codewiki",
+      status: "running",
+      message: `selected ${generation.depth} wiki strategy`,
+      detail: `${generation.sourceFiles} source files; ${generation.sourceLines} lines; ${resolved.plan.pages.length} pages planned; ${owed} to write` + (resolved.resumed ? "; resuming an interrupted run" : "")
+    });
+    writeWikiPlanFile(staging.dir, resolved.plan);
+    const beforeHash = computeWikiContentHash(cwd);
+    if (!input.generate) {
+      const problem = "wiki generation requires a model runtime";
+      progress2(input, { phase: "generate", status: "failed", message: problem });
+      progress2(input, { phase: "done", status: "failed", message: "wiki generation failed" });
+      return failed([problem], listWikiPagesInDir(wikiDir(cwd)).length);
+    }
+    progress2(input, {
+      phase: "generate",
+      status: "started",
+      message: mode === "init" ? "drafting project wiki" : "updating project wiki"
+    });
+    try {
+      await input.generate({
+        cwd,
+        mode,
+        outputDir: staging.dir,
+        codewiki,
+        generation,
+        plan: resolved.plan,
+        resumed: resolved.resumed,
+        unclaimedAreas: resolved.unclaimedAreas,
+        gitHead: existingMeta?.gitHead ?? null,
+        ...input.onProgress ? { progress: input.onProgress } : {}
+      });
+    } catch (err) {
+      const problem = err instanceof Error ? err.message : String(err);
+      progress2(input, { phase: "generate", status: "failed", message: "wiki generator failed", detail: problem });
+      progress2(input, {
+        phase: "done",
+        status: "failed",
+        message: "wiki generation failed",
+        detail: `staged work kept at ${staging.dir}; rerun to resume`
+      });
+      return failed([problem], listWikiPagesInDir(wikiDir(cwd)).length);
+    }
+    progress2(input, { phase: "generate", status: "completed", message: "wiki generator completed" });
+    const workedPlan = readWikiPlanFile(staging.dir, resolved.plan) ?? resolved.plan;
+    const report = assembleWikiTree({ dir: staging.dir, sourceRoot: cwd, plan: workedPlan });
+    const finalPlan = reconcilePlan(workedPlan, staging.dir);
+    const pendingCount = finalPlan.pages.filter((page) => page.status !== "written").length;
+    progress2(input, {
+      phase: "state",
+      status: "running",
+      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 });
+    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}`);
+    const writeMeta = () => {
+      writeWikiMeta(cwd, {
+        version: 1,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        gitHead: currentWikiGitHead(cwd),
+        sourceTreeHash,
+        model: input.model,
+        contentHash: afterHash,
+        pages: stagedPages,
+        generation: {
+          requestedDepth: generation.requestedDepth,
+          depth: generation.depth,
+          sourceFiles: generation.sourceFiles,
+          sourceLines: generation.sourceLines,
+          pagesPlanned: finalPlan.pages.length,
+          pagesWritten: finalPlan.pages.length - pendingCount
+        },
+        plan: finalPlan
+      });
+    };
+    const done = (status) => ({
+      status,
+      pages: stagedPages.length,
+      pending: pendingCount,
+      ...problems.length > 0 ? { problems } : {}
+    });
+    if (afterHash === beforeHash && computeWikiContentHash(cwd) === beforeHash && existingMeta) {
+      removeDir(staging.dir);
+      progress2(input, {
+        phase: "state",
+        status: "completed",
+        message: "wiki unchanged; metadata preserved",
+        detail: wikiMetaPath(cwd)
+      });
+      progress2(input, { phase: "done", status: "completed", message: "wiki unchanged" });
+      return done("noop");
+    }
+    progress2(input, { phase: "state", status: "running", message: "promoting wiki" });
+    const promoted = promoteStaging(cwd, staging.dir, writeMeta);
+    if (!promoted.ok) {
+      progress2(input, {
+        phase: "done",
+        status: "failed",
+        message: "wiki promotion failed",
+        detail: promoted.problems.join("; ")
+      });
+      return failed(promoted.problems, listWikiPagesInDir(wikiDir(cwd)).length);
+    }
+    progress2(input, { phase: "state", status: "completed", message: "wiki metadata written" });
+    progress2(input, {
+      phase: "done",
+      status: "completed",
+      message: pendingCount > 0 ? "wiki partially generated" : "wiki generated",
+      ...pendingCount > 0 ? {
+        detail: `${pendingCount} page${pendingCount === 1 ? "" : "s"} remain; run \`clio-coder context wiki --update\` to finish`
+      } : {}
+    });
+    return done("generated");
+  } finally {
+    lock.release();
+  }
+}
+
+// src/domains/context/refresh.ts
+function curateClioMd(cwd, codewiki) {
+  try {
+    const parsed = tryReadClioMd(cwd);
+    if (!parsed?.ok) return "absent";
+    const handbook = parsed.value;
+    const fresh = new Map(codewikiSections(codewiki).map((section) => [section.title, section.body]));
+    let changed = false;
+    const sections = handbook.sections.map((section) => {
+      const body = fresh.get(section.title);
+      if (body === void 0 || body === section.body) return section;
+      changed = true;
+      return { title: section.title, body };
+    });
+    if (!changed) return "unchanged";
+    writeFileSync3(
+      join8(cwd, "CLIO-CODER.md"),
+      serializeClioMd({
+        projectName: handbook.projectName,
+        identity: handbook.identity,
+        conventions: handbook.conventions,
+        invariants: handbook.invariants,
+        sections,
+        ...handbook.importedAgentContext ? { importedAgentContext: handbook.importedAgentContext } : {},
+        fingerprint: handbook.fingerprint
+      }),
+      "utf8"
+    );
+    return "updated";
+  } catch {
+    return "absent";
+  }
+}
+function indexedSourceFileCount3(codewiki) {
+  return codewiki.files.filter((file) => file.lang !== "config").length;
+}
+var STALE_WIKI_REFRESH_HINT = "wiki is stale; run clio-coder context refresh --wiki or clio-coder context wiki --update";
+var NO_WIKI_HINT = "no wiki exists, so --wiki had nothing to update; run clio-coder context wiki to build one";
+function incompleteWikiHint(cwd) {
+  const completeness = wikiCompleteness(cwd);
+  if (!completeness || completeness.owed === 0) return void 0;
+  return `wiki is incomplete: ${completeness.pagesWritten} of ${completeness.pagesPlanned} planned pages written, ${completeness.owed} owed; run clio-coder context wiki --update to resume`;
+}
+async function runContextRefresh(input = {}) {
+  const cwd = input.cwd ?? process.cwd();
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  const prev = readClioState(cwd);
+  const hasWiki = readWikiMeta(cwd) !== null;
+  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
+  });
+  const entries = indexedSourceFileCount3(codewiki);
+  let wikiResult;
+  let hint;
+  if (input.wiki === true && hasWiki) {
+    wikiResult = await runWikiGenerate({
+      cwd,
+      mode: "update",
+      model: input.wikiModel ?? "unresolved-documenter-target",
+      ...input.wikiGenerate ? { generate: input.wikiGenerate } : {},
+      ...input.onProgress ? { onProgress: input.onProgress } : {}
+    });
+  } else if (input.wiki === true) {
+    hint = NO_WIKI_HINT;
+  } 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" : "";
+  input.io?.stdout(
+    `clio-coder context refresh: codewiki rebuilt (${entries} source file${entries === 1 ? "" : "s"})${handbookNote}
+`
+  );
+  input.onProgress?.({ phase: "done", status: "completed", message: "context refreshed" });
+  return {
+    action: "refreshed",
+    codewikiEntries: entries,
+    fingerprint,
+    clioMd,
+    ...wikiResult ? { wiki: wikiResult } : {},
+    ...hint ? { hint } : {}
+  };
+}
+
+// src/domains/context/extension.ts
+function persistState(cwd, fingerprint, indexedAt, prev, codewikiVersion) {
+  writeClioState(cwd, {
+    version: 1,
+    projectType: prev?.projectType ?? detectProjectType(cwd),
+    fingerprint,
+    codewikiVersion,
+    ...prev?.contextSources ? { contextSources: prev.contextSources } : {},
+    ...prev?.contextSourceHash ? { contextSourceHash: prev.contextSourceHash } : {},
+    ...prev?.lastBootstrap ? { lastBootstrap: prev.lastBootstrap } : {},
+    ...prev?.lastInitAt ? { lastInitAt: prev.lastInitAt } : {},
+    lastSessionAt: prev?.lastSessionAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    lastIndexedAt: indexedAt
+  });
+}
+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;
+  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);
+}
+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;
+  } catch {
+    return 0;
+  }
+}
+function resolveClioMdState(cwd) {
+  const clio = tryReadClioMd(cwd);
+  if (!clio) return "none";
+  if (!clio.ok) return "malformed";
+  const state = readClioState(cwd);
+  if (state?.contextSources !== void 0 && adoptionSourcesChanged(state.contextSources, { cwd })) {
+    return "stale";
+  }
+  return "ok";
+}
+function createContextStateReader() {
+  let cached = null;
+  return {
+    read(cwd = process.cwd()) {
+      const now = Date.now();
+      if (cached && cached.cwd === cwd && now - cached.at < CONTEXT_STATE_CACHE_TTL_MS) return cached.state;
+      const state = { clioMd: resolveClioMdState(cwd), memoryCount: memoryCount() };
+      cached = { cwd, at: now, state };
+      return state;
+    },
+    invalidate(cwd) {
+      if (!cached) return;
+      if (!cwd || cached.cwd === cwd) cached = null;
+    }
+  };
+}
+function collectStartupHints(cwd, options = {}) {
+  const hints = [];
+  let projectType;
+  try {
+    projectType = detectProjectType(cwd);
+  } catch {
+    projectType = "unknown";
+  }
+  const clio = tryReadClioMd(cwd);
+  if (!clio && 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}`);
+  }
+  const state = readClioState(cwd);
+  if (!state) return hints;
+  if (state.contextSources !== void 0 && adoptionSourcesChanged(state.contextSources, { cwd })) {
+    hints.push("clio: Imported agent context changed. Run /context init --adopt to refresh.");
+  }
+  return hints;
+}
+function createContextBundle(_context, options = {}) {
+  let lastCwd = process.cwd();
+  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(() => {
+    });
+    startupHints = collectStartupHints(lastCwd, options);
+    if (process.env.CLIO_CODER_INTERACTIVE === "1") return;
+    for (const hint of startupHints) process.stderr.write(`${hint}
+`);
+  };
+  let incrementalQueue = Promise.resolve();
+  const noteFileChanges = (paths, cwd = lastCwd) => {
+    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
+      );
+      contextState.invalidate(cwd);
+    }).catch(() => {
+    });
+  };
+  let unsubscribeSessionStart = null;
+  const extension = {
+    start() {
+      unsubscribeSessionStart = _context.bus.on(BusChannels.SessionStart, onStart);
+    },
+    async stop() {
+      unsubscribeSessionStart?.();
+      unsubscribeSessionStart = null;
+      await incrementalQueue;
+      const slicer = createSlicer();
+      const projectType = detectProjectType(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 } : {}
+      });
+    }
+  };
+  const contract = {
+    async runBootstrap(input) {
+      const emitProgress = (event) => {
+        _context.bus.emit(BusChannels.ContextActivity, { kind: "context-init", at: Date.now(), ...event });
+        input?.onProgress?.(event);
+      };
+      try {
+        const result = await runBootstrap(input ? { ...input, onProgress: emitProgress } : { onProgress: emitProgress });
+        const cwd = input?.cwd ?? process.cwd();
+        contextState.invalidate(cwd);
+        if (cwd === lastCwd) startupHints = collectStartupHints(cwd, options);
+        return result;
+      } catch (err) {
+        emitProgress({
+          phase: "done",
+          status: "failed",
+          message: "context init failed",
+          detail: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+    },
+    async runContextClear(input) {
+      const emitProgress = (event) => {
+        _context.bus.emit(BusChannels.ContextActivity, { kind: "context-clear", at: Date.now(), ...event });
+      };
+      emitProgress({ phase: "done", status: "started", message: "clearing context" });
+      try {
+        const result = await runContextClear(input);
+        const cwd = input?.cwd ?? process.cwd();
+        contextState.invalidate(cwd);
+        if (cwd === lastCwd) startupHints = collectStartupHints(cwd, options);
+        emitProgress({ phase: "done", status: "completed", message: "context cleared" });
+        return result;
+      } catch (err) {
+        emitProgress({
+          phase: "done",
+          status: "failed",
+          message: "context clear failed",
+          detail: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+    },
+    async runContextRefresh(input) {
+      const emitProgress = (event) => {
+        _context.bus.emit(BusChannels.ContextActivity, { kind: "context-refresh", at: Date.now(), ...event });
+        input?.onProgress?.(event);
+      };
+      try {
+        const result = await runContextRefresh(
+          input ? { ...input, onProgress: emitProgress } : { onProgress: emitProgress }
+        );
+        const cwd = input?.cwd ?? process.cwd();
+        contextState.invalidate(cwd);
+        if (cwd === lastCwd) startupHints = collectStartupHints(cwd, options);
+        return result;
+      } catch (err) {
+        emitProgress({
+          phase: "done",
+          status: "failed",
+          message: "context refresh failed",
+          detail: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+    },
+    async runWikiGenerate(input) {
+      const emitProgress = (event) => {
+        _context.bus.emit(BusChannels.ContextActivity, { kind: "context-wiki", at: Date.now(), ...event });
+        input?.onProgress?.(event);
+      };
+      try {
+        return await runWikiGenerate(
+          input ? { ...input, onProgress: emitProgress } : { model: "configured-clio-target", onProgress: emitProgress }
+        );
+      } catch (err) {
+        emitProgress({
+          phase: "done",
+          status: "failed",
+          message: "context wiki failed",
+          detail: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+    },
+    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() ?? "";
+      return {
+        projectName: clio.value.projectName,
+        conventions: [...clio.value.conventions],
+        invariants: [...clio.value.invariants],
+        ...verificationBody.length > 0 ? { verificationExpectations: verificationBody } : {}
+      };
+    },
+    contextState: contextState.read,
+    startupHints: () => [...startupHints],
+    noteFileChanges
+  };
+  return { extension, contract };
+}
+
+// src/domains/context/manifest.ts
+var ContextManifest = {
+  name: "context",
+  dependsOn: ["resources"]
+};
+
+// src/domains/context/operator-profile.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "node:fs";
+import { join as join9 } from "node:path";
+import { parse as parseYaml2 } from "yaml";
+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(parseYaml2(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/project-rules.ts
+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";
+import { parse as parseYaml3 } from "yaml";
+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;
+  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 });
+  } catch {
+    return;
+  }
+  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);
+  }
+}
+function parseRule(filePath, root, issues) {
+  let text;
+  try {
+    text = readFileSync9(filePath, "utf8").replace(/\r\n/g, "\n");
+  } catch (err) {
+    issues.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+    return { excludes: [] };
+  }
+  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 = parseYaml3(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 = createHash4("sha256").update(trimmedBody).digest("hex").slice(0, 16);
+  const rule = {
+    id,
+    sourcePath: join10(".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 = join10(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 path of workingPaths) {
+      if (regex.test(normalizeGlobInput(path))) 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/wiki/prompts.ts
+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();
+  for (const [token, value] of Object.entries(substitutions)) {
+    text = text.split(`{{${token}}}`).join(value);
+  }
+  return text;
+}
+var REPOSITORY_GUIDANCE_CANDIDATES = [
+  ".claude/CLAUDE.md",
+  "AGENTS.md",
+  "CLAUDE.md",
+  "CLIO-CODER.md",
+  "CODEX.md",
+  ".codex/AGENTS.md",
+  "GEMINI.md",
+  ".github/copilot-instructions.md"
+];
+function isWithin(root, candidate) {
+  const rel = relative5(root, candidate);
+  return rel.length === 0 || !rel.startsWith("..") && !isAbsolute2(rel);
+}
+function repositoryGuidancePaths(cwd) {
+  let root;
+  try {
+    root = realpathSync(cwd);
+  } catch {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const paths = [];
+  for (const relPath of REPOSITORY_GUIDANCE_CANDIDATES) {
+    const absPath = join11(cwd, relPath);
+    if (!existsSync9(absPath)) continue;
+    try {
+      const resolved = realpathSync(absPath);
+      const stat = statSync3(resolved);
+      if (!isWithin(root, resolved) || !stat.isFile() || stat.size === 0 || seen.has(resolved)) continue;
+      seen.add(resolved);
+      paths.push(relPath);
+    } catch {
+    }
+  }
+  return paths;
+}
+function repositoryGuidance(cwd) {
+  const paths = repositoryGuidancePaths(cwd);
+  if (paths.length === 0) {
+    return "No recognized repository instruction files were detected. Discover source-of-truth documentation from the live tree.";
+  }
+  return [
+    "Read every detected instruction file before drafting:",
+    ...paths.map((path) => `- ${path}`),
+    "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");
+}
+function gitLines(cwd, args, cap) {
+  try {
+    const out3 = execFileSync2("git", [...args], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trimEnd();
+    const lines = out3.split(/\r?\n/).filter((line) => line.length > 0);
+    if (lines.length === 0) return "";
+    const capped = lines.slice(0, cap);
+    return `${capped.join("\n")}${lines.length > capped.length ? `
+[truncated to ${cap} lines]` : ""}`;
+  } catch {
+    return null;
+  }
+}
+function workingTreeEvidence(cwd) {
+  const out3 = gitLines(cwd, ["status", "--short", "--untracked-files=all"], 200);
+  if (out3 === null) return "Working-tree evidence unavailable: git status failed.";
+  return out3.length === 0 ? "Working tree is clean." : out3;
+}
+function gitEvidence(cwd, gitHead) {
+  if (!gitHead) return "Git evidence unavailable: no previous wiki gitHead was recorded.";
+  const out3 = gitLines(cwd, ["log", `${gitHead}..HEAD`, "--name-status", "--oneline"], 200);
+  if (out3 === null) return "Git evidence unavailable: git log failed for the recorded wiki gitHead.";
+  return out3.length === 0 ? "Git evidence is empty: no commits were found since the recorded wiki gitHead." : out3;
+}
+function renderPlanSkeleton(plan) {
+  return JSON.stringify(
+    {
+      overview: plan.overview,
+      pages: plan.pages.map((page) => ({
+        path: page.path,
+        title: page.title,
+        intent: page.intent,
+        sources: page.sources
+      }))
+    },
+    null,
+    2
+  );
+}
+function buildWikiPlanPrompt(input) {
+  const { generation } = input;
+  const plan = input.plan ?? generation.plan;
+  const unclaimed = input.unclaimedAreas ?? [];
+  const sections = [
+    readWikiFragment("plan", { planPath: join11(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",
+    "```json",
+    renderPlanSkeleton(plan),
+    "```"
+  ];
+  if (unclaimed.length > 0) {
+    sections.push(
+      "## Areas no page covers",
+      "The index found these areas and no page in the plan above claims any of their sources. Add a page for each one that deserves its own, or fold it into an existing page by extending that page's sources.",
+      unclaimed.map((page) => `- ${page.path} (${page.title}): ${page.sources.join(", ")}`).join("\n")
+    );
+  }
+  sections.push(
+    "## Repository guidance",
+    repositoryGuidance(input.cwd),
+    "## Working-tree evidence",
+    "```text",
+    workingTreeEvidence(input.cwd),
+    "```",
+    "## Codewiki digest",
+    "```text",
+    renderCodewikiDigest(input.codewiki),
+    "```"
+  );
+  if (input.mode === "update") {
+    sections.push("## Git evidence", "```text", gitEvidence(input.cwd, input.gitHead), "```");
+  }
+  return `${sections.join("\n\n")}
+`;
+}
+function scopedSymbols(codewiki, sources, limit = 60) {
+  const wanted = new Set(sources);
+  const fileById = new Map(codewiki.files.map((file) => [file.id, file]));
+  const lines = [];
+  for (const symbol of codewiki.symbols) {
+    const file = fileById.get(symbol.fileId);
+    if (!file || !wanted.has(file.path)) continue;
+    lines.push(`- ${symbol.name} ${symbol.kind} ${file.path}:${symbol.line}`);
+    if (lines.length >= limit) break;
+  }
+  return lines.length > 0 ? lines.join("\n") : "No indexed symbols for these paths; read the files directly.";
+}
+function buildWikiPagePrompt(input) {
+  const { page } = 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),
+      pageRelPath: page.path,
+      pageTitle: page.title
+    }),
+    "## What this page must document",
+    page.intent.length > 0 ? page.intent : `Document ${page.title}.`,
+    "## Anchor sources",
+    page.sources.length > 0 ? `Read every one of these before writing, then follow at least one call in each direction:
+${page.sources.map((source) => `- ${source}`).join("\n")}` : "No anchor sources were planned. Use `code_nav` to locate this page's subject before writing.",
+    "## Indexed symbols under those sources",
+    "```text",
+    scopedSymbols(input.codewiki, page.sources),
+    "```",
+    "## Other pages you may link to",
+    siblingLines.length > 0 ? siblingLines.join("\n") : "None; this is the only page in the plan.",
+    "## Repository guidance",
+    repositoryGuidance(input.cwd)
+  ];
+  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.`
+    );
+  }
+  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,
+  renderImportedAgentContext,
+  adoptionSourcesChanged,
+  parseClioMd,
+  serializeClioMd,
+  tryReadClioMd,
+  renderPromptContext,
+  fallbackBootstrapOutput,
+  runBootstrap,
+  runContextClear,
+  assembleWikiTree,
+  WIKI_DEPTH_STRATEGY,
+  pagePathForArea,
+  buildCandidatePlan,
+  planWikiGeneration,
+  runWikiGenerate,
+  runContextRefresh,
+  OPERATOR_PROFILE_MAX_CHARS,
+  loadOperatorProfile,
+  renderOperatorProfile,
+  loadProjectRules,
+  selectActiveRules,
+  buildWikiPlanPrompt,
+  buildWikiPagePrompt,
+  ContextDomainModule,
+  createContextDomainModule
+};
+//# sourceMappingURL=chunk-UWIJNAOB.js.map