kairn-cli 2.6.0 → 2.7.0

package/dist/cli.js

@@ -1409,68 +1409,1589 @@ Return ONLY valid JSON.`;
   }
 });
 
+// src/ir/types.ts
+function createEmptyIR() {
+  return {
+    meta: {
+      name: "",
+      purpose: "",
+      techStack: { language: "" },
+      autonomyLevel: 2
+    },
+    sections: [],
+    commands: [],
+    rules: [],
+    agents: [],
+    skills: [],
+    docs: [],
+    hooks: [],
+    settings: createEmptySettings(),
+    mcpServers: [],
+    intents: []
+  };
+}
+function createEmptySettings() {
+  return { hooks: {}, raw: {} };
+}
+function createSection(id, heading, content, order) {
+  return { id, heading, content, order };
+}
+function createCommandNode(name, content, description) {
+  return { name, description: description ?? "", content };
+}
+function createRuleNode(name, content, paths) {
+  const node = { name, content };
+  if (paths !== void 0) {
+    node.paths = paths;
+  }
+  return node;
+}
+function createAgentNode(name, content, model) {
+  const node = { name, content };
+  if (model !== void 0) {
+    node.model = model;
+  }
+  return node;
+}
+function createEmptyDiff() {
+  return {
+    sections: {
+      added: [],
+      removed: [],
+      modified: [],
+      reordered: []
+    },
+    commands: {
+      added: [],
+      removed: [],
+      modified: []
+    },
+    rules: {
+      added: [],
+      removed: [],
+      modified: []
+    },
+    agents: {
+      added: [],
+      removed: [],
+      modified: []
+    },
+    mcpServers: {
+      added: [],
+      removed: []
+    },
+    settings: {
+      changes: []
+    }
+  };
+}
+var init_types = __esm({
+  "src/ir/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/ir/parser.ts
+import fs21 from "fs/promises";
+import path21 from "path";
+function slugify(heading) {
+  return heading.toLowerCase().trim().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function resolveSectionId(heading) {
+  const trimmed = heading.trim();
+  for (const entry of SECTION_ID_MAP) {
+    if (entry.pattern.test(trimmed)) {
+      return entry.id;
+    }
+  }
+  return `custom-${slugify(trimmed)}`;
+}
+function parseYamlFrontmatter(content) {
+  if (!content.startsWith("---\n") && !content.startsWith("---\r\n")) {
+    return { frontmatter: {}, body: content };
+  }
+  const secondDash = content.indexOf("\n---", 3);
+  if (secondDash === -1) {
+    return { frontmatter: {}, body: content };
+  }
+  const yamlBlock = content.slice(4, secondDash);
+  const afterClose = secondDash + 4;
+  const body = content.slice(afterClose).replace(/^\r?\n/, "");
+  const frontmatter = {};
+  const lines = yamlBlock.split("\n");
+  let currentKey = null;
+  let currentList = null;
+  for (const line of lines) {
+    const trimmed = line.trimEnd();
+    if (currentKey !== null && /^\s+-\s+/.test(trimmed)) {
+      if (currentList === null) {
+        currentList = [];
+      }
+      let value = trimmed.replace(/^\s+-\s+/, "").trim();
+      value = stripQuotes(value);
+      currentList.push(value);
+      continue;
+    }
+    if (currentKey !== null && currentList !== null) {
+      frontmatter[currentKey] = currentList;
+      currentKey = null;
+      currentList = null;
+    }
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx > 0) {
+      const key = trimmed.slice(0, colonIdx).trim();
+      const rawValue = trimmed.slice(colonIdx + 1).trim();
+      if (rawValue === "") {
+        currentKey = key;
+        currentList = null;
+      } else {
+        frontmatter[key] = stripQuotes(rawValue);
+        currentKey = null;
+        currentList = null;
+      }
+    }
+  }
+  if (currentKey !== null && currentList !== null) {
+    frontmatter[currentKey] = currentList;
+  }
+  return { frontmatter, body };
+}
+function stripQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseClaudeMd(content) {
+  const meta = {
+    techStack: { language: "" },
+    autonomyLevel: 2
+  };
+  const sections = [];
+  const chunks = content.split(/^## /gm);
+  const preamble = chunks[0];
+  const titleMatch = preamble.match(/^# (.+)$/m);
+  if (titleMatch) {
+    meta.name = titleMatch[1].trim();
+  } else {
+    meta.name = "";
+  }
+  const preambleHeading = meta.name ? `# ${meta.name}` : "";
+  const preambleContent = titleMatch ? preamble.slice(preamble.indexOf(titleMatch[0]) + titleMatch[0].length).trim() : preamble.trim();
+  sections.push({
+    id: "preamble",
+    heading: preambleHeading,
+    content: preambleContent,
+    order: 0
+  });
+  for (let i = 1; i < chunks.length; i++) {
+    const chunk = chunks[i];
+    const newlineIdx = chunk.indexOf("\n");
+    const heading = newlineIdx >= 0 ? chunk.slice(0, newlineIdx).trim() : chunk.trim();
+    const sectionContent = newlineIdx >= 0 ? chunk.slice(newlineIdx + 1).trim() : "";
+    const sectionId = resolveSectionId(heading);
+    sections.push({
+      id: sectionId,
+      heading: `## ${heading}`,
+      content: sectionContent,
+      order: i
+    });
+    if (sectionId === "purpose") {
+      const firstParagraph = sectionContent.split(/\n\n/)[0].trim();
+      meta.purpose = firstParagraph;
+    }
+    if (sectionId === "tech-stack") {
+      meta.techStack = extractTechStack(sectionContent);
+    }
+  }
+  return { meta, sections };
+}
+function extractTechStack(content) {
+  const stack = { language: "" };
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("-")) continue;
+    const bullet = trimmed.slice(1).trim().toLowerCase();
+    if (!stack.language && (bullet.includes("typescript") || bullet.includes("javascript"))) {
+      stack.language = bullet.includes("typescript") ? "TypeScript" : "JavaScript";
+    } else if (!stack.language && bullet.includes("python")) {
+      stack.language = "Python";
+    } else if (!stack.language && bullet.includes("rust")) {
+      stack.language = "Rust";
+    } else if (!stack.language && bullet.includes("go ") || !stack.language && bullet.startsWith("go,")) {
+      stack.language = "Go";
+    }
+    if (!stack.buildTool) {
+      const buildTools = [
+        "tsup",
+        "webpack",
+        "vite",
+        "esbuild",
+        "rollup",
+        "parcel",
+        "turbopack",
+        "swc",
+        "cargo",
+        "make",
+        "cmake"
+      ];
+      for (const tool of buildTools) {
+        if (bullet.includes(tool)) {
+          stack.buildTool = tool;
+          break;
+        }
+      }
+    }
+    if (!stack.testRunner) {
+      const testRunners = [
+        "vitest",
+        "jest",
+        "mocha",
+        "ava",
+        "tap",
+        "pytest",
+        "cargo test"
+      ];
+      for (const runner of testRunners) {
+        if (bullet.includes(runner)) {
+          stack.testRunner = runner;
+          break;
+        }
+      }
+    }
+    if (!stack.framework) {
+      const frameworks = [
+        "commander.js",
+        "commander",
+        "express",
+        "fastify",
+        "next.js",
+        "nextjs",
+        "react",
+        "vue",
+        "angular",
+        "svelte",
+        "django",
+        "flask",
+        "actix",
+        "axum"
+      ];
+      for (const fw of frameworks) {
+        if (bullet.includes(fw)) {
+          stack.framework = fw.charAt(0).toUpperCase() + fw.slice(1);
+          break;
+        }
+      }
+    }
+    if (!stack.packageManager) {
+      const pkgManagers = ["pnpm", "yarn", "bun", "npm", "cargo", "pip"];
+      for (const pm of pkgManagers) {
+        if (bullet.includes(`${pm} `)) {
+          stack.packageManager = pm;
+          break;
+        }
+      }
+    }
+  }
+  return stack;
+}
+function parseSettings(content) {
+  const parsed = JSON.parse(content);
+  const settings = createEmptySettings();
+  const permissions = parsed["permissions"];
+  if (permissions) {
+    const deny = permissions["deny"];
+    if (Array.isArray(deny) && deny.length > 0) {
+      settings.denyPatterns = deny;
+    }
+  }
+  const statusLine = parsed["statusLine"];
+  if (statusLine && typeof statusLine.command === "string") {
+    settings.statusLine = { command: statusLine.command };
+  }
+  const hooksRaw = parsed["hooks"];
+  if (hooksRaw && typeof hooksRaw === "object") {
+    const knownEvents = [
+      "PreToolUse",
+      "PostToolUse",
+      "UserPromptSubmit",
+      "SessionStart",
+      "PostCompact"
+    ];
+    for (const event of knownEvents) {
+      const entries = hooksRaw[event];
+      if (Array.isArray(entries) && entries.length > 0) {
+        settings.hooks[event] = entries;
+      }
+    }
+  }
+  const extractedKeys = /* @__PURE__ */ new Set(["permissions", "hooks", "statusLine"]);
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!extractedKeys.has(key)) {
+      settings.raw[key] = value;
+    }
+  }
+  return settings;
+}
+function parseMcpConfig(content) {
+  const parsed = JSON.parse(content);
+  const servers = parsed["mcpServers"];
+  if (!servers || typeof servers !== "object") {
+    return [];
+  }
+  const nodes = [];
+  for (const [id, config] of Object.entries(servers)) {
+    const command = config["command"];
+    const args = config["args"] ?? [];
+    const env = config["env"];
+    const node = { id, command, args };
+    if (env && typeof env === "object" && Object.keys(env).length > 0) {
+      node.env = env;
+    }
+    nodes.push(node);
+  }
+  return nodes;
+}
+async function readDirSafe(dirPath) {
+  try {
+    return await fs21.readdir(dirPath);
+  } catch {
+    return [];
+  }
+}
+async function readFileSafe2(filePath) {
+  try {
+    return await fs21.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function isDirectory(filePath) {
+  try {
+    const stat = await fs21.stat(filePath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function parseCommands(harnessPath) {
+  const dirPath = path21.join(harnessPath, "commands");
+  const entries = await readDirSafe(dirPath);
+  const nodes = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".md")) continue;
+    const filePath = path21.join(dirPath, entry);
+    const content = await readFileSafe2(filePath);
+    if (content === null) continue;
+    const name = entry.replace(/\.md$/, "");
+    const firstLine = content.split("\n")[0].trim();
+    const description = firstLine && !firstLine.startsWith("#") && !firstLine.startsWith("```") ? firstLine : "";
+    nodes.push({ name, description, content });
+  }
+  return nodes;
+}
+async function parseRules(harnessPath) {
+  const dirPath = path21.join(harnessPath, "rules");
+  const entries = await readDirSafe(dirPath);
+  const nodes = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".md")) continue;
+    const filePath = path21.join(dirPath, entry);
+    const rawContent = await readFileSafe2(filePath);
+    if (rawContent === null) continue;
+    const name = entry.replace(/\.md$/, "");
+    const { frontmatter, body } = parseYamlFrontmatter(rawContent);
+    const node = { name, content: body };
+    const paths = frontmatter["paths"];
+    if (Array.isArray(paths) && paths.length > 0) {
+      node.paths = paths;
+    }
+    nodes.push(node);
+  }
+  return nodes;
+}
+async function parseAgents(harnessPath) {
+  const dirPath = path21.join(harnessPath, "agents");
+  const entries = await readDirSafe(dirPath);
+  const nodes = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".md")) continue;
+    const filePath = path21.join(dirPath, entry);
+    const rawContent = await readFileSafe2(filePath);
+    if (rawContent === null) continue;
+    const fileBaseName = entry.replace(/\.md$/, "");
+    const { frontmatter, body } = parseYamlFrontmatter(rawContent);
+    const name = typeof frontmatter["name"] === "string" ? frontmatter["name"] : fileBaseName;
+    const node = { name, content: body };
+    if (typeof frontmatter["model"] === "string") {
+      node.model = frontmatter["model"];
+    }
+    const disallowedTools = frontmatter["disallowedTools"];
+    if (Array.isArray(disallowedTools)) {
+      node.disallowedTools = disallowedTools;
+    }
+    nodes.push(node);
+  }
+  return nodes;
+}
+async function parseSkills(harnessPath) {
+  const dirPath = path21.join(harnessPath, "skills");
+  const entries = await readDirSafe(dirPath);
+  const nodes = [];
+  for (const entry of entries) {
+    const entryPath = path21.join(dirPath, entry);
+    if (entry.endsWith(".md")) {
+      const content = await readFileSafe2(entryPath);
+      if (content === null) continue;
+      const name = entry.replace(/\.md$/, "");
+      nodes.push({ name, content });
+    } else if (await isDirectory(entryPath)) {
+      const skillMdPath = path21.join(entryPath, "skill.md");
+      const content = await readFileSafe2(skillMdPath);
+      if (content === null) continue;
+      nodes.push({ name: entry, content });
+    }
+  }
+  return nodes;
+}
+async function parseDocs(harnessPath) {
+  const dirPath = path21.join(harnessPath, "docs");
+  const entries = await readDirSafe(dirPath);
+  const nodes = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".md")) continue;
+    const filePath = path21.join(dirPath, entry);
+    const content = await readFileSafe2(filePath);
+    if (content === null) continue;
+    const name = entry.replace(/\.md$/, "");
+    nodes.push({ name, content });
+  }
+  return nodes;
+}
+async function parseHooks(harnessPath) {
+  const dirPath = path21.join(harnessPath, "hooks");
+  const entries = await readDirSafe(dirPath);
+  const nodes = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".mjs")) continue;
+    const filePath = path21.join(dirPath, entry);
+    const content = await readFileSafe2(filePath);
+    if (content === null) continue;
+    const name = entry.replace(/\.mjs$/, "");
+    nodes.push({ name, content, type: "command" });
+  }
+  return nodes;
+}
+async function parseHarness(harnessPath) {
+  const ir = createEmptyIR();
+  const claudeMdContent = await readFileSafe2(
+    path21.join(harnessPath, "CLAUDE.md")
+  );
+  if (claudeMdContent !== null) {
+    const { meta, sections } = parseClaudeMd(claudeMdContent);
+    ir.meta = {
+      ...ir.meta,
+      ...meta,
+      techStack: { ...ir.meta.techStack, ...meta.techStack }
+    };
+    ir.sections = sections;
+  }
+  const settingsContent = await readFileSafe2(
+    path21.join(harnessPath, "settings.json")
+  );
+  if (settingsContent !== null) {
+    ir.settings = parseSettings(settingsContent);
+  }
+  const [commands, rules, agents, skills, docs, hooks] = await Promise.all([
+    parseCommands(harnessPath),
+    parseRules(harnessPath),
+    parseAgents(harnessPath),
+    parseSkills(harnessPath),
+    parseDocs(harnessPath),
+    parseHooks(harnessPath)
+  ]);
+  ir.commands = commands;
+  ir.rules = rules;
+  ir.agents = agents;
+  ir.skills = skills;
+  ir.docs = docs;
+  ir.hooks = hooks;
+  const mcpServers = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  const parentMcpPath = path21.join(path21.dirname(harnessPath), ".mcp.json");
+  const parentMcpContent = await readFileSafe2(parentMcpPath);
+  if (parentMcpContent !== null) {
+    for (const node of parseMcpConfig(parentMcpContent)) {
+      if (!seenIds.has(node.id)) {
+        seenIds.add(node.id);
+        mcpServers.push(node);
+      }
+    }
+  }
+  const innerMcpPath = path21.join(harnessPath, ".mcp.json");
+  const innerMcpContent = await readFileSafe2(innerMcpPath);
+  if (innerMcpContent !== null) {
+    for (const node of parseMcpConfig(innerMcpContent)) {
+      if (!seenIds.has(node.id)) {
+        seenIds.add(node.id);
+        mcpServers.push(node);
+      }
+    }
+  }
+  ir.mcpServers = mcpServers;
+  return ir;
+}
+var SECTION_ID_MAP;
+var init_parser = __esm({
+  "src/ir/parser.ts"() {
+    "use strict";
+    init_types();
+    SECTION_ID_MAP = [
+      { pattern: /^(purpose|about|what)\b/i, id: "purpose" },
+      { pattern: /^(tech\s*stack|technology|stack)\b/i, id: "tech-stack" },
+      { pattern: /^(commands|key\s*commands)\b/i, id: "commands" },
+      { pattern: /^architecture\b/i, id: "architecture" },
+      { pattern: /^conventions?\b/i, id: "conventions" },
+      { pattern: /^verification\b/i, id: "verification" },
+      { pattern: /^(known\s*gotchas|gotchas)\b/i, id: "gotchas" },
+      { pattern: /^output\b/i, id: "output" },
+      { pattern: /^debugging\b/i, id: "debugging" },
+      { pattern: /^git\b/i, id: "git" }
+    ];
+  }
+});
+
+// src/ir/translate.ts
+function extractName(filePath, pattern) {
+  const match = filePath.match(pattern);
+  return match ? match[1] : null;
+}
+function findSectionContaining(ir, text) {
+  return ir.sections.find((s) => s.content.includes(text));
+}
+function translateClaudeMdMutation(mutation, ir) {
+  switch (mutation.action) {
+    case "replace": {
+      if (mutation.oldText === void 0) {
+        return buildRawText(mutation);
+      }
+      const section = findSectionContaining(ir, mutation.oldText);
+      if (!section) {
+        return buildRawText(mutation);
+      }
+      return {
+        type: "update_section",
+        sectionId: section.id,
+        content: section.content.replace(mutation.oldText, mutation.newText),
+        rationale: mutation.rationale
+      };
+    }
+    case "add_section": {
+      const headingMatch = mutation.newText.match(/^## (.+)/);
+      if (!headingMatch) {
+        return buildRawText(mutation);
+      }
+      const headingText = headingMatch[1].trim();
+      const sectionId = resolveSectionId(headingText);
+      const heading = `## ${headingText}`;
+      const newlineIdx = mutation.newText.indexOf("\n");
+      const content = newlineIdx >= 0 ? mutation.newText.slice(newlineIdx + 1).trim() : "";
+      const nextOrder = ir.sections.length;
+      return {
+        type: "add_section",
+        section: createSection(sectionId, heading, content, nextOrder),
+        rationale: mutation.rationale
+      };
+    }
+    case "delete_section": {
+      if (mutation.oldText === void 0) {
+        return buildRawText(mutation);
+      }
+      const section = findSectionContaining(ir, mutation.oldText);
+      if (!section) {
+        return buildRawText(mutation);
+      }
+      return {
+        type: "remove_section",
+        sectionId: section.id,
+        rationale: mutation.rationale
+      };
+    }
+    default:
+      return buildRawText(mutation);
+  }
+}
+function translateCommandMutation(mutation, name) {
+  switch (mutation.action) {
+    case "create_file":
+      return {
+        type: "add_command",
+        command: createCommandNode(name, mutation.newText),
+        rationale: mutation.rationale
+      };
+    case "delete_file":
+      return {
+        type: "remove_command",
+        name,
+        rationale: mutation.rationale
+      };
+    case "replace":
+      return {
+        type: "update_command",
+        name,
+        content: mutation.newText,
+        rationale: mutation.rationale
+      };
+    default:
+      return buildRawText(mutation);
+  }
+}
+function translateRuleMutation(mutation, name) {
+  switch (mutation.action) {
+    case "create_file":
+      return {
+        type: "add_rule",
+        rule: createRuleNode(name, mutation.newText),
+        rationale: mutation.rationale
+      };
+    case "delete_file":
+      return {
+        type: "remove_rule",
+        name,
+        rationale: mutation.rationale
+      };
+    case "replace":
+      return {
+        type: "update_rule",
+        name,
+        content: mutation.newText,
+        rationale: mutation.rationale
+      };
+    default:
+      return buildRawText(mutation);
+  }
+}
+function translateAgentMutation(mutation, name) {
+  switch (mutation.action) {
+    case "create_file":
+      return {
+        type: "add_agent",
+        agent: createAgentNode(name, mutation.newText),
+        rationale: mutation.rationale
+      };
+    case "delete_file":
+      return {
+        type: "remove_agent",
+        name,
+        rationale: mutation.rationale
+      };
+    case "replace":
+      return {
+        type: "update_agent",
+        name,
+        changes: { content: mutation.newText },
+        rationale: mutation.rationale
+      };
+    default:
+      return buildRawText(mutation);
+  }
+}
+function buildRawText(mutation) {
+  return {
+    type: "raw_text",
+    file: mutation.file,
+    action: mutation.action,
+    oldText: mutation.oldText,
+    newText: mutation.newText,
+    rationale: mutation.rationale
+  };
+}
+function translateMutation(mutation, ir) {
+  if (mutation.file === "CLAUDE.md") {
+    return translateClaudeMdMutation(mutation, ir);
+  }
+  const commandName = extractName(mutation.file, COMMANDS_PATH_RE);
+  if (commandName !== null) {
+    return translateCommandMutation(mutation, commandName);
+  }
+  const ruleName = extractName(mutation.file, RULES_PATH_RE);
+  if (ruleName !== null) {
+    return translateRuleMutation(mutation, ruleName);
+  }
+  const agentName = extractName(mutation.file, AGENTS_PATH_RE);
+  if (agentName !== null) {
+    return translateAgentMutation(mutation, agentName);
+  }
+  return buildRawText(mutation);
+}
+function translateMutations(mutations, ir) {
+  return mutations.map((m) => translateMutation(m, ir));
+}
+var COMMANDS_PATH_RE, RULES_PATH_RE, AGENTS_PATH_RE;
+var init_translate = __esm({
+  "src/ir/translate.ts"() {
+    "use strict";
+    init_types();
+    init_parser();
+    COMMANDS_PATH_RE = /^commands\/([^/]+?)(?:\.md)?$/;
+    RULES_PATH_RE = /^rules\/([^/]+?)(?:\.md)?$/;
+    AGENTS_PATH_RE = /^agents\/([^/]+?)(?:\.md)?$/;
+  }
+});
+
+// src/ir/mutations.ts
+function sectionExists(ir, id) {
+  return ir.sections.some((s) => s.id === id);
+}
+function commandExists(ir, name) {
+  return ir.commands.some((c) => c.name === name);
+}
+function ruleExists(ir, name) {
+  return ir.rules.some((r) => r.name === name);
+}
+function agentExists(ir, name) {
+  return ir.agents.some((a) => a.name === name);
+}
+function mcpServerExists(ir, id) {
+  return ir.mcpServers.some((s) => s.id === id);
+}
+function deepSet(obj, segments, value) {
+  if (segments.length === 0) return obj;
+  const [head, ...rest] = segments;
+  if (rest.length === 0) {
+    return { ...obj, [head]: value };
+  }
+  const existing = obj[head];
+  const child = existing !== null && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+  return { ...obj, [head]: deepSet(child, rest, value) };
+}
+function applySettingsUpdate(settings, path31, value) {
+  const segments = path31.split(".");
+  const topKey = segments[0];
+  if (STRUCTURED_SETTINGS_KEYS.has(topKey)) {
+    const settingsRecord = { ...settings };
+    const updated = deepSet(settingsRecord, segments, value);
+    return {
+      ...settings,
+      ...updated,
+      // Preserve raw as-is (deepSet may have overwritten it if path happened to be "raw")
+      raw: settings.raw
+    };
+  }
+  const updatedRaw = deepSet({ ...settings.raw }, segments, value);
+  return {
+    ...settings,
+    raw: updatedRaw
+  };
+}
+function applyIRMutation(ir, mutation) {
+  switch (mutation.type) {
+    // -- Sections ----------------------------------------------------------
+    case "update_section": {
+      if (!sectionExists(ir, mutation.sectionId)) {
+        throw new Error(`Section '${mutation.sectionId}' not found`);
+      }
+      return {
+        ...ir,
+        sections: ir.sections.map(
+          (s) => s.id === mutation.sectionId ? { ...s, content: mutation.content } : s
+        )
+      };
+    }
+    case "add_section": {
+      if (sectionExists(ir, mutation.section.id)) {
+        throw new Error(`Section '${mutation.section.id}' already exists`);
+      }
+      return {
+        ...ir,
+        sections: [...ir.sections, { ...mutation.section }]
+      };
+    }
+    case "remove_section": {
+      if (!sectionExists(ir, mutation.sectionId)) {
+        throw new Error(`Section '${mutation.sectionId}' not found`);
+      }
+      return {
+        ...ir,
+        sections: ir.sections.filter((s) => s.id !== mutation.sectionId)
+      };
+    }
+    case "reorder_section": {
+      if (!sectionExists(ir, mutation.sectionId)) {
+        throw new Error(`Section '${mutation.sectionId}' not found`);
+      }
+      return {
+        ...ir,
+        sections: ir.sections.map(
+          (s) => s.id === mutation.sectionId ? { ...s, order: mutation.newOrder } : s
+        )
+      };
+    }
+    // -- Commands ----------------------------------------------------------
+    case "add_command": {
+      if (commandExists(ir, mutation.command.name)) {
+        throw new Error(`Command '${mutation.command.name}' already exists`);
+      }
+      return {
+        ...ir,
+        commands: [...ir.commands, { ...mutation.command }]
+      };
+    }
+    case "update_command": {
+      if (!commandExists(ir, mutation.name)) {
+        throw new Error(`Command '${mutation.name}' not found`);
+      }
+      return {
+        ...ir,
+        commands: ir.commands.map(
+          (c) => c.name === mutation.name ? { ...c, content: mutation.content } : c
+        )
+      };
+    }
+    case "remove_command": {
+      if (!commandExists(ir, mutation.name)) {
+        throw new Error(`Command '${mutation.name}' not found`);
+      }
+      return {
+        ...ir,
+        commands: ir.commands.filter((c) => c.name !== mutation.name)
+      };
+    }
+    // -- Rules -------------------------------------------------------------
+    case "add_rule": {
+      if (ruleExists(ir, mutation.rule.name)) {
+        throw new Error(`Rule '${mutation.rule.name}' already exists`);
+      }
+      return {
+        ...ir,
+        rules: [...ir.rules, { ...mutation.rule }]
+      };
+    }
+    case "update_rule": {
+      if (!ruleExists(ir, mutation.name)) {
+        throw new Error(`Rule '${mutation.name}' not found`);
+      }
+      return {
+        ...ir,
+        rules: ir.rules.map(
+          (r) => r.name === mutation.name ? { ...r, content: mutation.content } : r
+        )
+      };
+    }
+    case "remove_rule": {
+      if (!ruleExists(ir, mutation.name)) {
+        throw new Error(`Rule '${mutation.name}' not found`);
+      }
+      return {
+        ...ir,
+        rules: ir.rules.filter((r) => r.name !== mutation.name)
+      };
+    }
+    // -- Agents ------------------------------------------------------------
+    case "add_agent": {
+      if (agentExists(ir, mutation.agent.name)) {
+        throw new Error(`Agent '${mutation.agent.name}' already exists`);
+      }
+      return {
+        ...ir,
+        agents: [...ir.agents, { ...mutation.agent }]
+      };
+    }
+    case "update_agent": {
+      if (!agentExists(ir, mutation.name)) {
+        throw new Error(`Agent '${mutation.name}' not found`);
+      }
+      return {
+        ...ir,
+        agents: ir.agents.map(
+          (a) => a.name === mutation.name ? { ...a, ...mutation.changes } : a
+        )
+      };
+    }
+    case "remove_agent": {
+      if (!agentExists(ir, mutation.name)) {
+        throw new Error(`Agent '${mutation.name}' not found`);
+      }
+      return {
+        ...ir,
+        agents: ir.agents.filter((a) => a.name !== mutation.name)
+      };
+    }
+    // -- MCP Servers -------------------------------------------------------
+    case "add_mcp_server": {
+      if (mcpServerExists(ir, mutation.server.id)) {
+        throw new Error(`MCP server '${mutation.server.id}' already exists`);
+      }
+      return {
+        ...ir,
+        mcpServers: [...ir.mcpServers, { ...mutation.server }]
+      };
+    }
+    case "remove_mcp_server": {
+      if (!mcpServerExists(ir, mutation.id)) {
+        throw new Error(`MCP server '${mutation.id}' not found`);
+      }
+      return {
+        ...ir,
+        mcpServers: ir.mcpServers.filter((s) => s.id !== mutation.id)
+      };
+    }
+    // -- Settings ----------------------------------------------------------
+    case "update_settings": {
+      return {
+        ...ir,
+        settings: applySettingsUpdate(ir.settings, mutation.path, mutation.value)
+      };
+    }
+    // -- Raw text (legacy fallback) ----------------------------------------
+    case "raw_text": {
+      console.warn(
+        "raw_text mutation is a legacy fallback \u2014 the text operation will be applied during rendering"
+      );
+      return { ...ir };
+    }
+  }
+}
+var STRUCTURED_SETTINGS_KEYS;
+var init_mutations = __esm({
+  "src/ir/mutations.ts"() {
+    "use strict";
+    STRUCTURED_SETTINGS_KEYS = /* @__PURE__ */ new Set(["statusLine", "hooks", "denyPatterns"]);
+  }
+});
+
+// src/ir/renderer.ts
+function renderClaudeMd(_meta, sections) {
+  const sorted = [...sections].sort((a, b) => a.order - b.order);
+  const blocks = [];
+  for (const section of sorted) {
+    if (section.heading && section.content) {
+      blocks.push(`${section.heading}
+
+${section.content}`);
+    } else if (section.heading) {
+      blocks.push(section.heading);
+    } else if (section.content) {
+      blocks.push(section.content);
+    }
+  }
+  if (blocks.length === 0) {
+    return "\n";
+  }
+  return blocks.join("\n\n") + "\n";
+}
+function renderSettings(settings) {
+  const result = JSON.parse(
+    JSON.stringify(settings.raw)
+  );
+  if (settings.denyPatterns && settings.denyPatterns.length > 0) {
+    const permissions = result["permissions"] ?? {};
+    permissions["deny"] = settings.denyPatterns;
+    result["permissions"] = permissions;
+  }
+  if (settings.statusLine) {
+    result["statusLine"] = settings.statusLine;
+  }
+  const hookEvents = [
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "SessionStart",
+    "PostCompact"
+  ];
+  const hooksObj = {};
+  let hasHooks = false;
+  for (const event of hookEvents) {
+    const entries = settings.hooks[event];
+    if (entries && entries.length > 0) {
+      hooksObj[event] = entries;
+      hasHooks = true;
+    }
+  }
+  if (hasHooks) {
+    result["hooks"] = hooksObj;
+  }
+  return JSON.stringify(result, null, 2) + "\n";
+}
+function renderMcpConfig(servers) {
+  if (servers.length === 0) {
+    return "";
+  }
+  const mcpServers = {};
+  for (const server of servers) {
+    const entry = {
+      command: server.command,
+      args: server.args
+    };
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry["env"] = server.env;
+    }
+    mcpServers[server.id] = entry;
+  }
+  return JSON.stringify({ mcpServers }, null, 2) + "\n";
+}
+function renderRuleWithFrontmatter(rule) {
+  if (!rule.paths || rule.paths.length === 0) {
+    return rule.content;
+  }
+  const yamlLines = ["---", "paths:"];
+  for (const p of rule.paths) {
+    yamlLines.push(`  - ${p}`);
+  }
+  yamlLines.push("---");
+  return yamlLines.join("\n") + "\n\n" + rule.content;
+}
+function renderAgentWithFrontmatter(agent) {
+  const hasModel = agent.model !== void 0;
+  const hasDisallowed = agent.disallowedTools !== void 0 && agent.disallowedTools.length > 0;
+  if (!hasModel && !hasDisallowed) {
+    return agent.content;
+  }
+  const yamlLines = ["---"];
+  if (hasModel) {
+    yamlLines.push(`model: ${agent.model}`);
+  }
+  if (hasDisallowed) {
+    yamlLines.push("disallowedTools:");
+    for (const tool of agent.disallowedTools) {
+      yamlLines.push(`  - ${tool}`);
+    }
+  }
+  yamlLines.push("---");
+  return yamlLines.join("\n") + "\n\n" + agent.content;
+}
+function settingsHasContent(settings) {
+  if (settings.statusLine) return true;
+  if (settings.denyPatterns && settings.denyPatterns.length > 0) return true;
+  if (Object.keys(settings.raw).length > 0) return true;
+  const hookEvents = [
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "SessionStart",
+    "PostCompact"
+  ];
+  for (const event of hookEvents) {
+    const entries = settings.hooks[event];
+    if (entries && entries.length > 0) return true;
+  }
+  return false;
+}
+function renderHarness(ir) {
+  const files = /* @__PURE__ */ new Map();
+  if (ir.sections.length > 0 || ir.meta.name) {
+    files.set("CLAUDE.md", renderClaudeMd(ir.meta, ir.sections));
+  }
+  if (settingsHasContent(ir.settings)) {
+    files.set("settings.json", renderSettings(ir.settings));
+  }
+  for (const cmd of ir.commands) {
+    files.set(`commands/${cmd.name}.md`, cmd.content);
+  }
+  for (const rule of ir.rules) {
+    files.set(`rules/${rule.name}.md`, renderRuleWithFrontmatter(rule));
+  }
+  for (const agent of ir.agents) {
+    files.set(`agents/${agent.name}.md`, renderAgentWithFrontmatter(agent));
+  }
+  for (const skill of ir.skills) {
+    files.set(`skills/${skill.name}.md`, skill.content);
+  }
+  for (const doc of ir.docs) {
+    files.set(`docs/${doc.name}.md`, doc.content);
+  }
+  for (const hook of ir.hooks) {
+    files.set(`hooks/${hook.name}.mjs`, hook.content);
+  }
+  const mcpContent = renderMcpConfig(ir.mcpServers);
+  if (mcpContent) {
+    files.set(".mcp.json", mcpContent);
+  }
+  return files;
+}
+var init_renderer = __esm({
+  "src/ir/renderer.ts"() {
+    "use strict";
+  }
+});
+
+// src/ir/diff.ts
+function diffIR(before, after) {
+  const diff = createEmptyDiff();
+  diffSections(before.sections, after.sections, diff);
+  diffByName(before.commands, after.commands, diff.commands);
+  diffByName(before.rules, after.rules, diff.rules);
+  diffAgents(before.agents, after.agents, diff);
+  diffMcpServers(before.mcpServers, after.mcpServers, diff);
+  diffSettings(before.settings, after.settings, diff);
+  return diff;
+}
+function formatIRDiff(diff) {
+  const blocks = [];
+  const sectionLines = formatSectionBlock(diff);
+  if (sectionLines.length > 0) {
+    blocks.push(["Sections:", ...sectionLines].join("\n"));
+  }
+  const commandLines = formatNamedBlock(diff.commands, "commands");
+  if (commandLines.length > 0) {
+    blocks.push(["Commands:", ...commandLines].join("\n"));
+  }
+  const ruleLines = formatNamedBlock(diff.rules, "rules");
+  if (ruleLines.length > 0) {
+    blocks.push(["Rules:", ...ruleLines].join("\n"));
+  }
+  const agentLines = formatAgentBlock(diff);
+  if (agentLines.length > 0) {
+    blocks.push(["Agents:", ...agentLines].join("\n"));
+  }
+  const mcpLines = formatMcpBlock(diff);
+  if (mcpLines.length > 0) {
+    blocks.push(["MCP Servers:", ...mcpLines].join("\n"));
+  }
+  const settingsLines = formatSettingsBlock(diff);
+  if (settingsLines.length > 0) {
+    blocks.push(["Settings:", ...settingsLines].join("\n"));
+  }
+  if (blocks.length === 0) {
+    return "No changes.";
+  }
+  return blocks.join("\n\n");
+}
+function diffSections(beforeList, afterList, diff) {
+  const beforeMap = /* @__PURE__ */ new Map();
+  for (const s of beforeList) {
+    beforeMap.set(s.id, s);
+  }
+  const afterMap = /* @__PURE__ */ new Map();
+  for (const s of afterList) {
+    afterMap.set(s.id, s);
+  }
+  for (const s of afterList) {
+    if (!beforeMap.has(s.id)) {
+      diff.sections.added.push(s);
+    }
+  }
+  for (const s of beforeList) {
+    if (!afterMap.has(s.id)) {
+      diff.sections.removed.push(s);
+    }
+  }
+  for (const [id, afterSection] of afterMap) {
+    const beforeSection = beforeMap.get(id);
+    if (beforeSection === void 0) continue;
+    if (beforeSection.content !== afterSection.content) {
+      diff.sections.modified.push({
+        id,
+        before: beforeSection.content,
+        after: afterSection.content
+      });
+    }
+    if (beforeSection.order !== afterSection.order) {
+      diff.sections.reordered.push({
+        id,
+        oldOrder: beforeSection.order,
+        newOrder: afterSection.order
+      });
+    }
+  }
+}
+function diffByName(beforeList, afterList, target) {
+  const beforeMap = /* @__PURE__ */ new Map();
+  for (const n of beforeList) {
+    beforeMap.set(n.name, n);
+  }
+  const afterMap = /* @__PURE__ */ new Map();
+  for (const n of afterList) {
+    afterMap.set(n.name, n);
+  }
+  for (const n of afterList) {
+    if (!beforeMap.has(n.name)) {
+      target.added.push(n);
+    }
+  }
+  for (const n of beforeList) {
+    if (!afterMap.has(n.name)) {
+      target.removed.push(n.name);
+    }
+  }
+  for (const [name, afterNode] of afterMap) {
+    const beforeNode = beforeMap.get(name);
+    if (beforeNode === void 0) continue;
+    if (beforeNode.content !== afterNode.content) {
+      target.modified.push({
+        name,
+        before: beforeNode.content,
+        after: afterNode.content
+      });
+    }
+  }
+}
+function diffAgents(beforeList, afterList, diff) {
+  const beforeMap = /* @__PURE__ */ new Map();
+  for (const a of beforeList) {
+    beforeMap.set(a.name, a);
+  }
+  const afterMap = /* @__PURE__ */ new Map();
+  for (const a of afterList) {
+    afterMap.set(a.name, a);
+  }
+  for (const a of afterList) {
+    if (!beforeMap.has(a.name)) {
+      diff.agents.added.push(a);
+    }
+  }
+  for (const a of beforeList) {
+    if (!afterMap.has(a.name)) {
+      diff.agents.removed.push(a.name);
+    }
+  }
+  for (const [name, afterAgent] of afterMap) {
+    const beforeAgent = beforeMap.get(name);
+    if (beforeAgent === void 0) continue;
+    const changeParts = [];
+    if (beforeAgent.model !== afterAgent.model) {
+      const from = beforeAgent.model ?? "none";
+      const to = afterAgent.model ?? "none";
+      changeParts.push(`model changed from ${from} to ${to}`);
+    }
+    if (beforeAgent.content !== afterAgent.content) {
+      changeParts.push("content updated");
+    }
+    const beforeTools = JSON.stringify(beforeAgent.disallowedTools ?? []);
+    const afterTools = JSON.stringify(afterAgent.disallowedTools ?? []);
+    if (beforeTools !== afterTools) {
+      changeParts.push("disallowedTools changed");
+    }
+    if (changeParts.length > 0) {
+      diff.agents.modified.push({
+        name,
+        changes: changeParts.join("; ")
+      });
+    }
+  }
+}
+function diffMcpServers(beforeList, afterList, diff) {
+  const beforeIds = new Set(beforeList.map((s) => s.id));
+  const afterIds = new Set(afterList.map((s) => s.id));
+  for (const s of afterList) {
+    if (!beforeIds.has(s.id)) {
+      diff.mcpServers.added.push(s);
+    }
+  }
+  for (const s of beforeList) {
+    if (!afterIds.has(s.id)) {
+      diff.mcpServers.removed.push(s.id);
+    }
+  }
+}
+function diffSettings(before, after, diff) {
+  if (!deepEqual(before.statusLine, after.statusLine)) {
+    diff.settings.changes.push({
+      path: "statusLine",
+      before: before.statusLine,
+      after: after.statusLine
+    });
+  }
+  if (!deepEqual(before.denyPatterns, after.denyPatterns)) {
+    diff.settings.changes.push({
+      path: "denyPatterns",
+      before: before.denyPatterns,
+      after: after.denyPatterns
+    });
+  }
+  if (!deepEqual(before.hooks, after.hooks)) {
+    diff.settings.changes.push({
+      path: "hooks",
+      before: before.hooks,
+      after: after.hooks
+    });
+  }
+}
+function formatSectionBlock(diff) {
+  const lines = [];
+  for (const s of diff.sections.added) {
+    lines.push(`  + Added: ${s.heading}`);
+  }
+  for (const s of diff.sections.removed) {
+    lines.push(`  - Removed: ${s.heading}`);
+  }
+  for (const m of diff.sections.modified) {
+    lines.push(`  ~ Modified: ${m.id} (content changed)`);
+  }
+  for (const r of diff.sections.reordered) {
+    lines.push(
+      `  \u2195 Reordered: ${r.id} (${r.oldOrder} \u2192 ${r.newOrder})`
+    );
+  }
+  return lines;
+}
+function formatNamedBlock(bucket, _category) {
+  const lines = [];
+  for (const n of bucket.added) {
+    lines.push(`  + Added: ${n.name}`);
+  }
+  for (const name of bucket.removed) {
+    lines.push(`  - Removed: ${name}`);
+  }
+  for (const m of bucket.modified) {
+    lines.push(`  ~ Modified: ${m.name} (content changed)`);
+  }
+  return lines;
+}
+function formatAgentBlock(diff) {
+  const lines = [];
+  for (const a of diff.agents.added) {
+    lines.push(`  + Added: ${a.name}`);
+  }
+  for (const name of diff.agents.removed) {
+    lines.push(`  - Removed: ${name}`);
+  }
+  for (const m of diff.agents.modified) {
+    lines.push(`  ~ Modified: ${m.name} (${m.changes})`);
+  }
+  return lines;
+}
+function formatMcpBlock(diff) {
+  const lines = [];
+  for (const s of diff.mcpServers.added) {
+    lines.push(`  + Added: ${s.id}`);
+  }
+  for (const id of diff.mcpServers.removed) {
+    lines.push(`  - Removed: ${id}`);
+  }
+  return lines;
+}
+function formatSettingsBlock(diff) {
+  const lines = [];
+  for (const c of diff.settings.changes) {
+    lines.push(`  ~ ${c.path} changed`);
+  }
+  return lines;
+}
+function deepEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+var init_diff = __esm({
+  "src/ir/diff.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
 // src/evolve/mutator.ts
-import fs21 from "fs/promises";
-import path21 from "path";
+import fs22 from "fs/promises";
+import path22 from "path";
 async function applyMutations(currentHarnessPath, nextIterationDir, mutations) {
-  const newHarnessPath = path21.join(nextIterationDir, "harness");
+  const newHarnessPath = path22.join(nextIterationDir, "harness");
+  let baselineIR = null;
+  try {
+    baselineIR = await parseHarness(currentHarnessPath);
+  } catch {
+  }
+  if (baselineIR !== null) {
+    return applyMutationsViaIR(
+      currentHarnessPath,
+      newHarnessPath,
+      mutations,
+      baselineIR
+    );
+  }
+  return applyMutationsLegacy(currentHarnessPath, newHarnessPath, mutations);
+}
+async function applyMutationsViaIR(currentHarnessPath, newHarnessPath, mutations, baselineIR) {
   await copyDir(currentHarnessPath, newHarnessPath);
-  for (const mutation of mutations) {
-    if (mutation.file.includes("..")) {
+  const irMutations = translateMutations(mutations, baselineIR);
+  let currentIR = baselineIR;
+  const rawTextMutations = [];
+  const touchedCategories = /* @__PURE__ */ new Set();
+  for (let i = 0; i < irMutations.length; i++) {
+    const irMut = irMutations[i];
+    if (irMut.type === "raw_text") {
+      rawTextMutations.push(mutations[i]);
       continue;
     }
-    const filePath = path21.join(newHarnessPath, mutation.file);
-    if (mutation.action === "replace") {
-      if (!mutation.oldText) {
-        continue;
-      }
-      const content = await fs21.readFile(filePath, "utf-8");
-      if (!content.includes(mutation.oldText)) {
-        continue;
-      }
-      await fs21.writeFile(
+    try {
+      currentIR = applyIRMutation(currentIR, irMut);
+      touchedCategories.add(getMutationCategory(irMut.type));
+    } catch {
+      continue;
+    }
+  }
+  if (touchedCategories.size > 0) {
+    await renderAffectedFiles(currentIR, newHarnessPath, touchedCategories);
+  }
+  for (const mutation of rawTextMutations) {
+    await applyLegacyMutation(newHarnessPath, mutation);
+  }
+  const irDiff = diffIR(baselineIR, currentIR);
+  let diffPatch = formatIRDiff(irDiff);
+  if (diffPatch === "No changes." && rawTextMutations.length > 0) {
+    diffPatch = await generateDiffLegacy(currentHarnessPath, newHarnessPath);
+  }
+  if (diffPatch === "No changes.") {
+    diffPatch = "";
+  }
+  return { newHarnessPath, diffPatch };
+}
+function getMutationCategory(mutationType) {
+  if (mutationType.includes("section") || mutationType.includes("reorder")) {
+    return "claude_md";
+  }
+  if (mutationType.includes("command")) {
+    return "commands";
+  }
+  if (mutationType.includes("rule")) {
+    return "rules";
+  }
+  if (mutationType.includes("agent")) {
+    return "agents";
+  }
+  if (mutationType.includes("mcp")) {
+    return "mcp";
+  }
+  if (mutationType.includes("settings")) {
+    return "settings";
+  }
+  return "unknown";
+}
+async function renderAffectedFiles(ir, targetDir, touchedCategories) {
+  const fileMap = renderHarness(ir);
+  for (const [relativePath, content] of fileMap) {
+    const category = getFileCategory(relativePath);
+    if (touchedCategories.has(category)) {
+      const fullPath = path22.join(targetDir, relativePath);
+      await fs22.mkdir(path22.dirname(fullPath), { recursive: true });
+      await fs22.writeFile(fullPath, content, "utf-8");
+    }
+  }
+  if (touchedCategories.has("commands")) {
+    await deleteOrphanedFiles(targetDir, "commands", fileMap);
+  }
+  if (touchedCategories.has("rules")) {
+    await deleteOrphanedFiles(targetDir, "rules", fileMap);
+  }
+  if (touchedCategories.has("agents")) {
+    await deleteOrphanedFiles(targetDir, "agents", fileMap);
+  }
+}
+function getFileCategory(relativePath) {
+  if (relativePath === "CLAUDE.md") return "claude_md";
+  if (relativePath.startsWith("commands/")) return "commands";
+  if (relativePath.startsWith("rules/")) return "rules";
+  if (relativePath.startsWith("agents/")) return "agents";
+  if (relativePath.startsWith("skills/")) return "skills";
+  if (relativePath.startsWith("docs/")) return "docs";
+  if (relativePath.startsWith("hooks/")) return "hooks";
+  if (relativePath === "settings.json") return "settings";
+  if (relativePath === ".mcp.json") return "mcp";
+  return "unknown";
+}
+async function deleteOrphanedFiles(targetDir, subdir, renderedMap) {
+  const subdirPath = path22.join(targetDir, subdir);
+  let entries;
+  try {
+    entries = await fs22.readdir(subdirPath);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const relativePath = `${subdir}/${entry}`;
+    if (!renderedMap.has(relativePath)) {
+      await fs22.unlink(path22.join(subdirPath, entry)).catch(() => {
+      });
+    }
+  }
+}
+async function applyMutationsLegacy(currentHarnessPath, newHarnessPath, mutations) {
+  await copyDir(currentHarnessPath, newHarnessPath);
+  for (const mutation of mutations) {
+    await applyLegacyMutation(newHarnessPath, mutation);
+  }
+  const diffPatch = await generateDiffLegacy(currentHarnessPath, newHarnessPath);
+  return { newHarnessPath, diffPatch };
+}
+async function applyLegacyMutation(harnessPath, mutation) {
+  if (mutation.file.includes("..")) {
+    return;
+  }
+  const filePath = path22.join(harnessPath, mutation.file);
+  if (mutation.action === "replace") {
+    if (!mutation.oldText) {
+      return;
+    }
+    let content;
+    try {
+      content = await fs22.readFile(filePath, "utf-8");
+    } catch {
+      return;
+    }
+    if (!content.includes(mutation.oldText)) {
+      return;
+    }
+    await fs22.writeFile(
+      filePath,
+      content.replace(mutation.oldText, mutation.newText),
+      "utf-8"
+    );
+  } else if (mutation.action === "add_section") {
+    try {
+      const content = await fs22.readFile(filePath, "utf-8");
+      await fs22.writeFile(
         filePath,
-        content.replace(mutation.oldText, mutation.newText),
+        content + "\n\n" + mutation.newText,
         "utf-8"
       );
-    } else if (mutation.action === "add_section") {
-      try {
-        const content = await fs21.readFile(filePath, "utf-8");
-        await fs21.writeFile(
-          filePath,
-          content + "\n\n" + mutation.newText,
-          "utf-8"
-        );
-      } catch {
-        await fs21.mkdir(path21.dirname(filePath), { recursive: true });
-        await fs21.writeFile(filePath, mutation.newText, "utf-8");
-      }
-    } else if (mutation.action === "create_file") {
-      await fs21.mkdir(path21.dirname(filePath), { recursive: true });
-      await fs21.writeFile(filePath, mutation.newText, "utf-8");
-    } else if (mutation.action === "delete_section") {
-      if (!mutation.oldText) {
-        continue;
-      }
-      let sectionContent;
-      try {
-        sectionContent = await fs21.readFile(filePath, "utf-8");
-      } catch {
-        continue;
+    } catch {
+      await fs22.mkdir(path22.dirname(filePath), { recursive: true });
+      await fs22.writeFile(filePath, mutation.newText, "utf-8");
+    }
+  } else if (mutation.action === "create_file") {
+    await fs22.mkdir(path22.dirname(filePath), { recursive: true });
+    await fs22.writeFile(filePath, mutation.newText, "utf-8");
+  } else if (mutation.action === "delete_section") {
+    if (!mutation.oldText) {
+      return;
+    }
+    let sectionContent;
+    try {
+      sectionContent = await fs22.readFile(filePath, "utf-8");
+    } catch {
+      return;
+    }
+    if (!sectionContent.includes(mutation.oldText)) {
+      return;
+    }
+    await fs22.writeFile(filePath, sectionContent.replace(mutation.oldText, ""), "utf-8");
+  } else if (mutation.action === "delete_file") {
+    await fs22.unlink(filePath).catch(() => {
+    });
+  }
+}
+async function generateDiff2(oldDir, newDir) {
+  try {
+    const oldIR = await parseHarness(oldDir);
+    const newIR = await parseHarness(newDir);
+    const oldHasContent = oldIR.sections.length > 0 || oldIR.commands.length > 0 || oldIR.rules.length > 0 || oldIR.agents.length > 0;
+    const newHasContent = newIR.sections.length > 0 || newIR.commands.length > 0 || newIR.rules.length > 0 || newIR.agents.length > 0;
+    if (oldHasContent || newHasContent) {
+      const irDiff = diffIR(oldIR, newIR);
+      const formatted = formatIRDiff(irDiff);
+      if (formatted === "No changes.") {
+        const legacyDiff2 = await generateDiffLegacy(oldDir, newDir);
+        return legacyDiff2;
       }
-      if (!sectionContent.includes(mutation.oldText)) {
-        continue;
+      const legacyDiff = await generateDiffLegacy(oldDir, newDir);
+      if (legacyDiff && !formatted.includes(legacyDiff)) {
+        return formatted + "\n\n" + legacyDiff;
       }
-      await fs21.writeFile(filePath, sectionContent.replace(mutation.oldText, ""), "utf-8");
-    } else if (mutation.action === "delete_file") {
-      await fs21.unlink(filePath).catch(() => {
-      });
+      return formatted;
     }
+  } catch {
   }
-  const diffPatch = await generateDiff2(currentHarnessPath, newHarnessPath);
-  return { newHarnessPath, diffPatch };
+  return generateDiffLegacy(oldDir, newDir);
 }
-async function generateDiff2(oldDir, newDir) {
+async function generateDiffLegacy(oldDir, newDir) {
   const oldFiles = await readAllFiles(oldDir);
   const newFiles = await readAllFiles(newDir);
   const allPaths = /* @__PURE__ */ new Set([
@@ -1511,17 +3032,17 @@ async function readAllFiles(dir) {
   async function walk(current) {
     let entries;
     try {
-      entries = await fs21.readdir(current, { withFileTypes: true });
+      entries = await fs22.readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path21.join(current, entry.name);
-      const relativePath = path21.relative(dir, fullPath);
+      const fullPath = path22.join(current, entry.name);
+      const relativePath = path22.relative(dir, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
-        result[relativePath] = await fs21.readFile(fullPath, "utf-8");
+        result[relativePath] = await fs22.readFile(fullPath, "utf-8");
       }
     }
   }
@@ -1532,12 +3053,17 @@ var init_mutator = __esm({
   "src/evolve/mutator.ts"() {
     "use strict";
     init_baseline();
+    init_parser();
+    init_translate();
+    init_mutations();
+    init_renderer();
+    init_diff();
   }
 });
 
 // src/evolve/sampling.ts
-import fs22 from "fs/promises";
-import path22 from "path";
+import fs23 from "fs/promises";
+import path23 from "path";
 function initBeliefs(tasks) {
   return tasks.map((task) => ({
     taskId: task.id,
@@ -1598,9 +3124,9 @@ function updateBeliefs(beliefs, results) {
   });
 }
 async function loadBeliefs(workspacePath) {
-  const beliefsPath = path22.join(workspacePath, "task-beliefs.json");
+  const beliefsPath = path23.join(workspacePath, "task-beliefs.json");
   try {
-    const content = await fs22.readFile(beliefsPath, "utf-8");
+    const content = await fs23.readFile(beliefsPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed)) return null;
     for (const entry of parsed) {
@@ -1614,9 +3140,9 @@ async function loadBeliefs(workspacePath) {
   }
 }
 async function saveBeliefs(workspacePath, beliefs) {
-  const beliefsPath = path22.join(workspacePath, "task-beliefs.json");
-  await fs22.mkdir(path22.dirname(beliefsPath), { recursive: true });
-  await fs22.writeFile(beliefsPath, JSON.stringify(beliefs, null, 2), "utf-8");
+  const beliefsPath = path23.join(workspacePath, "task-beliefs.json");
+  await fs23.mkdir(path23.dirname(beliefsPath), { recursive: true });
+  await fs23.writeFile(beliefsPath, JSON.stringify(beliefs, null, 2), "utf-8");
 }
 var init_sampling = __esm({
   "src/evolve/sampling.ts"() {
@@ -1625,8 +3151,8 @@ var init_sampling = __esm({
 });
 
 // src/evolve/regularization.ts
-import fs23 from "fs/promises";
-import path23 from "path";
+import fs24 from "fs/promises";
+import path24 from "path";
 async function measureComplexity(harnessPath) {
   let totalLines = 0;
   let totalFiles = 0;
@@ -1657,6 +3183,64 @@ async function measureComplexity(harnessPath) {
     diffFromBaseline: 0
   };
 }
+function measureComplexityFromIR(ir) {
+  const totalSections = ir.sections.length;
+  const totalRules = ir.rules.length;
+  const totalCommands = ir.commands.length;
+  let totalFiles = 0;
+  if (ir.sections.length > 0 || ir.meta.name) {
+    totalFiles += 1;
+  }
+  totalFiles += ir.commands.length;
+  totalFiles += ir.rules.length;
+  totalFiles += ir.agents.length;
+  totalFiles += ir.skills.length;
+  totalFiles += ir.docs.length;
+  totalFiles += ir.hooks.length;
+  const hasSettings = ir.settings.statusLine !== void 0 || ir.settings.denyPatterns !== void 0 && ir.settings.denyPatterns.length > 0 || Object.keys(ir.settings.raw).length > 0 || Object.values(ir.settings.hooks).some(
+    (entries) => entries !== void 0 && entries.length > 0
+  );
+  if (hasSettings) {
+    totalFiles += 1;
+  }
+  if (ir.mcpServers.length > 0) {
+    totalFiles += 1;
+  }
+  let totalLines = 0;
+  for (const section of ir.sections) {
+    totalLines += countLines(section.content);
+  }
+  for (const cmd of ir.commands) {
+    totalLines += countLines(cmd.content);
+  }
+  for (const rule of ir.rules) {
+    totalLines += countLines(rule.content);
+  }
+  for (const agent of ir.agents) {
+    totalLines += countLines(agent.content);
+  }
+  for (const skill of ir.skills) {
+    totalLines += countLines(skill.content);
+  }
+  for (const doc of ir.docs) {
+    totalLines += countLines(doc.content);
+  }
+  for (const hook of ir.hooks) {
+    totalLines += countLines(hook.content);
+  }
+  return {
+    totalLines,
+    totalFiles,
+    totalSections,
+    totalRules,
+    totalCommands,
+    diffFromBaseline: 0
+  };
+}
+function countLines(content) {
+  if (!content) return 0;
+  return content.split("\n").length;
+}
 function computeComplexityCost(current, baseline) {
   const baselineLines = Math.max(baseline.totalLines, 1);
   const lineDelta = (current.totalLines - baseline.totalLines) / baselineLines;
@@ -1702,18 +3286,18 @@ async function readAllFilesRecursive(dir) {
   async function walk(current) {
     let entries;
     try {
-      entries = await fs23.readdir(current, { withFileTypes: true });
+      entries = await fs24.readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path23.join(current, entry.name);
-      const relativePath = path23.relative(dir, fullPath);
+      const fullPath = path24.join(current, entry.name);
+      const relativePath = path24.relative(dir, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
         try {
-          result[relativePath] = await fs23.readFile(fullPath, "utf-8");
+          result[relativePath] = await fs24.readFile(fullPath, "utf-8");
         } catch {
         }
       }
@@ -1729,8 +3313,8 @@ var init_regularization = __esm({
 });
 
 // src/evolve/loop.ts
-import fs24 from "fs/promises";
-import path24 from "path";
+import fs25 from "fs/promises";
+import path25 from "path";
 function computeMutationCap(iter, maxIterations, maxMutations) {
   if (maxIterations <= 1) return maxMutations;
   const progress = iter / (maxIterations - 1);
@@ -1747,11 +3331,17 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
   let beliefs = useThompson ? await loadBeliefs(workspacePath) ?? initBeliefs(tasks) : [];
   const useKL = evolveConfig.klLambda > 0;
   let baselineComplexity = null;
+  let baselineIR = null;
   if (useKL) {
-    const baselineHarness = path24.join(workspacePath, "iterations", "0", "harness");
+    const baselineHarness = path25.join(workspacePath, "iterations", "0", "harness");
     try {
-      baselineComplexity = await measureComplexity(baselineHarness);
+      baselineIR = await parseHarness(baselineHarness);
+      baselineComplexity = measureComplexityFromIR(baselineIR);
     } catch {
+      try {
+        baselineComplexity = await measureComplexity(baselineHarness);
+      } catch {
+      }
     }
   }
   let rngState = 42;
@@ -1760,14 +3350,14 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
     return (rngState >>> 0) / 4294967296;
   };
   for (let iter = 0; iter < evolveConfig.maxIterations; iter++) {
-    const harnessPath = path24.join(
+    const harnessPath = path25.join(
       workspacePath,
       "iterations",
       iter.toString(),
       "harness"
     );
     try {
-      await fs24.access(harnessPath);
+      await fs25.access(harnessPath);
     } catch {
       if (iter === 0) {
         throw new Error(
@@ -1851,10 +3441,16 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
     let aggregate = rawAggregate;
     let iterComplexityCost;
     if (useKL && baselineComplexity) {
-      const currentComplexity = await measureComplexity(harnessPath);
+      let currentComplexity;
+      try {
+        const iterIR = await parseHarness(harnessPath);
+        currentComplexity = measureComplexityFromIR(iterIR);
+      } catch {
+        currentComplexity = await measureComplexity(harnessPath);
+      }
       const diffRatio = await computeDiffRatio(
         harnessPath,
-        path24.join(workspacePath, "iterations", "0", "harness")
+        path25.join(workspacePath, "iterations", "0", "harness")
       );
       currentComplexity.diffFromBaseline = diffRatio;
       iterComplexityCost = computeComplexityCost(currentComplexity, baselineComplexity);
@@ -1872,7 +3468,12 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
     if (iter === 0) {
       baselineScore = aggregate;
       if (useKL && !baselineComplexity) {
-        baselineComplexity = await measureComplexity(harnessPath);
+        try {
+          baselineIR = await parseHarness(harnessPath);
+          baselineComplexity = measureComplexityFromIR(baselineIR);
+        } catch {
+          baselineComplexity = await measureComplexity(harnessPath);
+        }
       }
     }
     let shouldRollback = iter > 0 && aggregate < bestScore;
@@ -1917,7 +3518,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       };
       await writeIterationLog(workspacePath, rollbackLog);
       history.push(rollbackLog);
-      const bestHarnessPath = path24.join(
+      const bestHarnessPath = path25.join(
         workspacePath,
         "iterations",
         bestIteration.toString(),
@@ -1942,7 +3543,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
               mutations: rollbackProposal.mutations.slice(0, rollbackCap)
             };
           }
-          const nextIterDir2 = path24.join(workspacePath, "iterations", (iter + 1).toString());
+          const nextIterDir2 = path25.join(workspacePath, "iterations", (iter + 1).toString());
           await applyMutations(bestHarnessPath, nextIterDir2, rollbackProposal.mutations);
           onProgress?.({
             type: "mutations-applied",
@@ -1950,8 +3551,8 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
             mutationCount: rollbackProposal.mutations.length
           });
         } catch {
-          const nextIterDir2 = path24.join(workspacePath, "iterations", (iter + 1).toString());
-          await copyDir(bestHarnessPath, path24.join(nextIterDir2, "harness"));
+          const nextIterDir2 = path25.join(workspacePath, "iterations", (iter + 1).toString());
+          await copyDir(bestHarnessPath, path25.join(nextIterDir2, "harness"));
         }
       }
       continue;
@@ -2015,12 +3616,12 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         iteration: iter,
         message: `Proposer failed: ${errMsg}`
       });
-      const nextIterDir2 = path24.join(
+      const nextIterDir2 = path25.join(
         workspacePath,
         "iterations",
         (iter + 1).toString()
       );
-      await copyDir(harnessPath, path24.join(nextIterDir2, "harness"));
+      await copyDir(harnessPath, path25.join(nextIterDir2, "harness"));
       const skipLog = {
         iteration: iter,
         score: aggregate,
@@ -2035,7 +3636,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       history.push(skipLog);
       continue;
     }
-    const nextIterDir = path24.join(
+    const nextIterDir = path25.join(
       workspacePath,
       "iterations",
       (iter + 1).toString()
@@ -2049,7 +3650,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       );
       diffPatch = mutationResult.diffPatch;
     } catch {
-      await copyDir(harnessPath, path24.join(nextIterDir, "harness"));
+      await copyDir(harnessPath, path25.join(nextIterDir, "harness"));
     }
     onProgress?.({
       type: "mutations-applied",
@@ -2071,7 +3672,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
   }
   if (evolveConfig.usePrincipal && history.length >= 2) {
     onProgress?.({ type: "proposing", iteration: history.length, message: "Principal Proposer synthesizing final harness" });
-    const baselineHarnessPath = path24.join(workspacePath, "iterations", "0", "harness");
+    const baselineHarnessPath = path25.join(workspacePath, "iterations", "0", "harness");
     try {
       const principalProposal = await propose(
         history.length,
@@ -2086,7 +3687,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         principalProposal.mutations = principalProposal.mutations.slice(0, evolveConfig.maxMutationsPerIteration);
       }
       const principalIterNum = history.length;
-      const principalIterDir = path24.join(workspacePath, "iterations", principalIterNum.toString());
+      const principalIterDir = path25.join(workspacePath, "iterations", principalIterNum.toString());
       const mutResult = await applyMutations(baselineHarnessPath, principalIterDir, principalProposal.mutations);
       onProgress?.({ type: "iteration-start", iteration: principalIterNum });
       const { results: principalResults, aggregate: principalAggregate } = await evaluateAll(
@@ -2147,11 +3748,12 @@ var init_loop = __esm({
     init_baseline();
     init_sampling();
     init_regularization();
+    init_parser();
   }
 });
 
 // src/evolve/synthesis.ts
-import path27 from "path";
+import path28 from "path";
 function buildMetaPrincipalSystemPrompt(numBranches) {
   return `You are reviewing the COMPLETE results of ${numBranches} independent evolution runs.
 Each branch explored different mutations and saw different task subsets.
@@ -2306,7 +3908,7 @@ async function runSynthesis(context, kairnConfig, evolveConfig, workspacePath) {
     if (mutations.length === 0) {
       return null;
     }
-    const synthesisDir = path27.join(workspacePath, "synthesis");
+    const synthesisDir = path28.join(workspacePath, "synthesis");
     const { newHarnessPath } = await applyMutations(
       context.baselineHarnessPath,
       synthesisDir,
@@ -2340,26 +3942,26 @@ __export(population_exports, {
   initBranches: () => initBranches,
   runPopulation: () => runPopulation
 });
-import fs27 from "fs/promises";
-import path28 from "path";
+import fs28 from "fs/promises";
+import path29 from "path";
 async function initBranches(workspacePath, baselinePath, numBranches) {
-  const branchesDir = path28.join(workspacePath, "branches");
-  await fs27.mkdir(branchesDir, { recursive: true });
+  const branchesDir = path29.join(workspacePath, "branches");
+  await fs28.mkdir(branchesDir, { recursive: true });
   const configs = [];
   for (let i = 0; i < numBranches; i++) {
-    const branchPath = path28.join(branchesDir, i.toString());
-    const harnessPath = path28.join(branchPath, "iterations", "0", "harness");
+    const branchPath = path29.join(branchesDir, i.toString());
+    const harnessPath = path29.join(branchPath, "iterations", "0", "harness");
     await copyDir(baselinePath, harnessPath);
-    const tasksYaml = path28.join(workspacePath, "tasks.yaml");
+    const tasksYaml = path29.join(workspacePath, "tasks.yaml");
     try {
-      await fs27.access(tasksYaml);
-      await fs27.copyFile(tasksYaml, path28.join(branchPath, "tasks.yaml"));
+      await fs28.access(tasksYaml);
+      await fs28.copyFile(tasksYaml, path29.join(branchPath, "tasks.yaml"));
     } catch {
     }
-    const configYaml = path28.join(workspacePath, "config.yaml");
+    const configYaml = path29.join(workspacePath, "config.yaml");
     try {
-      await fs27.access(configYaml);
-      await fs27.copyFile(configYaml, path28.join(branchPath, "config.yaml"));
+      await fs28.access(configYaml);
+      await fs28.copyFile(configYaml, path29.join(branchPath, "config.yaml"));
     } catch {
     }
     const seed = 42 + i * 1337;
@@ -2373,7 +3975,7 @@ async function initBranches(workspacePath, baselinePath, numBranches) {
 }
 async function runPopulation(workspacePath, tasks, kairnConfig, evolveConfig, numBranches, onProgress) {
   const branches = numBranches ?? evolveConfig.pbtBranches;
-  const baselinePath = path28.join(workspacePath, "baseline");
+  const baselinePath = path29.join(workspacePath, "baseline");
   const branchConfigs = await initBranches(workspacePath, baselinePath, branches);
   const branchPromises = branchConfigs.map(async (branchConfig) => {
     const branchEvolveConfig = {
@@ -2391,7 +3993,7 @@ async function runPopulation(workspacePath, tasks, kairnConfig, evolveConfig, nu
       branchEvolveConfig,
       branchProgress
     );
-    const finalHarnessPath = path28.join(
+    const finalHarnessPath = path29.join(
       branchConfig.workspacePath,
       "iterations",
       result.bestIteration.toString(),
@@ -2399,8 +4001,8 @@ async function runPopulation(workspacePath, tasks, kairnConfig, evolveConfig, nu
     );
     let beliefs = [];
     try {
-      const beliefsPath = path28.join(branchConfig.workspacePath, "task-beliefs.json");
-      const beliefsContent = await fs27.readFile(beliefsPath, "utf-8");
+      const beliefsPath = path29.join(branchConfig.workspacePath, "task-beliefs.json");
+      const beliefsContent = await fs28.readFile(beliefsPath, "utf-8");
       beliefs = JSON.parse(beliefsContent);
     } catch {
     }
@@ -2422,7 +4024,7 @@ async function runPopulation(workspacePath, tasks, kairnConfig, evolveConfig, nu
   }
   let synthesizedResult;
   try {
-    const baselinePath2 = path28.join(workspacePath, "baseline");
+    const baselinePath2 = path29.join(workspacePath, "baseline");
     const synthesisResult = await runSynthesis(
       { branches: branchResults, tasks, baselineHarnessPath: baselinePath2 },
       kairnConfig,
@@ -2597,7 +4199,7 @@ var ui = {
   // Key-value pairs
   kv: (key, value) => `  ${chalk.cyan(key.padEnd(14))} ${value}`,
   // File list
-  file: (path30) => chalk.dim(`    ${path30}`),
+  file: (path31) => chalk.dim(`    ${path31}`),
   // Tool display
   tool: (name, reason) => `    ${warmStone("\u25CF")} ${chalk.bold(name)}
       ${chalk.dim(reason)}`,
@@ -6449,8 +8051,8 @@ var keysCommand = new Command10("keys").description("Add or update API keys for
 import { Command as Command11 } from "commander";
 import chalk14 from "chalk";
 import ora2 from "ora";
-import fs28 from "fs/promises";
-import path29 from "path";
+import fs29 from "fs/promises";
+import path30 from "path";
 import { parse as yamlParse2 } from "yaml";
 import { confirm as confirm4, input as input4, select as select4 } from "@inquirer/prompts";
 
@@ -6780,8 +8382,8 @@ init_loop();
 
 // src/evolve/report.ts
 init_trace();
-import fs25 from "fs/promises";
-import path25 from "path";
+import fs26 from "fs/promises";
+import path26 from "path";
 
 // src/evolve/diagnosis.ts
 function numericScore(s) {
@@ -6831,10 +8433,10 @@ function numericScore2(s) {
   return s.score ?? (s.pass ? 100 : 0);
 }
 async function loadAllIterations(workspacePath) {
-  const iterDir = path25.join(workspacePath, "iterations");
+  const iterDir = path26.join(workspacePath, "iterations");
   let entries;
   try {
-    entries = await fs25.readdir(iterDir);
+    entries = await fs26.readdir(iterDir);
   } catch {
     return [];
   }
@@ -6848,7 +8450,7 @@ async function loadAllIterations(workspacePath) {
 }
 async function loadTasks(workspacePath) {
   try {
-    const content = await fs25.readFile(path25.join(workspacePath, "tasks.yaml"), "utf-8");
+    const content = await fs26.readFile(path26.join(workspacePath, "tasks.yaml"), "utf-8");
     const parsed = yamlParse(content);
     return parsed?.tasks ?? [];
   } catch {
@@ -7028,13 +8630,13 @@ init_mutator();
 init_baseline();
 init_mutator();
 init_trace();
-import fs26 from "fs/promises";
-import path26 from "path";
+import fs27 from "fs/promises";
+import path27 from "path";
 async function listIterations(workspacePath) {
-  const iterationsDir = path26.join(workspacePath, "iterations");
+  const iterationsDir = path27.join(workspacePath, "iterations");
   let entries;
   try {
-    entries = await fs26.readdir(iterationsDir);
+    entries = await fs27.readdir(iterationsDir);
   } catch {
     return [];
   }
@@ -7043,7 +8645,7 @@ async function listIterations(workspacePath) {
     const n = parseInt(entry, 10);
     if (!isNaN(n)) {
       try {
-        await fs26.access(path26.join(iterationsDir, entry, "harness"));
+        await fs27.access(path27.join(iterationsDir, entry, "harness"));
         nums.push(n);
       } catch {
       }
@@ -7069,16 +8671,16 @@ async function listFilesRecursive(dir) {
   async function walk(current) {
     let entries;
     try {
-      entries = await fs26.readdir(current, { withFileTypes: true });
+      entries = await fs27.readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path26.join(current, entry.name);
+      const fullPath = path27.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
-        results.push(path26.relative(dir, fullPath));
+        results.push(path27.relative(dir, fullPath));
       }
     }
   }
@@ -7101,37 +8703,37 @@ async function applyEvolution(workspacePath, projectRoot, targetIteration) {
   } else {
     iter = await findBestIteration(workspacePath, iterations);
   }
-  const harnessPath = path26.join(
+  const harnessPath = path27.join(
     workspacePath,
     "iterations",
     iter.toString(),
     "harness"
   );
-  const claudeDir = path26.join(projectRoot, ".claude");
+  const claudeDir = path27.join(projectRoot, ".claude");
   const diffPreview = await generateDiff2(claudeDir, harnessPath);
   const currentFiles = await listFilesRecursive(claudeDir);
   const targetFiles = await listFilesRecursive(harnessPath);
   const allPaths = /* @__PURE__ */ new Set([...currentFiles, ...targetFiles]);
   const filesChanged = [];
   for (const filePath of allPaths) {
-    const currentContent = await fs26.readFile(path26.join(claudeDir, filePath), "utf-8").catch(() => null);
-    const targetContent = await fs26.readFile(path26.join(harnessPath, filePath), "utf-8").catch(() => null);
+    const currentContent = await fs27.readFile(path27.join(claudeDir, filePath), "utf-8").catch(() => null);
+    const targetContent = await fs27.readFile(path27.join(harnessPath, filePath), "utf-8").catch(() => null);
     if (currentContent !== targetContent) {
       filesChanged.push(filePath);
     }
   }
-  await fs26.rm(claudeDir, { recursive: true, force: true });
+  await fs27.rm(claudeDir, { recursive: true, force: true });
   await copyDir(harnessPath, claudeDir);
-  const harnessMcpJson = path26.join(harnessPath, ".mcp.json");
-  const projectMcpJson = path26.join(projectRoot, ".mcp.json");
+  const harnessMcpJson = path27.join(harnessPath, ".mcp.json");
+  const projectMcpJson = path27.join(projectRoot, ".mcp.json");
   try {
-    await fs26.access(harnessMcpJson);
-    const currentMcp = await fs26.readFile(projectMcpJson, "utf-8").catch(() => null);
-    const targetMcp = await fs26.readFile(harnessMcpJson, "utf-8").catch(() => null);
+    await fs27.access(harnessMcpJson);
+    const currentMcp = await fs27.readFile(projectMcpJson, "utf-8").catch(() => null);
+    const targetMcp = await fs27.readFile(harnessMcpJson, "utf-8").catch(() => null);
     if (currentMcp !== targetMcp) {
       filesChanged.push(".mcp.json");
     }
-    await fs26.copyFile(harnessMcpJson, projectMcpJson);
+    await fs27.copyFile(harnessMcpJson, projectMcpJson);
   } catch {
   }
   return {
@@ -7160,7 +8762,7 @@ var DEFAULT_CONFIG = {
 };
 async function loadEvolveConfigFromWorkspace(workspacePath) {
   try {
-    const configStr = await fs28.readFile(path29.join(workspacePath, "config.yaml"), "utf-8");
+    const configStr = await fs29.readFile(path30.join(workspacePath, "config.yaml"), "utf-8");
     const parsed = yamlParse2(configStr);
     return {
       model: parsed.model ?? DEFAULT_CONFIG.model,
@@ -7187,9 +8789,9 @@ evolveCommand.command("init").description("Initialize an evolution workspace wit
   try {
     const projectRoot = process.cwd();
     console.log(ui.section("Evolve Init"));
-    const claudeDir = path29.join(projectRoot, ".claude");
+    const claudeDir = path30.join(projectRoot, ".claude");
     try {
-      await fs28.access(claudeDir);
+      await fs29.access(claudeDir);
     } catch {
       console.log(ui.error("No .claude/ directory found. Run kairn describe first."));
       process.exit(1);
@@ -7239,7 +8841,7 @@ evolveCommand.command("init").description("Initialize an evolution workspace wit
           if (config) {
             let claudeMd = "";
             try {
-              claudeMd = await fs28.readFile(path29.join(claudeDir, "CLAUDE.md"), "utf-8");
+              claudeMd = await fs29.readFile(path30.join(claudeDir, "CLAUDE.md"), "utf-8");
             } catch {
             }
             const profile = await buildProjectProfile(projectRoot);
@@ -7270,16 +8872,16 @@ evolveCommand.command("init").description("Initialize an evolution workspace wit
 evolveCommand.command("baseline").description("Snapshot current .claude/ directory as baseline").action(async () => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path29.join(projectRoot, ".kairn-evolve");
+    const workspace = path30.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve Baseline"));
     try {
-      await fs28.access(workspace);
+      await fs29.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
     }
     await snapshotBaseline(projectRoot, workspace);
-    const baselineDir = path29.join(workspace, "baseline");
+    const baselineDir = path30.join(workspace, "baseline");
     const fileCount = await countFiles(baselineDir);
     console.log(ui.success(`Baseline snapshot created (${fileCount} files)`));
   } catch (err) {
@@ -7291,18 +8893,18 @@ evolveCommand.command("baseline").description("Snapshot current .claude/ directo
 evolveCommand.command("run").description("Run tasks against the current harness").option("--task <id>", "Run a specific task by ID").option("--iterations <n>", "Number of evolution iterations", "5").option("--runs <n>", "Run each task N times for variance measurement", "1").option("--parallel <n>", "Run up to N tasks concurrently", "1").option("--max-mutations <n>", "Max mutations per iteration", "3").option("--prune-threshold <n>", "Skip tasks scoring above this on middle iterations", "95").option("--max-task-drop <n>", "Roll back if any task drops more than N points", "20").option("--principal", "Run Principal Proposer as final iteration").option("--eval-sample <n>", "Sample N tasks per middle iteration (0 = all)", "0").option("--sampling <strategy>", "Task sampling strategy: thompson or uniform", "thompson").option("--kl-lambda <n>", "KL regularization strength (0 = disabled)", "0.1").option("-i, --interactive", "Configure evolution settings interactively").action(async (options) => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path29.join(projectRoot, ".kairn-evolve");
+    const workspace = path30.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve Run"));
     try {
-      await fs28.access(workspace);
+      await fs29.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
     }
-    const tasksPath = path29.join(workspace, "tasks.yaml");
+    const tasksPath = path30.join(workspace, "tasks.yaml");
     let tasksContent;
     try {
-      tasksContent = await fs28.readFile(tasksPath, "utf-8");
+      tasksContent = await fs29.readFile(tasksPath, "utf-8");
     } catch {
       console.log(ui.error("No tasks.yaml found. Run kairn evolve init first."));
       process.exit(1);
@@ -7321,15 +8923,15 @@ evolveCommand.command("run").description("Run tasks against the current harness"
       console.log(ui.info(`Running ${tasksToRun.length} task(s)...`));
       console.log("");
       const config = await loadConfig();
-      const harnessPath = path29.join(projectRoot, ".claude");
+      const harnessPath = path30.join(projectRoot, ".claude");
       const results = [];
       for (const task of tasksToRun) {
-        const traceDir = path29.join(workspace, "traces", "0", task.id);
+        const traceDir = path30.join(workspace, "traces", "0", task.id);
         const spinner = ora2(`Running: ${task.id}`).start();
         const result = await runTask(task, harnessPath, traceDir, 0);
         if (config) {
-          const stdout = await fs28.readFile(path29.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
-          const stderr = await fs28.readFile(path29.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
+          const stdout = await fs29.readFile(path30.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
+          const stderr = await fs29.readFile(path30.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
           const score = await scoreTask(task, traceDir, stdout, stderr, config);
           result.score = score;
           await writeScore(traceDir, score);
@@ -7477,7 +9079,7 @@ evolveCommand.command("run").description("Run tasks against the current harness"
         evolveConfig.klLambda = klLambda;
       }
       try {
-        await fs28.access(path29.join(workspace, "iterations", "0", "harness"));
+        await fs29.access(path30.join(workspace, "iterations", "0", "harness"));
       } catch {
         console.log(ui.error("No baseline harness found. Run kairn evolve baseline first."));
         process.exit(1);
@@ -7571,16 +9173,16 @@ evolveCommand.command("run").description("Run tasks against the current harness"
 evolveCommand.command("pbt").description("Run Population-Based Training with parallel evolution branches").option("--branches <n>", "Number of parallel branches", "3").option("--iterations <n>", "Iterations per branch", "5").option("--parallel <n>", "Tasks per branch concurrently", "2").option("--sampling <strategy>", "Task sampling strategy: thompson or uniform", "thompson").option("--kl-lambda <n>", "KL regularization strength (0 = disabled)", "0.1").option("--eval-sample <n>", "Sample N tasks per middle iteration (0 = all)", "5").action(async (options) => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path29.join(projectRoot, ".kairn-evolve");
+    const workspace = path30.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve PBT"));
     try {
-      await fs28.access(workspace);
+      await fs29.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
     }
     try {
-      await fs28.access(path29.join(workspace, "iterations", "0", "harness"));
+      await fs29.access(path30.join(workspace, "iterations", "0", "harness"));
     } catch {
       console.log(ui.error("No baseline harness found. Run kairn evolve baseline first."));
       process.exit(1);
@@ -7600,8 +9202,8 @@ evolveCommand.command("pbt").description("Run Population-Based Training with par
     if (sampling === "thompson" || sampling === "uniform") {
       evolveConfig.samplingStrategy = sampling;
     }
-    const tasksPath = path29.join(workspace, "tasks.yaml");
-    const tasksContent = await fs28.readFile(tasksPath, "utf-8");
+    const tasksPath = path30.join(workspace, "tasks.yaml");
+    const tasksContent = await fs29.readFile(tasksPath, "utf-8");
     const parsed = yamlParse2(tasksContent);
     if (!parsed?.tasks || parsed.tasks.length === 0) {
       console.log(ui.error("No tasks found in tasks.yaml"));
@@ -7659,10 +9261,10 @@ evolveCommand.command("pbt").description("Run Population-Based Training with par
 evolveCommand.command("apply").description("Apply the best evolved harness to your project").option("--iter <n>", "Apply a specific iteration instead of the best").option("--force", "Apply even if git working tree is dirty").option("--no-commit", "Skip automatic git commit after applying").action(async (options) => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path29.join(projectRoot, ".kairn-evolve");
+    const workspace = path30.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve Apply"));
     try {
-      await fs28.access(workspace);
+      await fs29.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
@@ -7703,9 +9305,9 @@ evolveCommand.command("apply").description("Apply the best evolved harness to yo
 evolveCommand.command("report").description("Generate a summary report of the evolution run").option("--json", "Output machine-readable JSON instead of Markdown").action(async (options) => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path29.join(projectRoot, ".kairn-evolve");
+    const workspace = path30.join(projectRoot, ".kairn-evolve");
     try {
-      await fs28.access(workspace);
+      await fs29.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
@@ -7726,23 +9328,23 @@ evolveCommand.command("report").description("Generate a summary report of the ev
 evolveCommand.command("diff <iter1> <iter2>").description("Show harness changes between two iterations").action(async (iter1Str, iter2Str) => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path29.join(projectRoot, ".kairn-evolve");
+    const workspace = path30.join(projectRoot, ".kairn-evolve");
     const iter1 = parseInt(iter1Str, 10);
     const iter2 = parseInt(iter2Str, 10);
     if (isNaN(iter1) || isNaN(iter2)) {
       console.log(ui.error("Both arguments must be integers (iteration numbers)"));
       process.exit(1);
     }
-    const harness1 = path29.join(workspace, "iterations", iter1.toString(), "harness");
-    const harness2 = path29.join(workspace, "iterations", iter2.toString(), "harness");
+    const harness1 = path30.join(workspace, "iterations", iter1.toString(), "harness");
+    const harness2 = path30.join(workspace, "iterations", iter2.toString(), "harness");
     try {
-      await fs28.access(harness1);
+      await fs29.access(harness1);
     } catch {
       console.log(ui.error(`Iteration ${iter1} harness not found at ${harness1}`));
       process.exit(1);
     }
     try {
-      await fs28.access(harness2);
+      await fs29.access(harness2);
     } catch {
       console.log(ui.error(`Iteration ${iter2} harness not found at ${harness2}`));
       process.exit(1);
@@ -7797,10 +9399,10 @@ evolveCommand.command("diff <iter1> <iter2>").description("Show harness changes
 async function countFiles(dir) {
   let count = 0;
   try {
-    const entries = await fs28.readdir(dir, { withFileTypes: true });
+    const entries = await fs29.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        count += await countFiles(path29.join(dir, entry.name));
+        count += await countFiles(path30.join(dir, entry.name));
       } else {
         count++;
       }