@iowarp/clio-coder 0.3.1 → 0.3.3

package/dist/chunk-LBMZMYH2.js

@@ -0,0 +1,285 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/context/codewiki/schema.ts
+init_esm_shims();
+var CODEWIKI_VERSION = 5;
+
+// src/domains/context/codewiki/artifact.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+function uniqueSorted(values) {
+  return [...new Set([...values].filter((item) => item.length > 0))].sort((a, b) => a.localeCompare(b));
+}
+function stableFileId(path) {
+  return `f_${createHash("sha256").update(path).digest("hex").slice(0, 16)}`;
+}
+function languageForLegacyPath(path) {
+  if (path.endsWith(".d.ts")) return null;
+  const extension = path.slice(path.lastIndexOf("."));
+  const source = (/* @__PURE__ */ new Map([
+    [".ts", "typescript"],
+    [".tsx", "typescript"],
+    [".mts", "typescript"],
+    [".cts", "typescript"],
+    [".js", "javascript"],
+    [".jsx", "javascript"],
+    [".mjs", "javascript"],
+    [".cjs", "javascript"],
+    [".py", "python"],
+    [".pyw", "python"],
+    [".rs", "rust"],
+    [".go", "go"],
+    [".c", "c"],
+    [".h", "c"],
+    [".cc", "c++"],
+    [".cpp", "c++"],
+    [".cxx", "c++"],
+    [".hpp", "c++"],
+    [".hh", "c++"],
+    [".hxx", "c++"],
+    [".cu", "c++"],
+    [".cuh", "c++"],
+    [".java", "java"],
+    [".rb", "ruby"],
+    [".cs", "c#"]
+  ])).get(extension);
+  if (source) return source;
+  const name = path.split("/").pop() ?? path;
+  return (/* @__PURE__ */ new Set([
+    "package.json",
+    "pyproject.toml",
+    "setup.py",
+    "Cargo.toml",
+    "go.mod",
+    "pom.xml",
+    "CMakeLists.txt",
+    "compile_commands.json",
+    "Gemfile"
+  ])).has(name) || name.endsWith(".csproj") || name.toLowerCase().endsWith(".cmake") ? "config" : null;
+}
+function compareFiles(a, b) {
+  return a.path.localeCompare(b.path);
+}
+function compareSymbols(a, b) {
+  return a.fileId.localeCompare(b.fileId) || a.line - b.line || a.name.localeCompare(b.name) || a.kind.localeCompare(b.kind);
+}
+function compareEdges(a, b) {
+  const file = a.fileId.localeCompare(b.fileId);
+  if (file !== 0) return file;
+  const left = "toFileId" in a ? a.toFileId : `~${a.externalModule}`;
+  const right = "toFileId" in b ? b.toFileId : `~${b.externalModule}`;
+  return left.localeCompare(right);
+}
+var SIG_KINDS = /* @__PURE__ */ new Set(["func", "class", "method", "type"]);
+function normalizeSymbol(symbol) {
+  const sig = SIG_KINDS.has(symbol.kind) ? symbol.sig?.trim().slice(0, 240) : void 0;
+  return { name: symbol.name, kind: symbol.kind, fileId: symbol.fileId, line: symbol.line, ...sig ? { sig } : {} };
+}
+function normalizeCodewiki(codewiki) {
+  return {
+    version: CODEWIKI_VERSION,
+    language: codewiki.language,
+    files: codewiki.files.map((file) => ({
+      id: file.id,
+      path: file.path,
+      lang: file.lang,
+      loc: file.loc,
+      role: file.role,
+      hash: file.hash,
+      imports: uniqueSorted(file.imports),
+      ...file.summary ? { summary: file.summary } : {}
+    })).sort(compareFiles),
+    symbols: codewiki.symbols.map(normalizeSymbol).sort(compareSymbols),
+    edges: [...codewiki.edges].sort(compareEdges)
+  };
+}
+function codewikiPath(cwd) {
+  return join(cwd, ".clio-coder", "codewiki.json");
+}
+function serializeCodewiki(codewiki) {
+  return `${JSON.stringify(normalizeCodewiki(codewiki))}
+`;
+}
+function writeCodewiki(cwd, codewiki) {
+  const serialized = serializeCodewiki(codewiki);
+  safeResourceWrite(codewikiPath(cwd), serialized, { encoding: "utf8" });
+  return serialized;
+}
+function upgradeV3(value) {
+  return normalizeCodewiki({
+    version: CODEWIKI_VERSION,
+    language: value.language,
+    files: value.files.map((file) => ({ ...file, hash: "", imports: [] })),
+    symbols: value.symbols,
+    edges: value.edges
+  });
+}
+function upgradeV4(value) {
+  return normalizeCodewiki({
+    version: CODEWIKI_VERSION,
+    language: value.language,
+    files: value.files.map((file) => ({ ...file, hash: "" })),
+    symbols: value.symbols,
+    edges: value.edges
+  });
+}
+function upgradeV2(value) {
+  const files = value.entries.map((entry) => ({
+    id: stableFileId(entry.path),
+    path: entry.path,
+    lang: languageForLegacyPath(entry.path) ?? (value.language === "unknown" || value.language === "polyglot" || value.language === "dotfiles" ? "config" : value.language),
+    loc: 0,
+    role: entry.kind === "entry-point" ? "entry" : entry.kind === "test" ? "test" : "module"
+  }));
+  const ids = new Map(files.map((file) => [file.path, file.id]));
+  const symbols = value.entries.flatMap(
+    (entry) => entry.exports.map((name) => ({ name, kind: "const", fileId: ids.get(entry.path) ?? "", line: 1 }))
+  ).filter((symbol) => symbol.fileId);
+  const edges = value.entries.flatMap(
+    (entry) => entry.imports.map((item) => {
+      const fileId = ids.get(entry.path) ?? "";
+      const toFileId = ids.get(item);
+      return toFileId ? { fileId, toFileId } : { fileId, externalModule: item };
+    })
+  ).filter((edge) => edge.fileId);
+  return upgradeV3({ version: 3, language: value.language, files, symbols, edges });
+}
+var LANGUAGES = /* @__PURE__ */ new Set([
+  "typescript",
+  "javascript",
+  "python",
+  "rust",
+  "go",
+  "c",
+  "c++",
+  "java",
+  "ruby",
+  "c#",
+  "config"
+]);
+var ROLES = /* @__PURE__ */ new Set(["entry", "test", "module", "config"]);
+var KINDS = /* @__PURE__ */ new Set(["func", "class", "method", "type", "const", "var", "trait", "iface"]);
+function object(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function validFile(value, hash) {
+  const item = object(value);
+  if (!item) return false;
+  return typeof item.id === "string" && typeof item.path === "string" && typeof item.lang === "string" && LANGUAGES.has(item.lang) && Number.isInteger(item.loc) && item.loc >= 0 && typeof item.role === "string" && ROLES.has(item.role) && (!hash || typeof item.hash === "string" && Array.isArray(item.imports) && item.imports.every((v) => typeof v === "string")) && (!("summary" in item) || typeof item.summary === "string");
+}
+function validSymbol(value) {
+  const item = object(value);
+  if (!item) return false;
+  return typeof item.name === "string" && typeof item.kind === "string" && KINDS.has(item.kind) && typeof item.fileId === "string" && Number.isInteger(item.line) && item.line >= 1 && (!("sig" in item) || typeof item.sig === "string");
+}
+function validEdge(value) {
+  const item = object(value);
+  if (!item || typeof item.fileId !== "string") return false;
+  return typeof item.toFileId === "string" !== (typeof item.externalModule === "string");
+}
+function validEntry(value) {
+  const item = object(value);
+  if (!item || typeof item.path !== "string") return false;
+  return Array.isArray(item.exports) && item.exports.every((v) => typeof v === "string") && Array.isArray(item.imports) && item.imports.every((v) => typeof v === "string") && (item.kind === "entry-point" || item.kind === "test" || item.kind === "module") && (!("summary" in item) || typeof item.summary === "string");
+}
+function validNative(value) {
+  const ids = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  const loc = /* @__PURE__ */ new Map();
+  for (const file of value.files) {
+    const segments = file.path.split("/");
+    if (ids.has(file.id) || paths.has(file.path) || file.path.length === 0 || file.path.includes("\0") || file.path.includes("\\") || file.path.startsWith("/") || /^[A-Za-z]:\//.test(file.path) || segments.some((part) => part.length === 0 || part === "." || part === "..") || !/^[0-9a-f]{16}$/.test(file.hash))
+      return false;
+    ids.add(file.id);
+    paths.add(file.path);
+    loc.set(file.id, file.loc);
+  }
+  for (const symbol of value.symbols) {
+    const lines = loc.get(symbol.fileId);
+    if (lines === void 0 || symbol.line > lines) return false;
+  }
+  return value.edges.every((edge) => ids.has(edge.fileId) && (!("toFileId" in edge) || ids.has(edge.toFileId)));
+}
+function upgrade(value) {
+  const item = object(value);
+  if (!item || typeof item.language !== "string") return null;
+  if (item.version === 5 && Array.isArray(item.files) && item.files.every((v) => validFile(v, true)) && Array.isArray(item.symbols) && item.symbols.every(validSymbol) && Array.isArray(item.edges) && item.edges.every(validEdge) && validNative(item))
+    return normalizeCodewiki(item);
+  if (item.version === 4 && Array.isArray(item.files) && item.files.every((v) => validFile(v, true)) && Array.isArray(item.symbols) && item.symbols.every(validSymbol) && Array.isArray(item.edges) && item.edges.every(validEdge))
+    return upgradeV4(item);
+  if (item.version === 3 && Array.isArray(item.files) && item.files.every((v) => validFile(v, false)) && Array.isArray(item.symbols) && item.symbols.every(validSymbol) && Array.isArray(item.edges) && item.edges.every(validEdge))
+    return upgradeV3(item);
+  if (item.version === 2 && typeof item.generatedAt === "string" && Array.isArray(item.entries) && item.entries.every(validEntry))
+    return upgradeV2(item);
+  return null;
+}
+function parseCodewikiRaw(raw) {
+  try {
+    return upgrade(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function readCodewiki(cwd) {
+  const path = codewikiPath(cwd);
+  if (!existsSync(path)) return null;
+  try {
+    return parseCodewikiRaw(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function readCodewikiAsync(cwd) {
+  try {
+    return parseCodewikiRaw(await readFile(codewikiPath(cwd), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function codewikiNeedsBackfill(codewiki) {
+  return codewiki.files.some((file) => file.lang !== "config" && file.hash.length === 0);
+}
+function structuralCodewikiHash(codewiki) {
+  return createHash("sha256").update(JSON.stringify(normalizeCodewiki(codewiki))).digest("hex");
+}
+function codewikiEntries(codewiki) {
+  const files = new Map(codewiki.files.map((file) => [file.id, file]));
+  const exports = /* @__PURE__ */ new Map();
+  const imports = /* @__PURE__ */ new Map();
+  for (const symbol of codewiki.symbols)
+    exports.set(symbol.fileId, [...exports.get(symbol.fileId) ?? [], symbol.name]);
+  for (const edge of codewiki.edges) {
+    const value = "toFileId" in edge ? files.get(edge.toFileId)?.path : edge.externalModule;
+    if (value) imports.set(edge.fileId, [...imports.get(edge.fileId) ?? [], value]);
+  }
+  return codewiki.files.filter((file) => file.lang !== "config").map((file) => ({
+    path: file.path,
+    exports: uniqueSorted(exports.get(file.id) ?? []),
+    imports: uniqueSorted(imports.get(file.id) ?? []),
+    kind: file.role === "entry" ? "entry-point" : file.role === "test" ? "test" : "module",
+    ...file.summary ? { summary: file.summary } : {}
+  })).sort((a, b) => a.path.localeCompare(b.path));
+}
+
+export {
+  CODEWIKI_VERSION,
+  codewikiPath,
+  serializeCodewiki,
+  writeCodewiki,
+  parseCodewikiRaw,
+  readCodewiki,
+  readCodewikiAsync,
+  codewikiNeedsBackfill,
+  structuralCodewikiHash,
+  codewikiEntries
+};
+//# sourceMappingURL=chunk-LBMZMYH2.js.map

package/dist/{chunk-G34LV2PF.js → chunk-LM5TQCJZ.js}

@@ -1,101 +1,29 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
+  loadFragments,
   loadOperatorProfile,
   loadProjectRules,
   renderOperatorProfile,
   selectActiveRules
-} from "./chunk-M5T5VO65.js";
+} from "./chunk-PIWWS5BL.js";
 import {
   compile,
   compileWorker,
   sha256
-} from "./chunk-7SS2CTV2.js";
+} from "./chunk-SRDMMSEP.js";
 import {
   isUserVisibleAgent
-} from "./chunk-OLBBMFRD.js";
-import {
-  classifyProjectPreload
-} from "./chunk-K5XEMXTI.js";
+} from "./chunk-5UUP6MWO.js";
 import {
   BusChannels
-} from "./chunk-Q5WJOSJ7.js";
-import {
-  require_dist
-} from "./chunk-GB6QRBXN.js";
+} from "./chunk-OQ33BKR3.js";
 import {
-  resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+  classifyProjectPreload
+} from "./chunk-JVCV3ICN.js";
 import {
-  __toESM,
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
-// src/domains/prompts/index.ts
-init_esm_shims();
-
-// src/domains/prompts/extension.ts
-init_esm_shims();
-import { isAbsolute, relative } from "node:path";
-
-// src/core/clio-repo.ts
-init_esm_shims();
-import { existsSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-var CLIO_PACKAGE_NAME = "@iowarp/clio-coder";
-var SOURCE_MARKERS = [
-  "src/entry/orchestrator.ts",
-  "src/worker/entry.ts",
-  "src/domains/prompts/fragments/identity/clio.md"
-];
-function isFile(filePath) {
-  try {
-    return statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function readPackageJson(root) {
-  try {
-    const raw = readFileSync(path.join(root, "package.json"), "utf8");
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function repositoryMatches(value) {
-  if (typeof value === "string") return value.includes("iowarp/clio-coder");
-  if (!value || typeof value !== "object") return false;
-  const url = value.url;
-  return typeof url === "string" && url.includes("iowarp/clio-coder");
-}
-function hasGitMarker(root) {
-  return existsSync(path.join(root, ".git"));
-}
-function hasSourceMarkers(root) {
-  return SOURCE_MARKERS.every((marker) => isFile(path.join(root, marker)));
-}
-function isClioCoderRepoRoot(root) {
-  const pkg = readPackageJson(root);
-  if (pkg?.name !== CLIO_PACKAGE_NAME) return false;
-  if (!repositoryMatches(pkg.repository)) return false;
-  if (!hasGitMarker(root)) return false;
-  return hasSourceMarkers(root);
-}
-function detectClioCoderRepo(cwd = process.cwd()) {
-  let current = path.resolve(cwd);
-  for (; ; ) {
-    if (isClioCoderRepoRoot(current)) {
-      return { isClioCoderRepo: true, repoRoot: current };
-    }
-    if (hasGitMarker(current)) break;
-    const parent = path.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return { isClioCoderRepo: false, repoRoot: null };
-}
-
 // src/domains/agents/catalog.ts
 init_esm_shims();
 var DEFAULT_DISPATCH_AGENT_ID = "coder";
@@ -186,101 +114,70 @@ function formatSpecLine(spec, suffix) {
   return `- ${spec.name} [${spec.id}] (${spec.audience}, ${spec.category}, ${spec.capabilityClass}, ${spec.latencyClass}, ${spec.source}${tags}${skills}${budget})${suffix}`;
 }
 
-// src/domains/prompts/fragment-loader.ts
+// src/domains/prompts/index.ts
 init_esm_shims();
-var import_yaml = __toESM(require_dist(), 1);
-import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
-import path2 from "node:path";
-var frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-var fragmentIdRegex = /^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/;
-function defaultRootDir() {
-  return path2.join(resolvePackageRoot(), "src", "domains", "prompts", "fragments");
-}
-function walk(root) {
-  const out = [];
-  let entries;
+
+// src/domains/prompts/extension.ts
+init_esm_shims();
+import { isAbsolute, relative } from "node:path";
+
+// src/core/clio-repo.ts
+init_esm_shims();
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+var CLIO_PACKAGE_NAME = "@iowarp/clio-coder";
+var SOURCE_MARKERS = [
+  "src/entry/orchestrator.ts",
+  "src/worker/entry.ts",
+  "src/domains/prompts/fragments/identity/clio.md"
+];
+function isFile(filePath) {
   try {
-    entries = readdirSync(root, { withFileTypes: true });
+    return statSync(filePath).isFile();
   } catch {
-    return out;
-  }
-  for (const entry of entries) {
-    const full = path2.join(root, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name === "wiki") continue;
-      out.push(...walk(full));
-      continue;
-    }
-    if (entry.isFile() && entry.name.endsWith(".md")) {
-      out.push(full);
-    }
+    return false;
   }
-  return out.sort((left, right) => left.localeCompare(right));
 }
-function parseFragment(filePath, rootDir) {
-  const raw = readFileSync2(filePath, "utf8");
-  const rawRel = path2.relative(rootDir, filePath);
-  const relPath = rawRel.split(path2.sep).join("/");
-  const match = raw.match(frontmatterRegex);
-  if (!match) {
-    throw new Error(`fragment-loader: ${relPath}: missing or malformed YAML frontmatter`);
-  }
-  const frontmatterText = match[1] ?? "";
-  const body = match[2] ?? "";
-  let parsed;
+function readPackageJson(root) {
   try {
-    parsed = import_yaml.default.parse(frontmatterText);
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    throw new Error(`fragment-loader: ${relPath}: invalid YAML frontmatter (${reason})`);
-  }
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`fragment-loader: ${relPath}: frontmatter must be a YAML object`);
-  }
-  const fm = parsed;
-  const id = fm.id;
-  if (typeof id !== "string" || !fragmentIdRegex.test(id)) {
-    throw new Error(`fragment-loader: ${relPath}: frontmatter.id must be a dot-separated namespace`);
-  }
-  const version = fm.version;
-  if (version !== 1) {
-    throw new Error(`fragment-loader: ${relPath}: frontmatter.version must be 1`);
-  }
-  const description = fm.description;
-  if (typeof description !== "string" || description.trim() === "") {
-    throw new Error(`fragment-loader: ${relPath}: frontmatter.description must be a non-empty string`);
-  }
-  const dynamicRaw = fm.dynamic;
-  if (dynamicRaw !== void 0 && typeof dynamicRaw !== "boolean") {
-    throw new Error(`fragment-loader: ${relPath}: frontmatter.dynamic must be a boolean when present`);
+    const raw = readFileSync(path.join(root, "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
   }
-  return {
-    path: filePath,
-    relPath,
-    id,
-    version,
-    description,
-    dynamic: dynamicRaw === true,
-    body,
-    contentHash: sha256(raw)
-  };
 }
-function loadFragments(options) {
-  const rootDir = typeof options === "string" ? options : options?.rootDir;
-  const resolvedRoot = rootDir ? path2.resolve(rootDir) : defaultRootDir();
-  const files = walk(resolvedRoot);
-  const byId = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const fragment = parseFragment(file, resolvedRoot);
-    const existing = byId.get(fragment.id);
-    if (existing) {
-      throw new Error(
-        `fragment-loader: duplicate fragment id "${fragment.id}" in ${existing.relPath} and ${fragment.relPath}`
-      );
+function repositoryMatches(value) {
+  if (typeof value === "string") return value.includes("iowarp/clio-coder");
+  if (!value || typeof value !== "object") return false;
+  const url = value.url;
+  return typeof url === "string" && url.includes("iowarp/clio-coder");
+}
+function hasGitMarker(root) {
+  return existsSync(path.join(root, ".git"));
+}
+function hasSourceMarkers(root) {
+  return SOURCE_MARKERS.every((marker) => isFile(path.join(root, marker)));
+}
+function isClioCoderRepoRoot(root) {
+  const pkg = readPackageJson(root);
+  if (pkg?.name !== CLIO_PACKAGE_NAME) return false;
+  if (!repositoryMatches(pkg.repository)) return false;
+  if (!hasGitMarker(root)) return false;
+  return hasSourceMarkers(root);
+}
+function detectClioCoderRepo(cwd = process.cwd()) {
+  let current = path.resolve(cwd);
+  for (; ; ) {
+    if (isClioCoderRepoRoot(current)) {
+      return { isClioCoderRepo: true, repoRoot: current };
     }
-    byId.set(fragment.id, fragment);
+    if (hasGitMarker(current)) break;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
   }
-  return { byId, rootDir: resolvedRoot };
+  return { isClioCoderRepo: false, repoRoot: null };
 }
 
 // src/domains/prompts/extension.ts
@@ -329,6 +226,7 @@ function createPromptsBundle(context, options = {}) {
       const cwd = input.cwd ?? process.cwd();
       let contextFiles = "";
       let projectPreload = null;
+      let projectHandbookFiles = [];
       if (!suppressContextFiles) {
         const projectContext = contextDomain()?.renderPromptContext(cwd);
         contextFiles = projectContext ? selectProjectContext(projectContext, input.sessionInputs.providerSupportsTools ?? null) : "";
@@ -337,6 +235,7 @@ function createPromptsBundle(context, options = {}) {
             hasClioMd: projectContext.clioMd !== null,
             text: projectContext.text
           });
+          projectHandbookFiles = projectContext.handbookFiles;
         }
         for (const warning of projectContext?.warnings ?? []) process.stderr.write(`${warning}
 `);
@@ -355,17 +254,28 @@ function createPromptsBundle(context, options = {}) {
         additionalFragments: [
           ...workspaceRootFragment(cwd),
           ...clioRepoAwarenessFragments(cwd),
-          ...customizationFragments(cwd, input.workingContextPaths ?? [])
+          ...customizationFragments(cwd, input.workingContextPaths ?? []).fragments
         ]
       });
-      return { ...compiled, projectPreload };
+      return { ...compiled, projectPreload, projectHandbookFiles };
     },
     async compileWorkerPrompt(input) {
       if (!table) throw new Error("prompts domain not started");
       if (table.byId.size === 0) {
         throw new Error("prompts: no fragments loaded, check startup logs");
       }
-      return compileWorker(table, input);
+      const { cwd: inputCwd, workingContextPaths, ...workerInputs } = input;
+      const cwd = inputCwd ?? process.cwd();
+      const customization = customizationFragments(cwd, workingContextPaths ?? []);
+      const compiled = compileWorker(table, {
+        ...workerInputs,
+        additionalFragments: customization.fragments
+      });
+      return {
+        ...compiled,
+        rulesApplied: customization.activeRuleIds,
+        operatorProfileApplied: customization.operatorProfileApplied
+      };
     },
     reload
   };
@@ -396,6 +306,8 @@ function createPromptsBundle(context, options = {}) {
 }
 function customizationFragments(cwd, workingContextPaths) {
   const fragments = [];
+  let activeRuleIds = [];
+  let operatorProfileApplied = false;
   try {
     const loaded = loadProjectRules(cwd);
     const active = selectActiveRules(loaded.rules, normalizeWorkingContextPaths(cwd, workingContextPaths));
@@ -408,6 +320,7 @@ function customizationFragments(cwd, workingContextPaths) {
         contentHash: sha256(body),
         dynamic: true
       });
+      activeRuleIds = active.map((rule) => rule.id);
     }
   } catch {
   }
@@ -422,10 +335,11 @@ function customizationFragments(cwd, workingContextPaths) {
         contentHash: sha256(rendered.text),
         dynamic: true
       });
+      operatorProfileApplied = true;
     }
   } catch {
   }
-  return fragments;
+  return { fragments, activeRuleIds, operatorProfileApplied };
 }
 function normalizeWorkingContextPaths(cwd, paths) {
   const normalized = /* @__PURE__ */ new Set();
@@ -492,7 +406,7 @@ function renderProjectSynopsis(context, providerSupportsTools) {
   if (context.clioMd) {
     lines.push(`Project: ${context.clioMd.projectName}`);
     lines.push(
-      "CLIO-CODER.md: available; compact synopsis only because the handbook is too large for automatic preload."
+      "Project handbook: available; compact synopsis only because the effective layers are too large for automatic preload."
     );
   }
   if (hasCodewiki(context.text)) lines.push("Codewiki: available via code_nav.");
@@ -739,4 +653,4 @@ export {
   createPromptsDomainModule,
   SchedulingDomainModule
 };
-//# sourceMappingURL=chunk-G34LV2PF.js.map
+//# sourceMappingURL=chunk-LM5TQCJZ.js.map