kairn-cli 2.14.0 → 2.15.0

package/dist/cli.js

@@ -411,7 +411,7 @@ var init_ui = __esm({
       // Key-value pairs
       kv: (key, value) => `  ${chalk.cyan(key.padEnd(14))} ${value}`,
       // File list
-      file: (path37) => chalk.dim(`    ${path37}`),
+      file: (path39) => chalk.dim(`    ${path39}`),
       // Tool display
       tool: (name, reason) => `    ${warmStone("\u25CF")} ${chalk.bold(name)}
       ${chalk.dim(reason)}`,
@@ -3811,12 +3811,31 @@ var init_secrets = __esm({
   }
 });
 
-// src/scanner/scan.ts
+// src/compiler/persist.ts
 import fs9 from "fs/promises";
 import path9 from "path";
+async function persistHarnessIR(targetDir, ir) {
+  const kairnDir = path9.join(targetDir, KAIRN_DIR2);
+  await fs9.mkdir(kairnDir, { recursive: true });
+  const filePath = path9.join(kairnDir, HARNESS_IR_FILENAME);
+  await fs9.writeFile(filePath, JSON.stringify(ir, null, 2), "utf-8");
+  return filePath;
+}
+var KAIRN_DIR2, HARNESS_IR_FILENAME;
+var init_persist = __esm({
+  "src/compiler/persist.ts"() {
+    "use strict";
+    KAIRN_DIR2 = ".kairn";
+    HARNESS_IR_FILENAME = "harness-ir.json";
+  }
+});
+
+// src/scanner/scan.ts
+import fs10 from "fs/promises";
+import path10 from "path";
 async function fileExists(p) {
   try {
-    await fs9.access(p);
+    await fs10.access(p);
     return true;
   } catch {
     return false;
@@ -3824,7 +3843,7 @@ async function fileExists(p) {
 }
 async function readJsonSafe(p) {
   try {
-    const data = await fs9.readFile(p, "utf-8");
+    const data = await fs10.readFile(p, "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -3832,14 +3851,14 @@ async function readJsonSafe(p) {
 }
 async function readFileSafe(p) {
   try {
-    return await fs9.readFile(p, "utf-8");
+    return await fs10.readFile(p, "utf-8");
   } catch {
     return null;
   }
 }
 async function listDirSafe(p) {
   try {
-    const entries = await fs9.readdir(p);
+    const entries = await fs10.readdir(p);
     return entries.filter((e) => !e.startsWith("."));
   } catch {
     return [];
@@ -3891,7 +3910,7 @@ function extractEnvKeys(content) {
   return keys;
 }
 async function scanProject(dir) {
-  const pkg2 = await readJsonSafe(path9.join(dir, "package.json"));
+  const pkg2 = await readJsonSafe(path10.join(dir, "package.json"));
   const deps = pkg2?.dependencies ? Object.keys(pkg2.dependencies) : [];
   const devDeps = pkg2?.devDependencies ? Object.keys(pkg2.devDependencies) : [];
   const allDeps = [...deps, ...devDeps];
@@ -3919,19 +3938,19 @@ async function scanProject(dir) {
   const framework = detectFramework(allDeps);
   const typescript = keyFiles.includes("tsconfig.json") || allDeps.includes("typescript");
   const testCommand = scripts.test && scripts.test !== 'echo "Error: no test specified" && exit 1' ? scripts.test : null;
-  const hasTests = testCommand !== null || await fileExists(path9.join(dir, "tests")) || await fileExists(path9.join(dir, "__tests__")) || await fileExists(path9.join(dir, "test"));
+  const hasTests = testCommand !== null || await fileExists(path10.join(dir, "tests")) || await fileExists(path10.join(dir, "__tests__")) || await fileExists(path10.join(dir, "test"));
   const buildCommand = scripts.build || null;
   const lintCommand = scripts.lint || null;
-  const hasSrc = await fileExists(path9.join(dir, "src"));
-  const hasDocker = await fileExists(path9.join(dir, "docker-compose.yml")) || await fileExists(path9.join(dir, "Dockerfile"));
-  const hasCi = await fileExists(path9.join(dir, ".github/workflows"));
-  const hasEnvFile = await fileExists(path9.join(dir, ".env")) || await fileExists(path9.join(dir, ".env.example"));
+  const hasSrc = await fileExists(path10.join(dir, "src"));
+  const hasDocker = await fileExists(path10.join(dir, "docker-compose.yml")) || await fileExists(path10.join(dir, "Dockerfile"));
+  const hasCi = await fileExists(path10.join(dir, ".github/workflows"));
+  const hasEnvFile = await fileExists(path10.join(dir, ".env")) || await fileExists(path10.join(dir, ".env.example"));
   let envKeys = [];
-  const envExample = await readFileSafe(path9.join(dir, ".env.example"));
+  const envExample = await readFileSafe(path10.join(dir, ".env.example"));
   if (envExample) {
     envKeys = extractEnvKeys(envExample);
   }
-  const claudeDir = path9.join(dir, ".claude");
+  const claudeDir = path10.join(dir, ".claude");
   const hasClaudeDir = await fileExists(claudeDir);
   let existingClaudeMd = null;
   let existingSettings = null;
@@ -3943,21 +3962,21 @@ async function scanProject(dir) {
   let mcpServerCount = 0;
   let claudeMdLineCount = 0;
   if (hasClaudeDir) {
-    existingClaudeMd = await readFileSafe(path9.join(claudeDir, "CLAUDE.md"));
+    existingClaudeMd = await readFileSafe(path10.join(claudeDir, "CLAUDE.md"));
     if (existingClaudeMd) {
       claudeMdLineCount = existingClaudeMd.split("\n").length;
     }
-    existingSettings = await readJsonSafe(path9.join(claudeDir, "settings.json"));
-    existingMcpConfig = await readJsonSafe(path9.join(dir, ".mcp.json"));
+    existingSettings = await readJsonSafe(path10.join(claudeDir, "settings.json"));
+    existingMcpConfig = await readJsonSafe(path10.join(dir, ".mcp.json"));
     if (existingMcpConfig?.mcpServers) {
       mcpServerCount = Object.keys(existingMcpConfig.mcpServers).length;
     }
-    existingCommands = (await listDirSafe(path9.join(claudeDir, "commands"))).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
-    existingRules = (await listDirSafe(path9.join(claudeDir, "rules"))).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
-    existingSkills = await listDirSafe(path9.join(claudeDir, "skills"));
-    existingAgents = (await listDirSafe(path9.join(claudeDir, "agents"))).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+    existingCommands = (await listDirSafe(path10.join(claudeDir, "commands"))).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+    existingRules = (await listDirSafe(path10.join(claudeDir, "rules"))).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+    existingSkills = await listDirSafe(path10.join(claudeDir, "skills"));
+    existingAgents = (await listDirSafe(path10.join(claudeDir, "agents"))).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
   }
-  const name = pkg2?.name || path9.basename(dir);
+  const name = pkg2?.name || path10.basename(dir);
   const description = pkg2?.description || "";
   return {
     name,
@@ -4014,8 +4033,8 @@ var init_types3 = __esm({
 });
 
 // src/analyzer/patterns.ts
-import fs10 from "fs/promises";
-import path10 from "path";
+import fs11 from "fs/promises";
+import path11 from "path";
 function getStrategy(language) {
   if (language === null) {
     return null;
@@ -4080,7 +4099,7 @@ function extractPathsFromScripts(scripts) {
 async function resolveNodeEntryPoints(dir) {
   const paths = [];
   try {
-    const raw = await fs10.readFile(path10.join(dir, "package.json"), "utf-8");
+    const raw = await fs11.readFile(path11.join(dir, "package.json"), "utf-8");
     const pkg2 = JSON.parse(raw);
     if (typeof pkg2.main === "string") {
       paths.push(pkg2.main);
@@ -4119,7 +4138,7 @@ async function resolveNodeEntryPoints(dir) {
 async function resolvePythonEntryPoints(dir) {
   const paths = [];
   try {
-    const raw = await fs10.readFile(path10.join(dir, "pyproject.toml"), "utf-8");
+    const raw = await fs11.readFile(path11.join(dir, "pyproject.toml"), "utf-8");
     const scriptMatches = raw.matchAll(/^\s*\w+\s*=\s*"([^":]+)/gm);
     for (const m of scriptMatches) {
       const modulePath = m[1].replace(/\./g, "/") + ".py";
@@ -4130,17 +4149,17 @@ async function resolvePythonEntryPoints(dir) {
   }
   for (const f of ["manage.py", "wsgi.py", "asgi.py"]) {
     try {
-      await fs10.access(path10.join(dir, f));
+      await fs11.access(path11.join(dir, f));
       paths.push(f);
     } catch {
     }
   }
   try {
-    const entries = await fs10.readdir(path10.join(dir, "src"), { withFileTypes: true });
+    const entries = await fs11.readdir(path11.join(dir, "src"), { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         try {
-          await fs10.access(path10.join(dir, "src", entry.name, "__main__.py"));
+          await fs11.access(path11.join(dir, "src", entry.name, "__main__.py"));
           paths.push(`src/${entry.name}/__main__.py`);
           paths.push(`src/${entry.name}/__init__.py`);
         } catch {
@@ -4154,7 +4173,7 @@ async function resolvePythonEntryPoints(dir) {
 async function resolveRustEntryPoints(dir) {
   const paths = [];
   try {
-    const raw = await fs10.readFile(path10.join(dir, "Cargo.toml"), "utf-8");
+    const raw = await fs11.readFile(path11.join(dir, "Cargo.toml"), "utf-8");
     const binPaths = raw.matchAll(/path\s*=\s*"([^"]+\.rs)"/g);
     for (const m of binPaths) paths.push(m[1]);
   } catch {
@@ -4164,7 +4183,7 @@ async function resolveRustEntryPoints(dir) {
 async function resolveGoEntryPoints(dir) {
   const paths = [];
   try {
-    const cmdEntries = await fs10.readdir(path10.join(dir, "cmd"), { withFileTypes: true });
+    const cmdEntries = await fs11.readdir(path11.join(dir, "cmd"), { withFileTypes: true });
     for (const entry of cmdEntries) {
       if (entry.isDirectory()) {
         paths.push(`cmd/${entry.name}/main.go`);
@@ -4330,9 +4349,9 @@ var init_patterns = __esm({
 });
 
 // src/analyzer/repomix-adapter.ts
-import path11 from "path";
+import path12 from "path";
 import os3 from "os";
-import fs11 from "fs/promises";
+import fs12 from "fs/promises";
 import {
   pack,
   mergeConfigs,
@@ -4342,7 +4361,7 @@ import {
 } from "repomix";
 async function packCodebase(dir, options) {
   setLogLevel(0);
-  const tempOutputFile = path11.join(
+  const tempOutputFile = path12.join(
     os3.tmpdir(),
     `kairn-repomix-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`
   );
@@ -4413,7 +4432,7 @@ ${f.content}`).join("\n\n");
       message
     );
   } finally {
-    await fs11.rm(tempOutputFile, { force: true }).catch(() => {
+    await fs12.rm(tempOutputFile, { force: true }).catch(() => {
     });
   }
 }
@@ -4425,50 +4444,64 @@ var init_repomix_adapter = __esm({
 });
 
 // src/analyzer/cache.ts
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 import fsSync from "fs";
-import path12 from "path";
+import path13 from "path";
 import { createHash } from "crypto";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getKairnVersion() {
-  let dir = path12.dirname(fileURLToPath3(import.meta.url));
+  let dir = path13.dirname(fileURLToPath3(import.meta.url));
   for (let i = 0; i < 5; i++) {
     try {
-      const pkgPath = path12.join(dir, "package.json");
+      const pkgPath = path13.join(dir, "package.json");
       const content = fsSync.readFileSync(pkgPath, "utf-8");
       const parsed = JSON.parse(content);
       if (parsed.name === "kairn-cli") return parsed.version ?? "0.0.0";
     } catch {
     }
-    dir = path12.dirname(dir);
+    dir = path13.dirname(dir);
   }
   return "0.0.0";
 }
 async function readCache(dir) {
-  const filePath = path12.join(dir, CACHE_FILENAME);
+  const filePath = path13.join(dir, CACHE_FILENAME);
   try {
-    const raw = await fs12.readFile(filePath, "utf-8");
+    const raw = await fs13.readFile(filePath, "utf-8");
     const parsed = JSON.parse(raw);
-    return parsed;
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.analysis !== "object" || parsed.analysis === null) {
+      return null;
+    }
+    const cache = parsed;
+    let packedSource = null;
+    try {
+      const packedPath = path13.join(dir, PACKED_SOURCE_FILENAME);
+      packedSource = await fs13.readFile(packedPath, "utf-8");
+    } catch {
+    }
+    return { ...cache, packedSource };
   } catch {
     return null;
   }
 }
-async function writeCache(dir, analysis) {
-  const filePath = path12.join(dir, CACHE_FILENAME);
+async function writeCache(dir, analysis, packedSource) {
+  const filePath = path13.join(dir, CACHE_FILENAME);
   const cache = {
     analysis,
     content_hash: analysis.content_hash,
     kairn_version: KAIRN_VERSION
   };
-  await fs12.writeFile(filePath, JSON.stringify(cache, null, 2), "utf-8");
+  await fs13.writeFile(filePath, JSON.stringify(cache, null, 2), "utf-8");
+  if (packedSource !== void 0) {
+    const packedPath = path13.join(dir, PACKED_SOURCE_FILENAME);
+    await fs13.writeFile(packedPath, packedSource, "utf-8");
+  }
 }
 async function computeContentHash(filePaths, dir) {
   const hash = createHash("sha256");
   for (const filePath of filePaths) {
     try {
-      const fullPath = path12.join(dir, filePath);
-      const content = await fs12.readFile(fullPath, "utf-8");
+      const fullPath = path13.join(dir, filePath);
+      const content = await fs13.readFile(fullPath, "utf-8");
       hash.update(content);
     } catch {
     }
@@ -4478,12 +4511,13 @@ async function computeContentHash(filePaths, dir) {
 function isCacheValid(cache, currentHash) {
   return cache.content_hash === currentHash && cache.kairn_version === KAIRN_VERSION;
 }
-var KAIRN_VERSION, CACHE_FILENAME;
+var KAIRN_VERSION, CACHE_FILENAME, PACKED_SOURCE_FILENAME;
 var init_cache = __esm({
   "src/analyzer/cache.ts"() {
     "use strict";
     KAIRN_VERSION = getKairnVersion();
     CACHE_FILENAME = ".kairn-analysis.json";
+    PACKED_SOURCE_FILENAME = ".kairn-packed-source.txt";
   }
 });
 
@@ -4516,7 +4550,10 @@ async function analyzeProject(dir, profile, config, options) {
         dir
       );
       if (isCacheValid(cache, currentHash)) {
-        return cache.analysis;
+        return {
+          analysis: cache.analysis,
+          packedSource: cache.packedSource ?? ""
+        };
       }
     }
   }
@@ -4582,8 +4619,8 @@ async function analyzeProject(dir, profile, config, options) {
     content_hash: contentHash,
     analyzed_at: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeCache(dir, analysis);
-  return analysis;
+  await writeCache(dir, analysis, packed.content);
+  return { analysis, packedSource: packed.content };
 }
 function buildUserMessage6(language, profile, packedContent) {
   return [
@@ -4656,8 +4693,8 @@ import { Command as Command2 } from "commander";
 import { confirm as confirm2 } from "@inquirer/prompts";
 import chalk5 from "chalk";
 import ora from "ora";
-import fs13 from "fs/promises";
-import path13 from "path";
+import fs14 from "fs/promises";
+import path14 from "path";
 function simpleDiff(oldContent, newContent) {
   const oldLines = oldContent.split("\n");
   const newLines = newContent.split("\n");
@@ -4681,10 +4718,10 @@ async function generateDiff(spec, targetDir) {
   const fileMap = buildFileMap(spec);
   const results = [];
   for (const [relativePath, newContent] of fileMap) {
-    const absolutePath = path13.join(targetDir, relativePath);
+    const absolutePath = path14.join(targetDir, relativePath);
     let oldContent = null;
     try {
-      oldContent = await fs13.readFile(absolutePath, "utf-8");
+      oldContent = await fs14.readFile(absolutePath, "utf-8");
     } catch {
     }
     if (oldContent === null) {
@@ -4741,7 +4778,7 @@ Existing .claude/ harness found:`);
   lines.push(`  Agents: ${profile.existingAgents.length > 0 ? profile.existingAgents.join(", ") : "none"}`);
   return lines.join("\n");
 }
-function buildOptimizeIntent(profile, analysis) {
+function buildOptimizeIntent(profile, analysis, packedSource) {
   const parts = [];
   parts.push("## Project Profile (scanned from actual codebase)\n");
   parts.push(buildProfileSummary(profile));
@@ -4826,6 +4863,13 @@ ${profile.existingClaudeMd}`);
       }
     }
   }
+  if (packedSource) {
+    parts.push(`
+
+## Sampled Source Code (reference for project-specific content)
+
+${packedSource}`);
+  }
   return parts.join("\n");
 }
 var optimizeCommand;
@@ -4843,6 +4887,7 @@ var init_optimize = __esm({
     init_logo();
     init_analyze();
     init_types3();
+    init_persist();
     optimizeCommand = new Command2("optimize").description("Scan an existing project and generate or optimize its Claude Code environment").option("-y, --yes", "Skip confirmation prompts").option("--audit-only", "Only audit the existing harness, don't generate changes").option("--diff", "Preview changes as a diff without writing").option("--runtime <runtime>", "Target runtime (claude-code or hermes)", "claude-code").action(async (options) => {
       printCompactBanner();
       const config = await loadConfig();
@@ -4866,13 +4911,19 @@ var init_optimize = __esm({
       console.log(ui.section("Codebase Analysis"));
       const analysisSpinner = ora({ text: "Analyzing source code...", indent: 2 }).start();
       let analysis = null;
+      let packedSource = "";
       try {
-        analysis = await analyzeProject(targetDir, profile, config);
+        const result = await analyzeProject(targetDir, profile, config);
+        analysis = result.analysis;
+        packedSource = result.packedSource;
         analysisSpinner.succeed("Codebase analyzed");
         console.log(ui.kv("Purpose:", analysis.purpose));
         console.log(ui.kv("Domain:", analysis.domain));
         console.log(ui.kv("Modules:", analysis.key_modules.map((m) => m.name).join(", ") || "none detected"));
         console.log(ui.kv("Workflows:", analysis.workflows.map((w) => w.name).join(", ") || "none detected"));
+        if (packedSource) {
+          console.log(ui.kv("Source:", `${packedSource.length.toLocaleString()} chars sampled`));
+        }
       } catch (err) {
         if (err instanceof AnalysisError) {
           analysisSpinner.fail("Analysis failed");
@@ -4940,7 +4991,7 @@ Run \`kairn analyze\` for details.`));
           }
         }
       }
-      const intent = buildOptimizeIntent(profile, analysis);
+      const intent = buildOptimizeIntent(profile, analysis, packedSource);
       let spec;
       const spinner = ora({ text: "Compiling optimized environment...", indent: 2 }).start();
       try {
@@ -4954,6 +5005,13 @@ Run \`kairn analyze\` for details.`));
         console.log(ui.errorBox("KAIRN \u2014 Error", `Optimization failed: ${msg}`));
         process.exit(1);
       }
+      if (spec.ir) {
+        try {
+          await persistHarnessIR(targetDir, spec.ir);
+        } catch {
+          console.log(ui.warn("Could not persist harness IR to .kairn/harness-ir.json"));
+        }
+      }
       const registry = await loadRegistry();
       const summary = summarizeSpec(spec, registry);
       console.log("");
@@ -5034,37 +5092,37 @@ Run \`kairn analyze\` for details.`));
 });
 
 // src/evolve/baseline.ts
-import fs20 from "fs/promises";
-import path20 from "path";
+import fs21 from "fs/promises";
+import path21 from "path";
 async function snapshotBaseline(projectRoot, workspacePath) {
-  const claudeDir = path20.join(projectRoot, ".claude");
-  const baselineDir = path20.join(workspacePath, "baseline");
-  const iter0Dir = path20.join(workspacePath, "iterations", "0", "harness");
+  const claudeDir = path21.join(projectRoot, ".claude");
+  const baselineDir = path21.join(workspacePath, "baseline");
+  const iter0Dir = path21.join(workspacePath, "iterations", "0", "harness");
   try {
-    await fs20.access(claudeDir);
+    await fs21.access(claudeDir);
   } catch {
     throw new Error(`.claude/ directory not found in ${projectRoot}`);
   }
   await copyDir(claudeDir, baselineDir);
   await copyDir(claudeDir, iter0Dir);
-  const mcpJsonPath = path20.join(projectRoot, ".mcp.json");
+  const mcpJsonPath = path21.join(projectRoot, ".mcp.json");
   try {
-    await fs20.access(mcpJsonPath);
-    await fs20.copyFile(mcpJsonPath, path20.join(baselineDir, ".mcp.json"));
-    await fs20.copyFile(mcpJsonPath, path20.join(iter0Dir, ".mcp.json"));
+    await fs21.access(mcpJsonPath);
+    await fs21.copyFile(mcpJsonPath, path21.join(baselineDir, ".mcp.json"));
+    await fs21.copyFile(mcpJsonPath, path21.join(iter0Dir, ".mcp.json"));
   } catch {
   }
 }
 async function copyDir(src, dest) {
-  await fs20.mkdir(dest, { recursive: true });
-  const entries = await fs20.readdir(src, { withFileTypes: true });
+  await fs21.mkdir(dest, { recursive: true });
+  const entries = await fs21.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path20.join(src, entry.name);
-    const destPath = path20.join(dest, entry.name);
+    const srcPath = path21.join(src, entry.name);
+    const destPath = path21.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDir(srcPath, destPath);
     } else {
-      await fs20.copyFile(srcPath, destPath);
+      await fs21.copyFile(srcPath, destPath);
     }
   }
 }
@@ -5075,32 +5133,32 @@ var init_baseline = __esm({
 });
 
 // src/evolve/trace.ts
-import fs21 from "fs/promises";
-import path21 from "path";
+import fs22 from "fs/promises";
+import path22 from "path";
 async function loadTrace(traceDir) {
-  const stdout = await fs21.readFile(path21.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
-  const stderr = await fs21.readFile(path21.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
-  const filesChangedStr = await fs21.readFile(
-    path21.join(traceDir, "files_changed.json"),
+  const stdout = await fs22.readFile(path22.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
+  const stderr = await fs22.readFile(path22.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
+  const filesChangedStr = await fs22.readFile(
+    path22.join(traceDir, "files_changed.json"),
     "utf-8"
   ).catch(() => "{}");
-  const timingStr = await fs21.readFile(
-    path21.join(traceDir, "timing.json"),
+  const timingStr = await fs22.readFile(
+    path22.join(traceDir, "timing.json"),
     "utf-8"
   ).catch(() => "{}");
-  const scoreStr = await fs21.readFile(
-    path21.join(traceDir, "score.json"),
+  const scoreStr = await fs22.readFile(
+    path22.join(traceDir, "score.json"),
     "utf-8"
   ).catch(() => '{"pass": false}');
-  const toolCallsStr = await fs21.readFile(
-    path21.join(traceDir, "tool_calls.jsonl"),
+  const toolCallsStr = await fs22.readFile(
+    path22.join(traceDir, "tool_calls.jsonl"),
     "utf-8"
   ).catch(() => "");
   const toolCalls = toolCallsStr.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
-  const parentDir = path21.basename(path21.dirname(traceDir));
+  const parentDir = path22.basename(path22.dirname(traceDir));
   const iteration = parseInt(parentDir, 10) || 0;
   return {
-    taskId: path21.basename(traceDir),
+    taskId: path22.basename(traceDir),
     iteration,
     stdout,
     stderr,
@@ -5111,12 +5169,12 @@ async function loadTrace(traceDir) {
   };
 }
 async function loadIterationTraces(workspacePath, iteration) {
-  const tracesDir = path21.join(workspacePath, "traces", iteration.toString());
+  const tracesDir = path22.join(workspacePath, "traces", iteration.toString());
   const traces = [];
   try {
-    const taskDirs = await fs21.readdir(tracesDir);
+    const taskDirs = await fs22.readdir(tracesDir);
     for (const taskId of taskDirs) {
-      const trace = await loadTrace(path21.join(tracesDir, taskId));
+      const trace = await loadTrace(path22.join(tracesDir, taskId));
       traces.push(trace);
     }
   } catch {
@@ -5124,39 +5182,39 @@ async function loadIterationTraces(workspacePath, iteration) {
   return traces;
 }
 async function writeTrace(traceDir, trace) {
-  await fs21.mkdir(traceDir, { recursive: true });
-  await fs21.writeFile(path21.join(traceDir, "stdout.log"), trace.stdout, "utf-8");
-  await fs21.writeFile(path21.join(traceDir, "stderr.log"), trace.stderr, "utf-8");
+  await fs22.mkdir(traceDir, { recursive: true });
+  await fs22.writeFile(path22.join(traceDir, "stdout.log"), trace.stdout, "utf-8");
+  await fs22.writeFile(path22.join(traceDir, "stderr.log"), trace.stderr, "utf-8");
   const toolCallsLines = trace.toolCalls.map((tc) => JSON.stringify(tc)).join("\n");
-  await fs21.writeFile(path21.join(traceDir, "tool_calls.jsonl"), toolCallsLines, "utf-8");
-  await fs21.writeFile(
-    path21.join(traceDir, "files_changed.json"),
+  await fs22.writeFile(path22.join(traceDir, "tool_calls.jsonl"), toolCallsLines, "utf-8");
+  await fs22.writeFile(
+    path22.join(traceDir, "files_changed.json"),
     JSON.stringify(trace.filesChanged, null, 2),
     "utf-8"
   );
-  await fs21.writeFile(
-    path21.join(traceDir, "timing.json"),
+  await fs22.writeFile(
+    path22.join(traceDir, "timing.json"),
     JSON.stringify(trace.timing, null, 2),
     "utf-8"
   );
-  await fs21.writeFile(
-    path21.join(traceDir, "score.json"),
+  await fs22.writeFile(
+    path22.join(traceDir, "score.json"),
     JSON.stringify(trace.score, null, 2),
     "utf-8"
   );
 }
 async function writeScore(traceDir, score) {
-  await fs21.writeFile(
-    path21.join(traceDir, "score.json"),
+  await fs22.writeFile(
+    path22.join(traceDir, "score.json"),
     JSON.stringify(score, null, 2),
     "utf-8"
   );
 }
 async function writeIterationLog(workspacePath, log) {
-  const iterDir = path21.join(workspacePath, "iterations", log.iteration.toString());
-  await fs21.mkdir(iterDir, { recursive: true });
-  await fs21.writeFile(
-    path21.join(iterDir, "scores.json"),
+  const iterDir = path22.join(workspacePath, "iterations", log.iteration.toString());
+  await fs22.mkdir(iterDir, { recursive: true });
+  await fs22.writeFile(
+    path22.join(iterDir, "scores.json"),
     JSON.stringify({
       score: log.score,
       taskResults: log.taskResults,
@@ -5164,27 +5222,27 @@ async function writeIterationLog(workspacePath, log) {
     }, null, 2),
     "utf-8"
   );
-  await fs21.writeFile(
-    path21.join(iterDir, "proposer_reasoning.md"),
+  await fs22.writeFile(
+    path22.join(iterDir, "proposer_reasoning.md"),
     log.proposal?.reasoning ?? "Baseline evaluation (no proposal)",
     "utf-8"
   );
-  await fs21.writeFile(
-    path21.join(iterDir, "mutation_diff.patch"),
+  await fs22.writeFile(
+    path22.join(iterDir, "mutation_diff.patch"),
     log.diffPatch ?? "",
     "utf-8"
   );
 }
 async function loadIterationLog(workspacePath, iteration) {
-  const iterDir = path21.join(workspacePath, "iterations", iteration.toString());
+  const iterDir = path22.join(workspacePath, "iterations", iteration.toString());
   try {
-    await fs21.access(iterDir);
+    await fs22.access(iterDir);
   } catch {
     return null;
   }
-  const scoresStr = await fs21.readFile(path21.join(iterDir, "scores.json"), "utf-8").catch(() => "{}");
-  const reasoning = await fs21.readFile(path21.join(iterDir, "proposer_reasoning.md"), "utf-8").catch(() => "");
-  const diffPatch = await fs21.readFile(path21.join(iterDir, "mutation_diff.patch"), "utf-8").catch(() => "");
+  const scoresStr = await fs22.readFile(path22.join(iterDir, "scores.json"), "utf-8").catch(() => "{}");
+  const reasoning = await fs22.readFile(path22.join(iterDir, "proposer_reasoning.md"), "utf-8").catch(() => "");
+  const diffPatch = await fs22.readFile(path22.join(iterDir, "mutation_diff.patch"), "utf-8").catch(() => "");
   const scoresData = JSON.parse(scoresStr);
   const proposal = reasoning ? { reasoning, mutations: [], expectedImpact: {} } : null;
   return {
@@ -5555,12 +5613,12 @@ Return ONLY valid JSON:
 // src/evolve/runner.ts
 import { exec as exec3, spawn } from "child_process";
 import { promisify as promisify3 } from "util";
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import os4 from "os";
-import path22 from "path";
+import path23 from "path";
 async function deployMcpJson(harnessPath, workDir) {
-  const src = path22.join(harnessPath, ".mcp.json");
-  await fs22.copyFile(src, path22.join(workDir, ".mcp.json")).catch(() => {
+  const src = path23.join(harnessPath, ".mcp.json");
+  await fs23.copyFile(src, path23.join(workDir, ".mcp.json")).catch(() => {
   });
 }
 async function createIsolatedWorkspace(projectRoot, harnessPath) {
@@ -5570,40 +5628,40 @@ async function createIsolatedWorkspace(projectRoot, harnessPath) {
       cwd: projectRoot,
       timeout: 5e3
     });
-    const tmpDir2 = path22.join(os4.tmpdir(), `kairn-evolve-wt-${suffix}`);
+    const tmpDir2 = path23.join(os4.tmpdir(), `kairn-evolve-wt-${suffix}`);
     await execAsync3(`git worktree add --detach "${tmpDir2}" HEAD`, {
       cwd: projectRoot,
       timeout: 3e4
     });
-    await fs22.rm(path22.join(tmpDir2, ".claude"), { recursive: true, force: true });
-    await copyDir(harnessPath, path22.join(tmpDir2, ".claude"));
+    await fs23.rm(path23.join(tmpDir2, ".claude"), { recursive: true, force: true });
+    await copyDir(harnessPath, path23.join(tmpDir2, ".claude"));
     await deployMcpJson(harnessPath, tmpDir2);
     return { workDir: tmpDir2, isWorktree: true };
   } catch {
   }
-  const tmpDir = await fs22.mkdtemp(path22.join(os4.tmpdir(), `kairn-evolve-cp-`));
+  const tmpDir = await fs23.mkdtemp(path23.join(os4.tmpdir(), `kairn-evolve-cp-`));
   await copyProjectDir(projectRoot, tmpDir);
-  await fs22.rm(path22.join(tmpDir, ".claude"), { recursive: true, force: true });
-  await copyDir(harnessPath, path22.join(tmpDir, ".claude"));
+  await fs23.rm(path23.join(tmpDir, ".claude"), { recursive: true, force: true });
+  await copyDir(harnessPath, path23.join(tmpDir, ".claude"));
   await deployMcpJson(harnessPath, tmpDir);
   return { workDir: tmpDir, isWorktree: false };
 }
 async function copyProjectDir(src, dest) {
-  await fs22.mkdir(dest, { recursive: true });
+  await fs23.mkdir(dest, { recursive: true });
   let entries;
   try {
-    entries = await fs22.readdir(src, { withFileTypes: true });
+    entries = await fs23.readdir(src, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (COPY_SKIP_DIRS.has(entry.name)) continue;
-    const srcPath = path22.join(src, entry.name);
-    const destPath = path22.join(dest, entry.name);
+    const srcPath = path23.join(src, entry.name);
+    const destPath = path23.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDir(srcPath, destPath);
     } else {
-      await fs22.copyFile(srcPath, destPath);
+      await fs23.copyFile(srcPath, destPath);
     }
   }
 }
@@ -5615,7 +5673,7 @@ async function cleanupIsolatedWorkspace(workDir, isWorktree, projectRoot) {
         timeout: 1e4
       });
     } catch {
-      await fs22.rm(workDir, { recursive: true, force: true }).catch(() => {
+      await fs23.rm(workDir, { recursive: true, force: true }).catch(() => {
       });
       await execAsync3("git worktree prune", {
         cwd: projectRoot,
@@ -5624,12 +5682,12 @@ async function cleanupIsolatedWorkspace(workDir, isWorktree, projectRoot) {
       });
     }
   } else {
-    await fs22.rm(workDir, { recursive: true, force: true }).catch(() => {
+    await fs23.rm(workDir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
 async function runTask(task, harnessPath, traceDir, iteration, projectRoot) {
-  await fs22.mkdir(traceDir, { recursive: true });
+  await fs23.mkdir(traceDir, { recursive: true });
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const startMs = Date.now();
   const root = projectRoot ?? process.cwd();
@@ -5709,13 +5767,13 @@ async function snapshotFileList(dir) {
   async function walk(current) {
     let entries;
     try {
-      entries = await fs22.readdir(current, { withFileTypes: true });
+      entries = await fs23.readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path22.join(current, entry.name);
-      const relativePath = path22.relative(dir, fullPath);
+      const fullPath = path23.join(current, entry.name);
+      const relativePath = path23.relative(dir, fullPath);
       if (relativePath.startsWith(".claude")) continue;
       if (relativePath.startsWith("node_modules")) continue;
       if (relativePath.startsWith(".git")) continue;
@@ -5723,7 +5781,7 @@ async function snapshotFileList(dir) {
         await walk(fullPath);
       } else {
         try {
-          const stat = await fs22.stat(fullPath);
+          const stat = await fs23.stat(fullPath);
           result[relativePath] = stat.mtimeMs;
         } catch {
         }
@@ -5802,7 +5860,7 @@ function computeStddev(values, mean) {
 }
 async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config, onProgress, runsPerTask = 1, parallelTasks = 1) {
   const results = {};
-  const projectRoot = path22.resolve(workspacePath, "..");
+  const projectRoot = path23.resolve(workspacePath, "..");
   const effectiveRuns = Math.max(1, runsPerTask);
   const concurrency = Math.max(1, parallelTasks);
   const evaluateTask = async (task) => {
@@ -5812,7 +5870,7 @@ async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config,
       const runScores = [];
       let passCount = 0;
       for (let run = 0; run < effectiveRuns; run++) {
-        const traceDir = path22.join(
+        const traceDir = path23.join(
           workspacePath,
           "traces",
           iteration.toString(),
@@ -5825,8 +5883,8 @@ async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config,
           message: `Run ${run + 1}/${effectiveRuns} of ${task.id}`
         });
         await runTask(task, harnessPath, traceDir, iteration, projectRoot);
-        const stdout = await fs22.readFile(path22.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
-        const stderr = await fs22.readFile(path22.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
+        const stdout = await fs23.readFile(path23.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
+        const stderr = await fs23.readFile(path23.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
         const score = await scoreTask(task, traceDir, stdout, stderr, config);
         await writeScore(traceDir, score);
         runScores.push(score.score ?? (score.pass ? 100 : 0));
@@ -5846,7 +5904,7 @@ async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config,
         }
       };
     } else {
-      const traceDir = path22.join(
+      const traceDir = path23.join(
         workspacePath,
         "traces",
         iteration.toString(),
@@ -5855,8 +5913,8 @@ async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config,
       const taskResult = await runTask(task, harnessPath, traceDir, iteration, projectRoot);
       finalScore = taskResult.score;
       if (config) {
-        const stdout = await fs22.readFile(path22.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
-        const stderr = await fs22.readFile(path22.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
+        const stdout = await fs23.readFile(path23.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
+        const stderr = await fs23.readFile(path23.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
         finalScore = await scoreTask(task, traceDir, stdout, stderr, config);
         await writeScore(traceDir, finalScore);
       }
@@ -5904,12 +5962,12 @@ __export(memory_exports, {
   loadProposerMemory: () => loadProposerMemory,
   saveRunSummary: () => saveRunSummary
 });
-import fs23 from "fs/promises";
-import path23 from "path";
+import fs24 from "fs/promises";
+import path24 from "path";
 async function loadProposerMemory(workspacePath) {
-  const memoryPath = path23.join(workspacePath, MEMORY_FILE);
+  const memoryPath = path24.join(workspacePath, MEMORY_FILE);
   try {
-    const raw = await fs23.readFile(memoryPath, "utf-8");
+    const raw = await fs24.readFile(memoryPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (Array.isArray(parsed)) return parsed;
     return [];
@@ -5948,8 +6006,8 @@ async function saveRunSummary(workspacePath, summary) {
   const existing = await loadProposerMemory(workspacePath);
   existing.push(summary);
   const trimmed = existing.slice(-MAX_ENTRIES);
-  const memoryPath = path23.join(workspacePath, MEMORY_FILE);
-  await fs23.writeFile(memoryPath, JSON.stringify(trimmed, null, 2), "utf-8");
+  const memoryPath = path24.join(workspacePath, MEMORY_FILE);
+  await fs24.writeFile(memoryPath, JSON.stringify(trimmed, null, 2), "utf-8");
 }
 function formatMemoryForProposer(memory) {
   if (memory.length === 0) return "";
@@ -5994,26 +6052,26 @@ __export(knowledge_exports, {
   savePattern: () => savePattern,
   saveProjectHistory: () => saveProjectHistory
 });
-import fs24 from "fs/promises";
-import path24 from "path";
+import fs25 from "fs/promises";
+import path25 from "path";
 import crypto2 from "crypto";
 function getKnowledgeDir() {
-  return path24.join(getKairnDir(), "knowledge");
+  return path25.join(getKairnDir(), "knowledge");
 }
 function getPatternsPath() {
-  return path24.join(getKnowledgeDir(), "patterns.jsonl");
+  return path25.join(getKnowledgeDir(), "patterns.jsonl");
 }
 function getProjectsDir() {
-  return path24.join(getKnowledgeDir(), "projects");
+  return path25.join(getKnowledgeDir(), "projects");
 }
 function getConvergencePath() {
-  return path24.join(getKnowledgeDir(), "convergence.json");
+  return path25.join(getKnowledgeDir(), "convergence.json");
 }
 async function loadKnowledgeBase(filter) {
   const patternsPath = getPatternsPath();
   let content;
   try {
-    content = await fs24.readFile(patternsPath, "utf-8");
+    content = await fs25.readFile(patternsPath, "utf-8");
   } catch {
     return [];
   }
@@ -6033,9 +6091,9 @@ async function loadKnowledgeBase(filter) {
 }
 async function savePattern(pattern) {
   const dir = getKnowledgeDir();
-  await fs24.mkdir(dir, { recursive: true });
+  await fs25.mkdir(dir, { recursive: true });
   const patternsPath = getPatternsPath();
-  await fs24.appendFile(patternsPath, JSON.stringify(pattern) + "\n", "utf-8");
+  await fs25.appendFile(patternsPath, JSON.stringify(pattern) + "\n", "utf-8");
 }
 async function extractAndSavePatterns(history, projectName, language) {
   const patterns = [];
@@ -6107,13 +6165,13 @@ function formatKnowledgeForArchitect(patterns, language) {
 }
 async function saveProjectHistory(projectName, summary) {
   const projectsDir = getProjectsDir();
-  await fs24.mkdir(projectsDir, { recursive: true });
-  const filePath = path24.join(projectsDir, `${projectName}.json`);
-  await fs24.writeFile(filePath, JSON.stringify(summary, null, 2), "utf-8");
+  await fs25.mkdir(projectsDir, { recursive: true });
+  const filePath = path25.join(projectsDir, `${projectName}.json`);
+  await fs25.writeFile(filePath, JSON.stringify(summary, null, 2), "utf-8");
 }
 async function loadConvergence() {
   try {
-    const content = await fs24.readFile(getConvergencePath(), "utf-8");
+    const content = await fs25.readFile(getConvergencePath(), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -6121,8 +6179,8 @@ async function loadConvergence() {
 }
 async function saveConvergence(convergence) {
   const dir = getKnowledgeDir();
-  await fs24.mkdir(dir, { recursive: true });
-  await fs24.writeFile(
+  await fs25.mkdir(dir, { recursive: true });
+  await fs25.writeFile(
     getConvergencePath(),
     JSON.stringify(convergence, null, 2),
     "utf-8"
@@ -6136,25 +6194,112 @@ var init_knowledge = __esm({
 });
 
 // src/evolve/proposer.ts
-import fs25 from "fs/promises";
-import path25 from "path";
+import fs26 from "fs/promises";
+import path26 from "path";
+function countSettingsHooks(settings) {
+  let count = 0;
+  const categories = settings.hooks;
+  for (const key of Object.keys(categories)) {
+    const entries = categories[key];
+    if (entries) {
+      count += entries.length;
+    }
+  }
+  return count;
+}
+function buildIRSummary(ir) {
+  const lines = [];
+  lines.push("## Harness Structure (IR)");
+  const meta = ir.meta;
+  const techParts = [meta.techStack.language];
+  if (meta.techStack.framework) techParts.push(meta.techStack.framework);
+  if (meta.techStack.buildTool) techParts.push(meta.techStack.buildTool);
+  lines.push(`Project: ${meta.name || "(unnamed)"} \u2014 ${techParts.join(", ")}`);
+  const sectionIds = ir.sections.map((s) => s.id);
+  lines.push(`Sections (${ir.sections.length}): ${sectionIds.join(", ") || "none"}`);
+  const commandSummaries = ir.commands.map((c) => c.name);
+  lines.push(`Commands (${ir.commands.length}): ${commandSummaries.join(", ") || "none"}`);
+  const ruleSummaries = ir.rules.map((r) => {
+    const pathHint = r.paths && r.paths.length > 0 ? ` (${r.paths.join(", ")})` : "";
+    return `${r.name}${pathHint}`;
+  });
+  lines.push(`Rules (${ir.rules.length}): ${ruleSummaries.join(", ") || "none"}`);
+  const agentNames = ir.agents.map((a) => a.name);
+  lines.push(`Agents (${ir.agents.length}): ${agentNames.join(", ") || "none"}`);
+  const serverNames = ir.mcpServers.map((s) => s.id);
+  lines.push(`MCP Servers (${ir.mcpServers.length}): ${serverNames.join(", ") || "none"}`);
+  if (ir.skills.length > 0) {
+    const skillNames = ir.skills.map((s) => s.name);
+    lines.push(`Skills (${ir.skills.length}): ${skillNames.join(", ")}`);
+  }
+  if (ir.docs.length > 0) {
+    const docNames = ir.docs.map((d) => d.name);
+    lines.push(`Docs (${ir.docs.length}): ${docNames.join(", ")}`);
+  }
+  if (ir.hooks.length > 0) {
+    const hookNames = ir.hooks.map((h) => h.name);
+    lines.push(`Hooks (${ir.hooks.length}): ${hookNames.join(", ")}`);
+  }
+  const settingsParts = [];
+  if (ir.settings.statusLine) {
+    settingsParts.push("statusLine=enabled");
+  }
+  if (ir.settings.denyPatterns && ir.settings.denyPatterns.length > 0) {
+    settingsParts.push(`denyPatterns=${ir.settings.denyPatterns.length}`);
+  }
+  const hooksCount = countSettingsHooks(ir.settings);
+  if (hooksCount > 0) {
+    settingsParts.push(`hooks=${hooksCount}`);
+  }
+  lines.push(`Settings: ${settingsParts.join(", ") || "default"}`);
+  return lines.join("\n");
+}
+function formatAnalysisForProposer(analysis) {
+  const lines = [];
+  lines.push(`Purpose: ${analysis.purpose}`);
+  lines.push(`Domain: ${analysis.domain}`);
+  lines.push(`Architecture: ${analysis.architecture_style}`);
+  lines.push(`Deployment: ${analysis.deployment_model}`);
+  if (analysis.key_modules.length > 0) {
+    lines.push("");
+    lines.push("Key Modules:");
+    for (const mod of analysis.key_modules) {
+      lines.push(`- ${mod.name} (${mod.path}): ${mod.description}`);
+    }
+  }
+  if (analysis.workflows.length > 0) {
+    lines.push("");
+    lines.push("Workflows:");
+    for (const wf of analysis.workflows) {
+      lines.push(`- ${wf.name}: ${wf.description} (trigger: ${wf.trigger})`);
+    }
+  }
+  if (analysis.config_keys.length > 0) {
+    lines.push("");
+    lines.push("Config Keys:");
+    for (const key of analysis.config_keys) {
+      lines.push(`- ${key.name}: ${key.purpose}`);
+    }
+  }
+  return lines.join("\n");
+}
 async function readHarnessFiles(harnessPath) {
   const result = {};
   async function walk(dir, prefix) {
     let entries;
     try {
-      entries = await fs25.readdir(dir, { withFileTypes: true });
+      entries = await fs26.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const relativePath = prefix ? path25.join(prefix, entry.name) : entry.name;
-      const fullPath = path25.join(dir, entry.name);
+      const relativePath = prefix ? path26.join(prefix, entry.name) : entry.name;
+      const fullPath = path26.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath, relativePath);
       } else if (entry.isFile()) {
         try {
-          result[relativePath] = await fs25.readFile(fullPath, "utf-8");
+          result[relativePath] = await fs26.readFile(fullPath, "utf-8");
         } catch {
         }
       }
@@ -6170,7 +6315,7 @@ function truncateStdout(stdout, limit) {
   return `[...truncated, showing last ${limit} chars...]
 ${stdout.slice(-limit)}`;
 }
-function buildProposerUserMessage(harnessFiles, traces, tasks, history, memorySection) {
+function buildProposerUserMessage(harnessFiles, traces, tasks, history, memorySection, projectContext) {
   const harnessSection = ["## Current Harness Files\n"];
   const fileEntries = Object.entries(harnessFiles);
   if (fileEntries.length === 0) {
@@ -6197,7 +6342,24 @@ ${content}
       );
     }
   }
-  const fixedContent = harnessSection.join("\n") + "\n" + taskSection.join("\n");
+  let projectSection = "";
+  if (projectContext) {
+    const parts = ["## Project Understanding\n"];
+    parts.push("### Analysis Summary");
+    parts.push(formatAnalysisForProposer(projectContext.analysis));
+    parts.push("");
+    parts.push("### Harness Structure");
+    parts.push(projectContext.irSummary);
+    if (projectContext.keySourceFiles) {
+      parts.push("");
+      parts.push("### Key Source Files");
+      parts.push("```");
+      parts.push(projectContext.keySourceFiles);
+      parts.push("```");
+    }
+    projectSection = "\n" + parts.join("\n") + "\n";
+  }
+  const fixedContent = harnessSection.join("\n") + "\n" + taskSection.join("\n") + projectSection;
   const remainingBudget = MAX_CONTEXT_CHARS - fixedContent.length;
   if (remainingBudget <= 0) {
     return fixedContent + "\n\n[...traces and history omitted \u2014 harness + tasks fill context budget...]";
@@ -6359,7 +6521,7 @@ function parseProposerResponse(raw) {
     expectedImpact
   };
 }
-async function propose(iteration, workspacePath, harnessPath, history, tasks, config, proposerModel) {
+async function propose(iteration, workspacePath, harnessPath, history, tasks, config, proposerModel, projectContext) {
   const harnessFiles = await readHarnessFiles(harnessPath);
   const traces = await loadIterationTraces(workspacePath, iteration);
   const { loadProposerMemory: loadProposerMemory2, formatMemoryForProposer: formatMemoryForProposer2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
@@ -6373,7 +6535,7 @@ async function propose(iteration, workspacePath, harnessPath, history, tasks, co
   } catch {
   }
   const combinedMemory = memorySection + (knowledgeSection ? "\n" + knowledgeSection : "");
-  const userMessage = buildProposerUserMessage(harnessFiles, traces, tasks, history, combinedMemory || void 0);
+  const userMessage = buildProposerUserMessage(harnessFiles, traces, tasks, history, combinedMemory || void 0, projectContext);
   const proposerConfig = { ...config, model: proposerModel };
   const response = await callLLM(proposerConfig, userMessage, {
     systemPrompt: PROPOSER_SYSTEM_PROMPT,
@@ -6460,8 +6622,8 @@ Return ONLY valid JSON.`;
 });
 
 // src/ir/parser.ts
-import fs26 from "fs/promises";
-import path26 from "path";
+import fs27 from "fs/promises";
+import path27 from "path";
 function slugify(heading) {
   return heading.toLowerCase().trim().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
@@ -6723,33 +6885,33 @@ function parseMcpConfig(content) {
 }
 async function readDirSafe(dirPath) {
   try {
-    return await fs26.readdir(dirPath);
+    return await fs27.readdir(dirPath);
   } catch {
     return [];
   }
 }
 async function readFileSafe2(filePath) {
   try {
-    return await fs26.readFile(filePath, "utf-8");
+    return await fs27.readFile(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 async function isDirectory(filePath) {
   try {
-    const stat = await fs26.stat(filePath);
+    const stat = await fs27.stat(filePath);
     return stat.isDirectory();
   } catch {
     return false;
   }
 }
 async function parseCommands(harnessPath) {
-  const dirPath = path26.join(harnessPath, "commands");
+  const dirPath = path27.join(harnessPath, "commands");
   const entries = await readDirSafe(dirPath);
   const nodes = [];
   for (const entry of entries) {
     if (!entry.endsWith(".md")) continue;
-    const filePath = path26.join(dirPath, entry);
+    const filePath = path27.join(dirPath, entry);
     const content = await readFileSafe2(filePath);
     if (content === null) continue;
     const name = entry.replace(/\.md$/, "");
@@ -6760,12 +6922,12 @@ async function parseCommands(harnessPath) {
   return nodes;
 }
 async function parseRules(harnessPath) {
-  const dirPath = path26.join(harnessPath, "rules");
+  const dirPath = path27.join(harnessPath, "rules");
   const entries = await readDirSafe(dirPath);
   const nodes = [];
   for (const entry of entries) {
     if (!entry.endsWith(".md")) continue;
-    const filePath = path26.join(dirPath, entry);
+    const filePath = path27.join(dirPath, entry);
     const rawContent = await readFileSafe2(filePath);
     if (rawContent === null) continue;
     const name = entry.replace(/\.md$/, "");
@@ -6780,12 +6942,12 @@ async function parseRules(harnessPath) {
   return nodes;
 }
 async function parseAgents(harnessPath) {
-  const dirPath = path26.join(harnessPath, "agents");
+  const dirPath = path27.join(harnessPath, "agents");
   const entries = await readDirSafe(dirPath);
   const nodes = [];
   for (const entry of entries) {
     if (!entry.endsWith(".md")) continue;
-    const filePath = path26.join(dirPath, entry);
+    const filePath = path27.join(dirPath, entry);
     const rawContent = await readFileSafe2(filePath);
     if (rawContent === null) continue;
     const fileBaseName = entry.replace(/\.md$/, "");
@@ -6829,20 +6991,20 @@ async function parseAgents(harnessPath) {
   return nodes;
 }
 async function parseSkills(harnessPath) {
-  const dirPath = path26.join(harnessPath, "skills");
+  const dirPath = path27.join(harnessPath, "skills");
   const entries = await readDirSafe(dirPath);
   const nodes = [];
   for (const entry of entries) {
-    const entryPath = path26.join(dirPath, entry);
+    const entryPath = path27.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)) {
-      let content = await readFileSafe2(path26.join(entryPath, "skill.md"));
+      let content = await readFileSafe2(path27.join(entryPath, "skill.md"));
       if (content === null) {
-        content = await readFileSafe2(path26.join(entryPath, "SKILL.md"));
+        content = await readFileSafe2(path27.join(entryPath, "SKILL.md"));
       }
       if (content === null) continue;
       nodes.push({ name: entry, content });
@@ -6851,12 +7013,12 @@ async function parseSkills(harnessPath) {
   return nodes;
 }
 async function parseDocs(harnessPath) {
-  const dirPath = path26.join(harnessPath, "docs");
+  const dirPath = path27.join(harnessPath, "docs");
   const entries = await readDirSafe(dirPath);
   const nodes = [];
   for (const entry of entries) {
     if (!entry.endsWith(".md")) continue;
-    const filePath = path26.join(dirPath, entry);
+    const filePath = path27.join(dirPath, entry);
     const content = await readFileSafe2(filePath);
     if (content === null) continue;
     const name = entry.replace(/\.md$/, "");
@@ -6865,12 +7027,12 @@ async function parseDocs(harnessPath) {
   return nodes;
 }
 async function parseHooks(harnessPath) {
-  const dirPath = path26.join(harnessPath, "hooks");
+  const dirPath = path27.join(harnessPath, "hooks");
   const entries = await readDirSafe(dirPath);
   const nodes = [];
   for (const entry of entries) {
     if (!entry.endsWith(".mjs")) continue;
-    const filePath = path26.join(dirPath, entry);
+    const filePath = path27.join(dirPath, entry);
     const content = await readFileSafe2(filePath);
     if (content === null) continue;
     const name = entry.replace(/\.mjs$/, "");
@@ -6881,7 +7043,7 @@ async function parseHooks(harnessPath) {
 async function parseHarness(harnessPath) {
   const ir = createEmptyIR();
   const claudeMdContent = await readFileSafe2(
-    path26.join(harnessPath, "CLAUDE.md")
+    path27.join(harnessPath, "CLAUDE.md")
   );
   if (claudeMdContent !== null) {
     const { meta, sections } = parseClaudeMd(claudeMdContent);
@@ -6893,7 +7055,7 @@ async function parseHarness(harnessPath) {
     ir.sections = sections;
   }
   const settingsContent = await readFileSafe2(
-    path26.join(harnessPath, "settings.json")
+    path27.join(harnessPath, "settings.json")
   );
   if (settingsContent !== null) {
     ir.settings = parseSettings(settingsContent);
@@ -6914,7 +7076,7 @@ async function parseHarness(harnessPath) {
   ir.hooks = hooks;
   const mcpServers = [];
   const seenIds = /* @__PURE__ */ new Set();
-  const parentMcpPath = path26.join(path26.dirname(harnessPath), ".mcp.json");
+  const parentMcpPath = path27.join(path27.dirname(harnessPath), ".mcp.json");
   const parentMcpContent = await readFileSafe2(parentMcpPath);
   if (parentMcpContent !== null) {
     for (const node of parseMcpConfig(parentMcpContent)) {
@@ -6924,7 +7086,7 @@ async function parseHarness(harnessPath) {
       }
     }
   }
-  const innerMcpPath = path26.join(harnessPath, ".mcp.json");
+  const innerMcpPath = path27.join(harnessPath, ".mcp.json");
   const innerMcpContent = await readFileSafe2(innerMcpPath);
   if (innerMcpContent !== null) {
     for (const node of parseMcpConfig(innerMcpContent)) {
@@ -7161,8 +7323,8 @@ function deepSet(obj, segments, value) {
   const child = existing !== null && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
   return { ...obj, [head]: deepSet(child, rest, value) };
 }
-function applySettingsUpdate(settings, path37, value) {
-  const segments = path37.split(".");
+function applySettingsUpdate(settings, path39, value) {
+  const segments = path39.split(".");
   const topKey = segments[0];
   if (STRUCTURED_SETTINGS_KEYS.has(topKey)) {
     const settingsRecord = { ...settings };
@@ -7620,10 +7782,10 @@ var init_diff = __esm({
 });
 
 // src/evolve/mutator.ts
-import fs27 from "fs/promises";
-import path27 from "path";
+import fs28 from "fs/promises";
+import path28 from "path";
 async function applyMutations(currentHarnessPath, nextIterationDir, mutations) {
-  const newHarnessPath = path27.join(nextIterationDir, "harness");
+  const newHarnessPath = path28.join(nextIterationDir, "harness");
   let baselineIR = null;
   try {
     baselineIR = await parseHarness(currentHarnessPath);
@@ -7664,6 +7826,11 @@ async function applyMutationsViaIR(currentHarnessPath, newHarnessPath, mutations
   for (const mutation of rawTextMutations) {
     await applyLegacyMutation(newHarnessPath, mutation);
   }
+  await fs28.writeFile(
+    path28.join(newHarnessPath, "..", "harness-ir.json"),
+    JSON.stringify(currentIR, null, 2),
+    "utf-8"
+  );
   const irDiff = diffIR(baselineIR, currentIR);
   let diffPatch = formatIRDiff(irDiff);
   if (diffPatch === "No changes." && rawTextMutations.length > 0) {
@@ -7700,9 +7867,9 @@ async function renderAffectedFiles(ir, targetDir, touchedCategories) {
   for (const [relativePath, content] of fileMap) {
     const category = getFileCategory(relativePath);
     if (touchedCategories.has(category)) {
-      const fullPath = path27.join(targetDir, relativePath);
-      await fs27.mkdir(path27.dirname(fullPath), { recursive: true });
-      await fs27.writeFile(fullPath, content, "utf-8");
+      const fullPath = path28.join(targetDir, relativePath);
+      await fs28.mkdir(path28.dirname(fullPath), { recursive: true });
+      await fs28.writeFile(fullPath, content, "utf-8");
     }
   }
   if (touchedCategories.has("commands")) {
@@ -7715,11 +7882,11 @@ async function renderAffectedFiles(ir, targetDir, touchedCategories) {
     await deleteOrphanedFiles(targetDir, "agents", fileMap);
   }
   if (touchedCategories.has("mcp") && !fileMap.has(".mcp.json")) {
-    await fs27.unlink(path27.join(targetDir, ".mcp.json")).catch(() => {
+    await fs28.unlink(path28.join(targetDir, ".mcp.json")).catch(() => {
     });
   }
   if (touchedCategories.has("settings") && !fileMap.has("settings.json")) {
-    await fs27.unlink(path27.join(targetDir, "settings.json")).catch(() => {
+    await fs28.unlink(path28.join(targetDir, "settings.json")).catch(() => {
     });
   }
 }
@@ -7736,17 +7903,17 @@ function getFileCategory(relativePath) {
   return "unknown";
 }
 async function deleteOrphanedFiles(targetDir, subdir, renderedMap) {
-  const subdirPath = path27.join(targetDir, subdir);
+  const subdirPath = path28.join(targetDir, subdir);
   let entries;
   try {
-    entries = await fs27.readdir(subdirPath);
+    entries = await fs28.readdir(subdirPath);
   } catch {
     return;
   }
   for (const entry of entries) {
     const relativePath = `${subdir}/${entry}`;
     if (!renderedMap.has(relativePath)) {
-      await fs27.unlink(path27.join(subdirPath, entry)).catch(() => {
+      await fs28.unlink(path28.join(subdirPath, entry)).catch(() => {
       });
     }
   }
@@ -7763,56 +7930,56 @@ async function applyLegacyMutation(harnessPath, mutation) {
   if (mutation.file.includes("..")) {
     return;
   }
-  const filePath = path27.join(harnessPath, mutation.file);
+  const filePath = path28.join(harnessPath, mutation.file);
   if (mutation.action === "replace") {
     if (!mutation.oldText) {
       return;
     }
     let content;
     try {
-      content = await fs27.readFile(filePath, "utf-8");
+      content = await fs28.readFile(filePath, "utf-8");
     } catch {
       return;
     }
     if (!content.includes(mutation.oldText)) {
       return;
     }
-    await fs27.writeFile(
+    await fs28.writeFile(
       filePath,
       content.replace(mutation.oldText, mutation.newText),
       "utf-8"
     );
   } else if (mutation.action === "add_section") {
     try {
-      const content = await fs27.readFile(filePath, "utf-8");
-      await fs27.writeFile(
+      const content = await fs28.readFile(filePath, "utf-8");
+      await fs28.writeFile(
         filePath,
         content + "\n\n" + mutation.newText,
         "utf-8"
       );
     } catch {
-      await fs27.mkdir(path27.dirname(filePath), { recursive: true });
-      await fs27.writeFile(filePath, mutation.newText, "utf-8");
+      await fs28.mkdir(path28.dirname(filePath), { recursive: true });
+      await fs28.writeFile(filePath, mutation.newText, "utf-8");
     }
   } else if (mutation.action === "create_file") {
-    await fs27.mkdir(path27.dirname(filePath), { recursive: true });
-    await fs27.writeFile(filePath, mutation.newText, "utf-8");
+    await fs28.mkdir(path28.dirname(filePath), { recursive: true });
+    await fs28.writeFile(filePath, mutation.newText, "utf-8");
   } else if (mutation.action === "delete_section") {
     if (!mutation.oldText) {
       return;
     }
     let sectionContent;
     try {
-      sectionContent = await fs27.readFile(filePath, "utf-8");
+      sectionContent = await fs28.readFile(filePath, "utf-8");
     } catch {
       return;
     }
     if (!sectionContent.includes(mutation.oldText)) {
       return;
     }
-    await fs27.writeFile(filePath, sectionContent.replace(mutation.oldText, ""), "utf-8");
+    await fs28.writeFile(filePath, sectionContent.replace(mutation.oldText, ""), "utf-8");
   } else if (mutation.action === "delete_file") {
-    await fs27.unlink(filePath).catch(() => {
+    await fs28.unlink(filePath).catch(() => {
     });
   }
 }
@@ -7880,17 +8047,17 @@ async function readAllFiles(dir) {
   async function walk(current) {
     let entries;
     try {
-      entries = await fs27.readdir(current, { withFileTypes: true });
+      entries = await fs28.readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path27.join(current, entry.name);
-      const relativePath = path27.relative(dir, fullPath);
+      const fullPath = path28.join(current, entry.name);
+      const relativePath = path28.relative(dir, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
-        result[relativePath] = await fs27.readFile(fullPath, "utf-8");
+        result[relativePath] = await fs28.readFile(fullPath, "utf-8");
       }
     }
   }
@@ -8030,7 +8197,7 @@ ${taskScores}
   }
   return "## Iteration History\n\n(History omitted to fit context budget)\n";
 }
-function buildArchitectUserMessage(harnessFiles, traces, tasks, history, knowledgeContext) {
+function buildArchitectUserMessage(harnessFiles, traces, tasks, history, knowledgeContext, projectContext) {
   const harnessSection = ["## Current Harness Files\n"];
   const fileEntries = Object.entries(harnessFiles);
   if (fileEntries.length === 0) {
@@ -8059,11 +8226,28 @@ ${content}
   }
   const summarySection = buildEvolutionSummary(history);
   const workingSection = buildWhatsWorking(history, tasks);
+  let projectSection = "";
+  if (projectContext) {
+    const parts = ["## Project Understanding\n"];
+    parts.push("### Analysis Summary");
+    parts.push(formatAnalysisForProposer(projectContext.analysis));
+    parts.push("");
+    parts.push("### Harness Structure");
+    parts.push(projectContext.irSummary);
+    if (projectContext.keySourceFiles) {
+      parts.push("");
+      parts.push("### Key Source Files");
+      parts.push("```");
+      parts.push(projectContext.keySourceFiles);
+      parts.push("```");
+    }
+    projectSection = "\n" + parts.join("\n") + "\n";
+  }
   const knowledgeSection = knowledgeContext ? `## Knowledge Base (patterns from other projects)
 
 ${knowledgeContext}
 ` : "";
-  const fixedContent = harnessSection.join("\n") + "\n" + taskSection.join("\n") + "\n" + summarySection + (summarySection ? "\n" : "") + workingSection + (workingSection ? "\n" : "") + knowledgeSection;
+  const fixedContent = harnessSection.join("\n") + "\n" + taskSection.join("\n") + "\n" + summarySection + (summarySection ? "\n" : "") + workingSection + (workingSection ? "\n" : "") + projectSection + knowledgeSection;
   const remainingBudget = MAX_CONTEXT_CHARS2 - fixedContent.length;
   if (remainingBudget <= 0) {
     return fixedContent + "\n\n[...traces and history omitted \u2014 context budget exceeded...]";
@@ -8074,7 +8258,7 @@ ${knowledgeContext}
   const historySection = buildHistorySection2(history, historyBudget);
   return fixedContent + "\n" + traceSection + "\n" + historySection;
 }
-async function proposeArchitecture(iteration, workspacePath, harnessPath, history, tasks, config, architectModel, knowledgeContext) {
+async function proposeArchitecture(iteration, workspacePath, harnessPath, history, tasks, config, architectModel, knowledgeContext, projectContext) {
   const harnessFiles = await readHarnessFiles(harnessPath);
   const traces = await loadIterationTraces(workspacePath, iteration);
   let effectiveKnowledge = knowledgeContext;
@@ -8091,7 +8275,8 @@ async function proposeArchitecture(iteration, workspacePath, harnessPath, histor
     traces,
     tasks,
     history,
-    effectiveKnowledge
+    effectiveKnowledge,
+    projectContext
   );
   const architectConfig = { ...config, model: architectModel };
   const response = await callLLM(architectConfig, userMessage, {
@@ -8206,8 +8391,8 @@ var init_schedule = __esm({
 });
 
 // src/evolve/sampling.ts
-import fs28 from "fs/promises";
-import path28 from "path";
+import fs29 from "fs/promises";
+import path29 from "path";
 function initBeliefs(tasks) {
   return tasks.map((task) => ({
     taskId: task.id,
@@ -8268,9 +8453,9 @@ function updateBeliefs(beliefs, results) {
   });
 }
 async function loadBeliefs(workspacePath) {
-  const beliefsPath = path28.join(workspacePath, "task-beliefs.json");
+  const beliefsPath = path29.join(workspacePath, "task-beliefs.json");
   try {
-    const content = await fs28.readFile(beliefsPath, "utf-8");
+    const content = await fs29.readFile(beliefsPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed)) return null;
     for (const entry of parsed) {
@@ -8284,9 +8469,9 @@ async function loadBeliefs(workspacePath) {
   }
 }
 async function saveBeliefs(workspacePath, beliefs) {
-  const beliefsPath = path28.join(workspacePath, "task-beliefs.json");
-  await fs28.mkdir(path28.dirname(beliefsPath), { recursive: true });
-  await fs28.writeFile(beliefsPath, JSON.stringify(beliefs, null, 2), "utf-8");
+  const beliefsPath = path29.join(workspacePath, "task-beliefs.json");
+  await fs29.mkdir(path29.dirname(beliefsPath), { recursive: true });
+  await fs29.writeFile(beliefsPath, JSON.stringify(beliefs, null, 2), "utf-8");
 }
 var init_sampling = __esm({
   "src/evolve/sampling.ts"() {
@@ -8295,8 +8480,8 @@ var init_sampling = __esm({
 });
 
 // src/evolve/regularization.ts
-import fs29 from "fs/promises";
-import path29 from "path";
+import fs30 from "fs/promises";
+import path30 from "path";
 async function measureComplexity(harnessPath) {
   let totalLines = 0;
   let totalFiles = 0;
@@ -8430,18 +8615,18 @@ async function readAllFilesRecursive(dir) {
   async function walk(current) {
     let entries;
     try {
-      entries = await fs29.readdir(current, { withFileTypes: true });
+      entries = await fs30.readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path29.join(current, entry.name);
-      const relativePath = path29.relative(dir, fullPath);
+      const fullPath = path30.join(current, entry.name);
+      const relativePath = path30.relative(dir, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
         try {
-          result[relativePath] = await fs29.readFile(fullPath, "utf-8");
+          result[relativePath] = await fs30.readFile(fullPath, "utf-8");
         } catch {
         }
       }
@@ -8538,14 +8723,56 @@ var init_targeting = __esm({
       "test-writing": ["verification", "commands"],
       "config-change": ["settings", "mcp"],
       "documentation": ["general"],
-      "persistence-completion": ["commands", "verification"]
+      "persistence-completion": ["commands", "verification"],
+      "real-bug-fix": ["general"],
+      "real-feature-add": ["general"],
+      "codebase-question": ["general"]
     };
   }
 });
 
 // src/evolve/loop.ts
-import fs30 from "fs/promises";
-import path30 from "path";
+import fs31 from "fs/promises";
+import path31 from "path";
+async function loadProjectContext(projectDir) {
+  try {
+    const analysisPath = path31.join(projectDir, CACHE_FILENAME);
+    const analysisRaw = await fs31.readFile(analysisPath, "utf-8");
+    const analysisCache = JSON.parse(analysisRaw);
+    const analysis = analysisCache.analysis;
+    let keySourceFiles = "";
+    try {
+      const packedPath = path31.join(projectDir, PACKED_SOURCE_FILENAME);
+      const packedSource = await fs31.readFile(packedPath, "utf-8");
+      keySourceFiles = packedSource.slice(0, KEY_SOURCE_CHARS_LIMIT);
+    } catch {
+    }
+    return { analysis, keySourceFiles };
+  } catch {
+    return null;
+  }
+}
+async function buildProjectContext(projectData, harnessPath) {
+  let irSummary = "";
+  try {
+    const irPath = path31.join(harnessPath, "..", "harness-ir.json");
+    const irRaw = await fs31.readFile(irPath, "utf-8");
+    const ir = JSON.parse(irRaw);
+    irSummary = buildIRSummary(ir);
+  } catch {
+    try {
+      const ir = await parseHarness(harnessPath);
+      irSummary = buildIRSummary(ir);
+    } catch {
+      irSummary = "(IR not available)";
+    }
+  }
+  return {
+    analysis: projectData.analysis,
+    irSummary,
+    keySourceFiles: projectData.keySourceFiles || void 0
+  };
+}
 function computeMutationCap(iter, maxIterations, maxMutations) {
   if (maxIterations <= 1) return maxMutations;
   const progress = iter / (maxIterations - 1);
@@ -8564,7 +8791,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
   let baselineComplexity = null;
   let baselineIR = null;
   if (useKL) {
-    const baselineHarness = path30.join(workspacePath, "iterations", "0", "harness");
+    const baselineHarness = path31.join(workspacePath, "iterations", "0", "harness");
     try {
       baselineIR = await parseHarness(baselineHarness);
       baselineComplexity = measureComplexityFromIR(baselineIR);
@@ -8576,20 +8803,22 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
     }
   }
   let lastChangedAspects = null;
+  const projectDir = path31.resolve(workspacePath, "..");
+  const projectData = await loadProjectContext(projectDir);
   let rngState = evolveConfig.rngSeed ?? 42;
   const rng = () => {
     rngState = rngState * 1664525 + 1013904223 & 4294967295;
     return (rngState >>> 0) / 4294967296;
   };
   for (let iter = 0; iter < evolveConfig.maxIterations; iter++) {
-    const harnessPath = path30.join(
+    const harnessPath = path31.join(
       workspacePath,
       "iterations",
       iter.toString(),
       "harness"
     );
     try {
-      await fs30.access(harnessPath);
+      await fs31.access(harnessPath);
     } catch {
       if (iter === 0) {
         throw new Error(
@@ -8698,7 +8927,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       }
       const diffRatio = await computeDiffRatio(
         harnessPath,
-        path30.join(workspacePath, "iterations", "0", "harness")
+        path31.join(workspacePath, "iterations", "0", "harness")
       );
       currentComplexity.diffFromBaseline = diffRatio;
       iterComplexityCost = computeComplexityCost(currentComplexity, baselineComplexity);
@@ -8767,7 +8996,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       };
       await writeIterationLog(workspacePath, rollbackLog);
       history.push(rollbackLog);
-      const bestHarnessPath = path30.join(
+      const bestHarnessPath = path31.join(
         workspacePath,
         "iterations",
         bestIteration.toString(),
@@ -8776,6 +9005,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       if (iter + 1 < evolveConfig.maxIterations) {
         onProgress?.({ type: "proposing", iteration: iter, message: "Proposing new mutations after rollback" });
         try {
+          const rollbackProjectCtx = projectData ? await buildProjectContext(projectData, bestHarnessPath) : void 0;
           let rollbackProposal = await propose(
             iter,
             workspacePath,
@@ -8783,7 +9013,8 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
             history,
             tasks,
             kairnConfig,
-            evolveConfig.proposerModel
+            evolveConfig.proposerModel,
+            rollbackProjectCtx
           );
           const rollbackCap = computeMutationCap(iter, evolveConfig.maxIterations, evolveConfig.maxMutationsPerIteration);
           if (rollbackProposal.mutations.length > rollbackCap) {
@@ -8792,7 +9023,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
               mutations: rollbackProposal.mutations.slice(0, rollbackCap)
             };
           }
-          const nextIterDir2 = path30.join(workspacePath, "iterations", (iter + 1).toString());
+          const nextIterDir2 = path31.join(workspacePath, "iterations", (iter + 1).toString());
           await applyMutations(bestHarnessPath, nextIterDir2, rollbackProposal.mutations);
           try {
             const rollbackIR = await parseHarness(bestHarnessPath);
@@ -8807,8 +9038,8 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
             mutationCount: rollbackProposal.mutations.length
           });
         } catch {
-          const nextIterDir2 = path30.join(workspacePath, "iterations", (iter + 1).toString());
-          await copyDir(bestHarnessPath, path30.join(nextIterDir2, "harness"));
+          const nextIterDir2 = path31.join(workspacePath, "iterations", (iter + 1).toString());
+          await copyDir(bestHarnessPath, path31.join(nextIterDir2, "harness"));
         }
       }
       continue;
@@ -8859,6 +9090,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       onProgress?.({ type: "architect-start", iteration: iter });
       let architectProposal;
       try {
+        const architectProjectCtx = projectData ? await buildProjectContext(projectData, harnessPath) : void 0;
         architectProposal = await proposeArchitecture(
           iter,
           workspacePath,
@@ -8866,7 +9098,9 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
           history,
           tasks,
           kairnConfig,
-          evolveConfig.architectModel
+          evolveConfig.architectModel,
+          void 0,
+          architectProjectCtx
         );
         const architectCap = computeArchitectMutationBudget(iter, evolveConfig.maxIterations);
         if (architectProposal.mutations.length > architectCap) {
@@ -8882,8 +9116,8 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
           iteration: iter,
           message: `Architect failed: ${errMsg}. Falling back to reactive proposer.`
         });
-        const nextIterDir2 = path30.join(workspacePath, "iterations", (iter + 1).toString());
-        await copyDir(harnessPath, path30.join(nextIterDir2, "harness"));
+        const nextIterDir2 = path31.join(workspacePath, "iterations", (iter + 1).toString());
+        await copyDir(harnessPath, path31.join(nextIterDir2, "harness"));
         const skipLog = {
           iteration: iter,
           score: aggregate,
@@ -8900,7 +9134,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         continue;
       }
       onProgress?.({ type: "architect-staging", iteration: iter });
-      const stagingDir = path30.join(workspacePath, "staging", iter.toString());
+      const stagingDir = path31.join(workspacePath, "staging", iter.toString());
       let stagingHarnessPath;
       try {
         const stagingResult = await applyMutations(
@@ -8911,8 +9145,8 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         stagingHarnessPath = stagingResult.newHarnessPath;
       } catch {
         onProgress?.({ type: "architect-rejected", iteration: iter, score: 0, message: "Failed to apply mutations to staging" });
-        const nextIterDir2 = path30.join(workspacePath, "iterations", (iter + 1).toString());
-        await copyDir(harnessPath, path30.join(nextIterDir2, "harness"));
+        const nextIterDir2 = path31.join(workspacePath, "iterations", (iter + 1).toString());
+        await copyDir(harnessPath, path31.join(nextIterDir2, "harness"));
         const rejectLog = {
           iteration: iter,
           score: aggregate,
@@ -8926,7 +9160,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         };
         await writeIterationLog(workspacePath, rejectLog);
         history.push(rejectLog);
-        await fs30.rm(stagingDir, { recursive: true, force: true }).catch(() => {
+        await fs31.rm(stagingDir, { recursive: true, force: true }).catch(() => {
         });
         continue;
       }
@@ -8943,12 +9177,12 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       );
       if (stagingScore >= bestScore) {
         onProgress?.({ type: "architect-accepted", iteration: iter, score: stagingScore });
-        const nextIterDir2 = path30.join(workspacePath, "iterations", (iter + 1).toString());
-        await copyDir(stagingHarnessPath, path30.join(nextIterDir2, "harness"));
+        const nextIterDir2 = path31.join(workspacePath, "iterations", (iter + 1).toString());
+        await copyDir(stagingHarnessPath, path31.join(nextIterDir2, "harness"));
       } else {
         onProgress?.({ type: "architect-rejected", iteration: iter, score: stagingScore });
-        const nextIterDir2 = path30.join(workspacePath, "iterations", (iter + 1).toString());
-        await copyDir(harnessPath, path30.join(nextIterDir2, "harness"));
+        const nextIterDir2 = path31.join(workspacePath, "iterations", (iter + 1).toString());
+        await copyDir(harnessPath, path31.join(nextIterDir2, "harness"));
       }
       const architectLog = {
         iteration: iter,
@@ -8963,13 +9197,14 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       };
       await writeIterationLog(workspacePath, architectLog);
       history.push(architectLog);
-      await fs30.rm(stagingDir, { recursive: true, force: true }).catch(() => {
+      await fs31.rm(stagingDir, { recursive: true, force: true }).catch(() => {
       });
       continue;
     }
     onProgress?.({ type: "proposing", iteration: iter });
     let proposal;
     try {
+      const iterProjectCtx = projectData ? await buildProjectContext(projectData, harnessPath) : void 0;
       proposal = await propose(
         iter,
         workspacePath,
@@ -8977,7 +9212,8 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         history,
         tasks,
         kairnConfig,
-        evolveConfig.proposerModel
+        evolveConfig.proposerModel,
+        iterProjectCtx
       );
       const iterCap = computeMutationCap(iter, evolveConfig.maxIterations, evolveConfig.maxMutationsPerIteration);
       if (proposal.mutations.length > iterCap) {
@@ -8993,12 +9229,12 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         iteration: iter,
         message: `Proposer failed: ${errMsg}`
       });
-      const nextIterDir2 = path30.join(
+      const nextIterDir2 = path31.join(
         workspacePath,
         "iterations",
         (iter + 1).toString()
       );
-      await copyDir(harnessPath, path30.join(nextIterDir2, "harness"));
+      await copyDir(harnessPath, path31.join(nextIterDir2, "harness"));
       const skipLog = {
         iteration: iter,
         score: aggregate,
@@ -9014,7 +9250,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       history.push(skipLog);
       continue;
     }
-    const nextIterDir = path30.join(
+    const nextIterDir = path31.join(
       workspacePath,
       "iterations",
       (iter + 1).toString()
@@ -9035,7 +9271,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         lastChangedAspects = null;
       }
     } catch {
-      await copyDir(harnessPath, path30.join(nextIterDir, "harness"));
+      await copyDir(harnessPath, path31.join(nextIterDir, "harness"));
       lastChangedAspects = null;
     }
     onProgress?.({
@@ -9059,8 +9295,9 @@ 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 = path30.join(workspacePath, "iterations", "0", "harness");
+    const baselineHarnessPath = path31.join(workspacePath, "iterations", "0", "harness");
     try {
+      const principalProjectCtx = projectData ? await buildProjectContext(projectData, baselineHarnessPath) : void 0;
       let principalProposal = await propose(
         history.length,
         workspacePath,
@@ -9068,7 +9305,8 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         history,
         tasks,
         kairnConfig,
-        evolveConfig.proposerModel
+        evolveConfig.proposerModel,
+        principalProjectCtx
       );
       if (principalProposal.mutations.length > evolveConfig.maxMutationsPerIteration) {
         principalProposal = {
@@ -9077,7 +9315,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         };
       }
       const principalIterNum = history.length;
-      const principalIterDir = path30.join(workspacePath, "iterations", principalIterNum.toString());
+      const principalIterDir = path31.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(
@@ -9118,7 +9356,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
   }
   try {
     const { extractAndSavePatterns: extractAndSavePatterns2 } = await Promise.resolve().then(() => (init_knowledge(), knowledge_exports));
-    const projectName = path30.basename(path30.resolve(workspacePath, ".."));
+    const projectName = path31.basename(path31.resolve(workspacePath, ".."));
     await extractAndSavePatterns2(history, projectName, null);
   } catch {
   }
@@ -9134,6 +9372,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
     baselineScore
   };
 }
+var KEY_SOURCE_CHARS_LIMIT;
 var init_loop = __esm({
   "src/evolve/loop.ts"() {
     "use strict";
@@ -9149,11 +9388,13 @@ var init_loop = __esm({
     init_parser();
     init_translate();
     init_targeting();
+    init_cache();
+    KEY_SOURCE_CHARS_LIMIT = 1e4;
   }
 });
 
 // src/evolve/synthesis.ts
-import path33 from "path";
+import path34 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.
@@ -9309,7 +9550,7 @@ async function runSynthesis(context, kairnConfig, evolveConfig, workspacePath) {
     if (mutations.length === 0) {
       return null;
     }
-    const synthesisDir = path33.join(workspacePath, "synthesis");
+    const synthesisDir = path34.join(workspacePath, "synthesis");
     const { newHarnessPath } = await applyMutations(
       context.baselineHarnessPath,
       synthesisDir,
@@ -9343,26 +9584,26 @@ __export(population_exports, {
   initBranches: () => initBranches,
   runPopulation: () => runPopulation
 });
-import fs33 from "fs/promises";
-import path34 from "path";
+import fs34 from "fs/promises";
+import path35 from "path";
 async function initBranches(workspacePath, baselinePath, numBranches) {
-  const branchesDir = path34.join(workspacePath, "branches");
-  await fs33.mkdir(branchesDir, { recursive: true });
+  const branchesDir = path35.join(workspacePath, "branches");
+  await fs34.mkdir(branchesDir, { recursive: true });
   const configs = [];
   for (let i = 0; i < numBranches; i++) {
-    const branchPath = path34.join(branchesDir, i.toString());
-    const harnessPath = path34.join(branchPath, "iterations", "0", "harness");
+    const branchPath = path35.join(branchesDir, i.toString());
+    const harnessPath = path35.join(branchPath, "iterations", "0", "harness");
     await copyDir(baselinePath, harnessPath);
-    const tasksYaml = path34.join(workspacePath, "tasks.yaml");
+    const tasksYaml = path35.join(workspacePath, "tasks.yaml");
     try {
-      await fs33.access(tasksYaml);
-      await fs33.copyFile(tasksYaml, path34.join(branchPath, "tasks.yaml"));
+      await fs34.access(tasksYaml);
+      await fs34.copyFile(tasksYaml, path35.join(branchPath, "tasks.yaml"));
     } catch {
     }
-    const configYaml = path34.join(workspacePath, "config.yaml");
+    const configYaml = path35.join(workspacePath, "config.yaml");
     try {
-      await fs33.access(configYaml);
-      await fs33.copyFile(configYaml, path34.join(branchPath, "config.yaml"));
+      await fs34.access(configYaml);
+      await fs34.copyFile(configYaml, path35.join(branchPath, "config.yaml"));
     } catch {
     }
     const seed = 42 + i * 1337;
@@ -9376,7 +9617,7 @@ async function initBranches(workspacePath, baselinePath, numBranches) {
 }
 async function runPopulation(workspacePath, tasks, kairnConfig, evolveConfig, numBranches, onProgress) {
   const branches = numBranches ?? evolveConfig.pbtBranches;
-  const baselinePath = path34.join(workspacePath, "baseline");
+  const baselinePath = path35.join(workspacePath, "baseline");
   const branchConfigs = await initBranches(workspacePath, baselinePath, branches);
   const branchPromises = branchConfigs.map(async (branchConfig) => {
     const branchEvolveConfig = {
@@ -9396,7 +9637,7 @@ async function runPopulation(workspacePath, tasks, kairnConfig, evolveConfig, nu
       branchEvolveConfig,
       branchProgress
     );
-    const finalHarnessPath = path34.join(
+    const finalHarnessPath = path35.join(
       branchConfig.workspacePath,
       "iterations",
       result.bestIteration.toString(),
@@ -9404,8 +9645,8 @@ async function runPopulation(workspacePath, tasks, kairnConfig, evolveConfig, nu
     );
     let beliefs = [];
     try {
-      const beliefsPath = path34.join(branchConfig.workspacePath, "task-beliefs.json");
-      const beliefsContent = await fs33.readFile(beliefsPath, "utf-8");
+      const beliefsPath = path35.join(branchConfig.workspacePath, "task-beliefs.json");
+      const beliefsContent = await fs34.readFile(beliefsPath, "utf-8");
       beliefs = JSON.parse(beliefsContent);
     } catch {
     }
@@ -9427,7 +9668,7 @@ async function runPopulation(workspacePath, tasks, kairnConfig, evolveConfig, nu
   }
   let synthesizedResult;
   try {
-    const baselinePath2 = path34.join(workspacePath, "baseline");
+    const baselinePath2 = path35.join(workspacePath, "baseline");
     const synthesisResult = await runSynthesis(
       { branches: branchResults, tasks, baselineHarnessPath: baselinePath2 },
       kairnConfig,
@@ -9489,8 +9730,8 @@ __export(research_exports, {
   formatResearchReport: () => formatResearchReport,
   runResearch: () => runResearch
 });
-import fs34 from "fs/promises";
-import path35 from "path";
+import fs35 from "fs/promises";
+import path36 from "path";
 import os5 from "os";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify4 } from "util";
@@ -9509,8 +9750,8 @@ async function runResearch(config, _kairnConfig, _evolveConfig, onProgress) {
   }
   const allPatterns = [];
   const repoResults = [];
-  const tempBase = path35.join(os5.tmpdir(), `kairn-research-${Date.now()}`);
-  await fs34.mkdir(tempBase, { recursive: true });
+  const tempBase = path36.join(os5.tmpdir(), `kairn-research-${Date.now()}`);
+  await fs35.mkdir(tempBase, { recursive: true });
   try {
     for (let i = 0; i < config.repos.length; i++) {
       const url = config.repos[i];
@@ -9522,7 +9763,7 @@ async function runResearch(config, _kairnConfig, _evolveConfig, onProgress) {
         totalRepos: config.repos.length,
         message: `Cloning ${name}...`
       });
-      const repoDir = path35.join(tempBase, name);
+      const repoDir = path36.join(tempBase, name);
       try {
         await execAsync4(`git clone --depth 1 '${url.replace(/'/g, "'\\''")}' '${repoDir.replace(/'/g, "'\\''")}' 2>/dev/null`, { timeout: 6e4 });
       } catch (err) {
@@ -9536,10 +9777,10 @@ async function runResearch(config, _kairnConfig, _evolveConfig, onProgress) {
         repoResults.push({ repo: name, bestScore: 0, patternsFound: 0 });
         continue;
       }
-      const claudeDir = path35.join(repoDir, ".claude");
+      const claudeDir = path36.join(repoDir, ".claude");
       let hasHarness = false;
       try {
-        await fs34.access(claudeDir);
+        await fs35.access(claudeDir);
         hasHarness = true;
       } catch {
         onProgress?.({
@@ -9589,7 +9830,7 @@ async function runResearch(config, _kairnConfig, _evolveConfig, onProgress) {
     onProgress?.({ type: "research-complete", message: "Research complete" });
     return report;
   } finally {
-    await fs34.rm(tempBase, { recursive: true, force: true }).catch(() => {
+    await fs35.rm(tempBase, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -9960,6 +10201,7 @@ async function detectExistingRepo(dir) {
 }
 
 // src/commands/describe.ts
+init_persist();
 var describeCommand = new Command3("describe").description("Describe your workflow and generate a Claude Code environment").argument("[intent]", "What you want your agent to do").option("-y, --yes", "Skip confirmation prompt").option("-q, --quick", "Skip clarification questions").option("--runtime <runtime>", "Target runtime (claude-code or hermes)", "claude-code").action(async (intentArg, options) => {
   printFullBanner("The Agent Environment Compiler");
   const config = await loadConfig();
@@ -10059,6 +10301,13 @@ Autonomy level: ${autonomyLevel} (${autonomyLabel(autonomyLevel)})`;
 `));
     process.exit(1);
   }
+  if (spec.ir) {
+    try {
+      await persistHarnessIR(process.cwd(), spec.ir);
+    } catch {
+      console.log(ui.warn("Could not persist harness IR to .kairn/harness-ir.json"));
+    }
+  }
   const registry = await loadRegistry();
   const summary = summarizeSpec(spec, registry);
   console.log("");
@@ -10133,14 +10382,14 @@ init_ui();
 init_logo();
 import { Command as Command4 } from "commander";
 import chalk7 from "chalk";
-import fs14 from "fs/promises";
-import path14 from "path";
+import fs15 from "fs/promises";
+import path15 from "path";
 var listCommand = new Command4("list").description("Show saved environments").action(async () => {
   printCompactBanner();
   const envsDir = getEnvsDir();
   let files;
   try {
-    files = await fs14.readdir(envsDir);
+    files = await fs15.readdir(envsDir);
   } catch {
     console.log(chalk7.dim("  No environments yet. Run ") + chalk7.bold("kairn describe") + chalk7.dim(" to create one.\n"));
     return;
@@ -10153,7 +10402,7 @@ var listCommand = new Command4("list").description("Show saved environments").ac
   let first = true;
   for (const file of jsonFiles) {
     try {
-      const data = await fs14.readFile(path14.join(envsDir, file), "utf-8");
+      const data = await fs15.readFile(path15.join(envsDir, file), "utf-8");
       const spec = JSON.parse(data);
       const date = new Date(spec.created_at).toLocaleDateString();
       const toolCount = spec.tools?.length ?? 0;
@@ -10178,8 +10427,8 @@ init_ui();
 init_logo();
 import { Command as Command5 } from "commander";
 import chalk8 from "chalk";
-import fs15 from "fs/promises";
-import path15 from "path";
+import fs16 from "fs/promises";
+import path16 from "path";
 var activateCommand = new Command5("activate").description("Re-deploy a saved environment to the current directory").argument("<env_id>", "Environment ID (from kairn list)").action(async (envId) => {
   printCompactBanner();
   const envsDir = getEnvsDir();
@@ -10189,7 +10438,7 @@ var activateCommand = new Command5("activate").description("Re-deploy a saved en
   let fromTemplate = false;
   let envFiles = [];
   try {
-    envFiles = await fs15.readdir(envsDir);
+    envFiles = await fs16.readdir(envsDir);
   } catch {
   }
   match = envFiles.find(
@@ -10200,7 +10449,7 @@ var activateCommand = new Command5("activate").description("Re-deploy a saved en
   } else {
     let templateFiles = [];
     try {
-      templateFiles = await fs15.readdir(templatesDir);
+      templateFiles = await fs16.readdir(templatesDir);
     } catch {
     }
     match = templateFiles.find(
@@ -10216,7 +10465,7 @@ var activateCommand = new Command5("activate").description("Re-deploy a saved en
       process.exit(1);
     }
   }
-  const data = await fs15.readFile(path15.join(sourceDir, match), "utf-8");
+  const data = await fs16.readFile(path16.join(sourceDir, match), "utf-8");
   const spec = JSON.parse(data);
   const label = fromTemplate ? chalk8.dim(" (template)") : "";
   console.log(chalk8.cyan(`  Activating: ${spec.name}`) + label);
@@ -10236,21 +10485,21 @@ init_ui();
 init_logo();
 import { Command as Command6 } from "commander";
 import chalk9 from "chalk";
-import fs16 from "fs/promises";
-import path16 from "path";
+import fs17 from "fs/promises";
+import path17 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var REGISTRY_URL = "https://raw.githubusercontent.com/ashtonperlroth/kairn/main/src/registry/tools.json";
 async function getLocalRegistryPath() {
   const __filename3 = fileURLToPath4(import.meta.url);
-  const __dirname3 = path16.dirname(__filename3);
+  const __dirname3 = path17.dirname(__filename3);
   const candidates = [
-    path16.resolve(__dirname3, "../registry/tools.json"),
-    path16.resolve(__dirname3, "../src/registry/tools.json"),
-    path16.resolve(__dirname3, "../../src/registry/tools.json")
+    path17.resolve(__dirname3, "../registry/tools.json"),
+    path17.resolve(__dirname3, "../src/registry/tools.json"),
+    path17.resolve(__dirname3, "../../src/registry/tools.json")
   ];
   for (const candidate of candidates) {
     try {
-      await fs16.access(candidate);
+      await fs17.access(candidate);
       return candidate;
     } catch {
       continue;
@@ -10287,10 +10536,10 @@ var updateRegistryCommand = new Command6("update-registry").description("Fetch t
     const registryPath = await getLocalRegistryPath();
     const backupPath = registryPath + ".bak";
     try {
-      await fs16.copyFile(registryPath, backupPath);
+      await fs17.copyFile(registryPath, backupPath);
     } catch {
     }
-    await fs16.writeFile(registryPath, JSON.stringify(tools, null, 2), "utf-8");
+    await fs17.writeFile(registryPath, JSON.stringify(tools, null, 2), "utf-8");
     console.log(ui.success(`Registry updated: ${tools.length} tools`));
     console.log(chalk9.dim(`  Saved to: ${registryPath}`));
     console.log(chalk9.dim(`  Backup: ${backupPath}
@@ -10669,14 +10918,14 @@ init_ui();
 init_logo();
 import { Command as Command9 } from "commander";
 import chalk12 from "chalk";
-import fs17 from "fs/promises";
-import path17 from "path";
+import fs18 from "fs/promises";
+import path18 from "path";
 var templatesCommand = new Command9("templates").description("Browse available templates").option("--category <cat>", "filter templates by category keyword").option("--json", "output raw JSON array").action(async (options) => {
   printCompactBanner();
   const templatesDir = getTemplatesDir();
   let files;
   try {
-    files = await fs17.readdir(templatesDir);
+    files = await fs18.readdir(templatesDir);
   } catch {
     console.log(
       chalk12.dim(
@@ -10701,8 +10950,8 @@ var templatesCommand = new Command9("templates").description("Browse available t
   const templates = [];
   for (const file of jsonFiles) {
     try {
-      const data = await fs17.readFile(
-        path17.join(templatesDir, file),
+      const data = await fs18.readFile(
+        path18.join(templatesDir, file),
         "utf-8"
       );
       const spec = JSON.parse(data);
@@ -10753,8 +11002,8 @@ init_loader();
 import { Command as Command10 } from "commander";
 import { password as password3 } from "@inquirer/prompts";
 import chalk13 from "chalk";
-import fs18 from "fs/promises";
-import path18 from "path";
+import fs19 from "fs/promises";
+import path19 from "path";
 var keysCommand = new Command10("keys").description("Add or update API keys for the current environment").option("--show", "Show which keys are set vs missing").action(async (options) => {
   printCompactBanner();
   const targetDir = process.cwd();
@@ -10866,8 +11115,8 @@ var keysCommand = new Command10("keys").description("Add or update API keys for
   for (const [key, value] of envEntries) {
     envLines.push(`${key}=${value}`);
   }
-  const envPath = path18.join(targetDir, ".env");
-  await fs18.writeFile(envPath, envLines.join("\n") + "\n", "utf-8");
+  const envPath = path19.join(targetDir, ".env");
+  await fs19.writeFile(envPath, envLines.join("\n") + "\n", "utf-8");
   console.log(chalk13.green(`  \u2713 ${keysEntered} key(s) saved to .env`));
   console.log("");
 });
@@ -10877,90 +11126,131 @@ init_ui();
 import { Command as Command11 } from "commander";
 import chalk14 from "chalk";
 import ora2 from "ora";
-import fs35 from "fs/promises";
-import path36 from "path";
+import fs36 from "fs/promises";
+import path37 from "path";
 import { parse as yamlParse2 } from "yaml";
 import { confirm as confirm4, input as input4, select as select4 } from "@inquirer/prompts";
 
 // src/evolve/init.ts
 init_config();
-import fs19 from "fs/promises";
-import path19 from "path";
+init_cache();
+import fs20 from "fs/promises";
+import path20 from "path";
 import { stringify as yamlStringify } from "yaml";
 
 // src/evolve/templates.ts
 init_llm();
 var EVAL_TEMPLATES = {
+  // --- Harness-sensitivity templates (probe whether agent follows .claude/ harness) ---
   "add-feature": {
     id: "add-feature",
     name: "Add Feature",
     description: "Can the agent add a new capability?",
-    bestFor: ["feature-development", "api-building", "full-stack"]
+    bestFor: ["feature-development", "api-building", "full-stack"],
+    category: "harness-sensitivity"
   },
   "fix-bug": {
     id: "fix-bug",
     name: "Fix Bug",
     description: "Can the agent diagnose and fix a problem?",
-    bestFor: ["maintenance", "debugging", "qa"]
+    bestFor: ["maintenance", "debugging", "qa"],
+    category: "harness-sensitivity"
   },
   "refactor": {
     id: "refactor",
     name: "Refactor",
     description: "Can the agent restructure code?",
-    bestFor: ["maintenance", "architecture", "backend"]
+    bestFor: ["maintenance", "architecture", "backend"],
+    category: "harness-sensitivity"
   },
   "test-writing": {
     id: "test-writing",
     name: "Test Writing",
     description: "Can the agent write tests?",
-    bestFor: ["tdd", "qa", "backend"]
+    bestFor: ["tdd", "qa", "backend"],
+    category: "harness-sensitivity"
   },
   "config-change": {
     id: "config-change",
     name: "Config Change",
     description: "Can the agent update configuration?",
-    bestFor: ["devops", "infrastructure", "backend"]
+    bestFor: ["devops", "infrastructure", "backend"],
+    category: "harness-sensitivity"
   },
   "documentation": {
     id: "documentation",
     name: "Documentation",
     description: "Can the agent write and update docs?",
-    bestFor: ["content", "api-building", "full-stack"]
+    bestFor: ["content", "api-building", "full-stack"],
+    category: "harness-sensitivity"
   },
   "convention-adherence": {
     id: "convention-adherence",
     name: "Convention Adherence",
     description: "Does the agent follow all project conventions defined in CLAUDE.md?",
-    bestFor: ["feature-development", "full-stack", "backend", "maintenance"]
+    bestFor: ["feature-development", "full-stack", "backend", "maintenance"],
+    category: "harness-sensitivity"
   },
   "workflow-compliance": {
     id: "workflow-compliance",
     name: "Workflow Compliance",
     description: "Does the agent use the project workflow commands and skills?",
-    bestFor: ["feature-development", "full-stack", "tdd", "qa"]
+    bestFor: ["feature-development", "full-stack", "tdd", "qa"],
+    category: "harness-sensitivity"
   },
   "rule-compliance": {
     id: "rule-compliance",
     name: "Rule Compliance",
     description: "Does the agent follow all project rules without violations?",
-    bestFor: ["feature-development", "backend", "maintenance", "architecture"]
+    bestFor: ["feature-development", "backend", "maintenance", "architecture"],
+    category: "harness-sensitivity"
   },
   "intent-routing": {
     id: "intent-routing",
     name: "Intent Routing",
     description: "Test that natural language prompts route to the correct workflow command via intent hooks",
-    bestFor: ["feature-development", "full-stack", "api-building"]
+    bestFor: ["feature-development", "full-stack", "api-building"],
+    category: "harness-sensitivity"
   },
   "persistence-completion": {
     id: "persistence-completion",
     name: "Persistence Completion",
     description: "Can the agent complete a multi-criterion task using the persistence loop?",
-    bestFor: ["feature-development", "full-stack", "api-building", "maintenance"]
+    bestFor: ["feature-development", "full-stack", "api-building", "maintenance"],
+    category: "harness-sensitivity"
+  },
+  // --- Substantive SWE-bench-style templates (test real coding ability) ---
+  "real-bug-fix": {
+    id: "real-bug-fix",
+    name: "Real Bug Fix",
+    description: "Injects a known bug into a source file and asks the agent to diagnose and fix it, mimicking a real GitHub issue",
+    bestFor: ["debugging", "maintenance", "qa", "backend"],
+    category: "substantive"
+  },
+  "real-feature-add": {
+    id: "real-feature-add",
+    name: "Real Feature Add",
+    description: "Describes a concrete feature with clear acceptance criteria and verifies the agent implements it correctly",
+    bestFor: ["feature-development", "full-stack", "api-building", "backend"],
+    category: "substantive"
+  },
+  "codebase-question": {
+    id: "codebase-question",
+    name: "Codebase Question",
+    description: "Asks a factual question about codebase knowledge and checks the answer via LLM-as-judge against a known-correct answer",
+    bestFor: ["research", "architecture", "maintenance", "debugging"],
+    category: "substantive"
   }
 };
+var SUBSTANTIVE_FLOOR = [
+  "real-bug-fix",
+  "real-feature-add",
+  "codebase-question"
+];
+var MAX_HARNESS_TEMPLATES = 4;
 function selectTemplatesForWorkflow(workflowType) {
-  const mapping = {
-    "feature-development": ["add-feature", "test-writing", "convention-adherence", "workflow-compliance", "intent-routing", "persistence-completion"],
+  const harnessMapping = {
+    "feature-development": ["add-feature", "test-writing", "intent-routing", "convention-adherence", "workflow-compliance", "persistence-completion"],
     "api-building": ["add-feature", "fix-bug", "test-writing", "convention-adherence", "persistence-completion"],
     "full-stack": ["add-feature", "fix-bug", "test-writing", "convention-adherence", "persistence-completion"],
     "maintenance": ["fix-bug", "refactor", "test-writing", "rule-compliance", "persistence-completion"],
@@ -10974,7 +11264,8 @@ function selectTemplatesForWorkflow(workflowType) {
     "content": ["documentation", "add-feature", "convention-adherence"],
     "research": ["documentation", "add-feature", "convention-adherence"]
   };
-  return mapping[workflowType] || ["add-feature", "fix-bug", "test-writing", "convention-adherence"];
+  const harness = (harnessMapping[workflowType] ?? ["add-feature", "fix-bug", "test-writing", "convention-adherence"]).slice(0, MAX_HARNESS_TEMPLATES);
+  return [...SUBSTANTIVE_FLOOR, ...harness];
 }
 var TASK_GENERATION_PROMPT = `You are an eval task generator for Claude Code agent environments. Given a project's CLAUDE.md, project structure, and selected eval templates, generate concrete, project-specific tasks.
 
@@ -10988,6 +11279,15 @@ IMPORTANT: For harness-aware templates (convention-adherence, workflow-complianc
 
 These harness-aware tasks are critical \u2014 they test whether the .claude/ environment actually improves agent behavior.
 
+SUBSTANTIVE SWE-bench-style templates test real coding ability beyond harness adherence:
+- real-bug-fix: Inject a known bug into a source file (e.g., swap variable names, remove an import, introduce an off-by-one error). Write the task description like a real GitHub issue: "When X happens, Y is broken." The setup command should apply the bug. Scorer: run the test suite or check the specific file was fixed correctly. Use scoring "pass-fail".
+- real-feature-add: Describe a concrete feature with clear acceptance criteria (e.g., "Add a --verbose flag that prints debug output"). The feature should be small, self-contained, and testable. Scorer: verify the feature exists, tests pass, and no regressions. Use scoring "pass-fail" or "rubric".
+- codebase-question: Ask a factual question about the codebase that requires reading and understanding source code (e.g., "What function handles authentication?" or "What environment variables does this project need?"). Include the known-correct answer in expected_outcome. Scorer: LLM-as-judge checks answer accuracy against the known-correct answer. Use scoring "llm-judge".
+
+Each task MUST include a "category" field:
+- "harness-sensitivity" for templates that test .claude/ harness adherence
+- "substantive" for SWE-bench-style templates that test real coding ability
+
 Return a JSON object with a "tasks" array. Each task has:
 - id: kebab-case identifier (e.g., "add-health-endpoint")
 - template: which eval template this instantiates
@@ -10995,8 +11295,11 @@ Return a JSON object with a "tasks" array. Each task has:
 - setup: shell commands to prepare the workspace (e.g., "npm install")
 - expected_outcome: multi-line string describing what success looks like
 - scoring: "pass-fail", "llm-judge", or "rubric"
+- category: "harness-sensitivity" or "substantive"
 - timeout: seconds (300 for features/bugs, 600 for refactors, 180 for config/docs/tests)
 
+BALANCE REQUIREMENT: Generate an equal number of harness-sensitivity tasks and substantive tasks. If you are given N templates total, aim for ceil(N/2) harness-sensitivity tasks and floor(N/2) substantive tasks. Do not skew toward one category.
+
 Return ONLY valid JSON, no markdown fences.`;
 function parseJsonResponse(raw) {
   let cleaned = raw.trim();
@@ -11038,7 +11341,56 @@ function validateTask(obj, index) {
   }
   return record;
 }
-function buildTaskGenerationMessage(claudeMd, projectProfile, templates) {
+function buildAnalysisContext(analysis) {
+  const lines = ["## Project Analysis", ""];
+  lines.push(`Purpose: ${analysis.purpose}`);
+  lines.push(`Domain: ${analysis.domain}`);
+  lines.push(`Architecture: ${analysis.architecture_style}`);
+  lines.push(`Deployment: ${analysis.deployment_model}`);
+  lines.push("");
+  if (analysis.key_modules.length > 0) {
+    lines.push("### Key Modules");
+    lines.push("");
+    for (const mod of analysis.key_modules) {
+      lines.push(`- **${mod.name}** (${mod.path}): ${mod.description}`);
+      if (mod.responsibilities.length > 0) {
+        lines.push(`  Responsibilities: ${mod.responsibilities.join(", ")}`);
+      }
+    }
+    lines.push("");
+  }
+  if (analysis.workflows.length > 0) {
+    lines.push("### Workflows");
+    lines.push("");
+    for (const wf of analysis.workflows) {
+      lines.push(`- **${wf.name}**: ${wf.description} (trigger: ${wf.trigger})`);
+      lines.push(`  Steps: ${wf.steps.join(" -> ")}`);
+    }
+    lines.push("");
+  }
+  if (analysis.config_keys.length > 0) {
+    lines.push("### Config Keys");
+    lines.push("");
+    for (const key of analysis.config_keys) {
+      lines.push(`- ${key.name}: ${key.purpose}`);
+    }
+    lines.push("");
+  }
+  if (analysis.dataflow.length > 0) {
+    lines.push("### Data Flow");
+    lines.push("");
+    for (const edge of analysis.dataflow) {
+      lines.push(`- ${edge.from} -> ${edge.to}: ${edge.data}`);
+    }
+    lines.push("");
+  }
+  lines.push("IMPORTANT: Use this analysis to generate domain-specific tasks:");
+  lines.push("- real-bug-fix tasks should reference actual module names and paths listed above");
+  lines.push("- codebase-question tasks should ask about actual workflows, modules, and config keys");
+  lines.push("- real-feature-add tasks should extend actual functionality in the modules listed above");
+  return lines.join("\n");
+}
+function buildTaskGenerationMessage(claudeMd, projectProfile, templates, analysis) {
   const profileLines = [
     `Language: ${projectProfile.language ?? "unknown"}`,
     `Framework: ${projectProfile.framework ?? "none"}`,
@@ -11049,7 +11401,7 @@ function buildTaskGenerationMessage(claudeMd, projectProfile, templates) {
     const meta = EVAL_TEMPLATES[t];
     return `- ${t}: ${meta.description}`;
   }).join("\n");
-  return [
+  const sections = [
     "## CLAUDE.md",
     "",
     claudeMd,
@@ -11057,16 +11409,23 @@ function buildTaskGenerationMessage(claudeMd, projectProfile, templates) {
     "## Project Profile",
     "",
     ...profileLines,
-    "",
+    ""
+  ];
+  if (analysis) {
+    sections.push(buildAnalysisContext(analysis));
+    sections.push("");
+  }
+  sections.push(
     "## Selected Eval Templates",
     "",
     templateDescriptions,
     "",
     "Generate concrete, project-specific tasks for each template above."
-  ].join("\n");
+  );
+  return sections.join("\n");
 }
-async function generateTasksFromTemplates(claudeMd, projectProfile, templates, config) {
-  const userMessage = buildTaskGenerationMessage(claudeMd, projectProfile, templates);
+async function generateTasksFromTemplates(claudeMd, projectProfile, templates, config, analysis) {
+  const userMessage = buildTaskGenerationMessage(claudeMd, projectProfile, templates, analysis);
   const rawResponse = await callLLM(config, userMessage, {
     systemPrompt: TASK_GENERATION_PROMPT,
     maxTokens: 4096
@@ -11088,10 +11447,10 @@ async function generateTasksFromTemplates(claudeMd, projectProfile, templates, c
 
 // src/evolve/init.ts
 async function createEvolveWorkspace(projectRoot, config) {
-  const workspace = path19.join(projectRoot, ".kairn-evolve");
-  await fs19.mkdir(path19.join(workspace, "baseline"), { recursive: true });
-  await fs19.mkdir(path19.join(workspace, "traces"), { recursive: true });
-  await fs19.mkdir(path19.join(workspace, "iterations"), { recursive: true });
+  const workspace = path20.join(projectRoot, ".kairn-evolve");
+  await fs20.mkdir(path20.join(workspace, "baseline"), { recursive: true });
+  await fs20.mkdir(path20.join(workspace, "traces"), { recursive: true });
+  await fs20.mkdir(path20.join(workspace, "iterations"), { recursive: true });
   const configObj = {
     model: config.model,
     proposer_model: config.proposerModel,
@@ -11099,8 +11458,8 @@ async function createEvolveWorkspace(projectRoot, config) {
     max_iterations: config.maxIterations,
     parallel_tasks: config.parallelTasks
   };
-  await fs19.writeFile(
-    path19.join(workspace, "config.yaml"),
+  await fs20.writeFile(
+    path20.join(workspace, "config.yaml"),
     yamlStringify(configObj),
     "utf-8"
   );
@@ -11116,12 +11475,13 @@ async function writeTasksFile(workspacePath, tasks) {
       expected_outcome: t.expected_outcome,
       scoring: t.scoring,
       ...t.rubric ? { rubric: t.rubric } : {},
-      timeout: t.timeout
+      timeout: t.timeout,
+      ...t.category ? { category: t.category } : {}
     }))
   };
   const header = "# .kairn-evolve/tasks.yaml\n# Auto-generated by kairn evolve init \u2014 edit freely\n";
-  await fs19.writeFile(
-    path19.join(workspacePath, "tasks.yaml"),
+  await fs20.writeFile(
+    path20.join(workspacePath, "tasks.yaml"),
     header + yamlStringify(doc),
     "utf-8"
   );
@@ -11134,8 +11494,8 @@ async function buildProjectProfile(projectRoot) {
     keyFiles: []
   };
   try {
-    const pkgStr = await fs19.readFile(
-      path19.join(projectRoot, "package.json"),
+    const pkgStr = await fs20.readFile(
+      path20.join(projectRoot, "package.json"),
       "utf-8"
     );
     const pkg2 = JSON.parse(pkgStr);
@@ -11162,18 +11522,18 @@ async function buildProjectProfile(projectRoot) {
   }
   if (!profile.language) {
     try {
-      await fs19.access(path19.join(projectRoot, "pyproject.toml"));
+      await fs20.access(path20.join(projectRoot, "pyproject.toml"));
       profile.language = "python";
     } catch {
       try {
-        await fs19.access(path19.join(projectRoot, "requirements.txt"));
+        await fs20.access(path20.join(projectRoot, "requirements.txt"));
         profile.language = "python";
       } catch {
       }
     }
   }
   try {
-    const entries = await fs19.readdir(projectRoot);
+    const entries = await fs20.readdir(projectRoot);
     const keyPatterns = [
       "README.md",
       "package.json",
@@ -11189,6 +11549,16 @@ async function buildProjectProfile(projectRoot) {
   }
   return profile;
 }
+async function loadProjectAnalysis(projectRoot) {
+  try {
+    const cache = await readCache(projectRoot);
+    if (cache?.analysis) {
+      return cache.analysis;
+    }
+  } catch {
+  }
+  return void 0;
+}
 async function autoGenerateTasks(projectRoot, workflowType) {
   const config = await loadConfig();
   if (!config) {
@@ -11196,15 +11566,16 @@ async function autoGenerateTasks(projectRoot, workflowType) {
   }
   let claudeMd = "";
   try {
-    claudeMd = await fs19.readFile(
-      path19.join(projectRoot, ".claude", "CLAUDE.md"),
+    claudeMd = await fs20.readFile(
+      path20.join(projectRoot, ".claude", "CLAUDE.md"),
       "utf-8"
     );
   } catch {
   }
   const profile = await buildProjectProfile(projectRoot);
+  const analysis = await loadProjectAnalysis(projectRoot);
   const templates = selectTemplatesForWorkflow(workflowType);
-  return generateTasksFromTemplates(claudeMd, profile, templates, config);
+  return generateTasksFromTemplates(claudeMd, profile, templates, config, analysis);
 }
 
 // src/commands/evolve.ts
@@ -11216,8 +11587,8 @@ init_loop();
 
 // src/evolve/report.ts
 init_trace();
-import fs31 from "fs/promises";
-import path31 from "path";
+import fs32 from "fs/promises";
+import path32 from "path";
 
 // src/evolve/diagnosis.ts
 function numericScore(s) {
@@ -11267,10 +11638,10 @@ function numericScore2(s) {
   return s.score ?? (s.pass ? 100 : 0);
 }
 async function loadAllIterations(workspacePath) {
-  const iterDir = path31.join(workspacePath, "iterations");
+  const iterDir = path32.join(workspacePath, "iterations");
   let entries;
   try {
-    entries = await fs31.readdir(iterDir);
+    entries = await fs32.readdir(iterDir);
   } catch {
     return [];
   }
@@ -11284,13 +11655,41 @@ async function loadAllIterations(workspacePath) {
 }
 async function loadTasks(workspacePath) {
   try {
-    const content = await fs31.readFile(path31.join(workspacePath, "tasks.yaml"), "utf-8");
+    const content = await fs32.readFile(path32.join(workspacePath, "tasks.yaml"), "utf-8");
     const parsed = yamlParse(content);
-    return parsed?.tasks ?? [];
+    const tasks = parsed?.tasks ?? [];
+    return tasks.map((t) => ({
+      ...t,
+      category: t.category ?? "harness-sensitivity"
+    }));
   } catch {
     return [];
   }
 }
+function computeCategoryBreakdown(tasks, taskResults) {
+  const harnessTasks = [];
+  const substantiveTasks = [];
+  for (const task of tasks) {
+    const result = taskResults[task.id];
+    if (!result) continue;
+    const score = numericScore2(result);
+    const category = task.category ?? "harness-sensitivity";
+    if (category === "harness-sensitivity") {
+      harnessTasks.push(score);
+    } else {
+      substantiveTasks.push(score);
+    }
+  }
+  if (harnessTasks.length === 0 || substantiveTasks.length === 0) {
+    return void 0;
+  }
+  const harnessAvg = harnessTasks.reduce((a, b) => a + b, 0) / harnessTasks.length;
+  const substantiveAvg = substantiveTasks.reduce((a, b) => a + b, 0) / substantiveTasks.length;
+  return {
+    harnessAdherence: { score: harnessAvg, count: harnessTasks.length },
+    substantiveTasks: { score: substantiveAvg, count: substantiveTasks.length }
+  };
+}
 function buildLeaderboard(iterations, tasks) {
   const taskIds = tasks.map((t) => t.id);
   return taskIds.map((taskId) => {
@@ -11350,6 +11749,11 @@ async function generateMarkdownReport(workspacePath) {
   lines.push(`| Best score | ${bestIter.score.toFixed(1)}% |`);
   lines.push(`| Best iteration | ${bestIter.iteration} |`);
   lines.push(`| Improvement | ${improvement >= 0 ? "+" : ""}${improvement.toFixed(1)} points |`);
+  const categoryBreakdown = computeCategoryBreakdown(tasks, bestIter.taskResults);
+  if (categoryBreakdown) {
+    lines.push(`| Harness adherence | ${categoryBreakdown.harnessAdherence.score.toFixed(1)}% (${categoryBreakdown.harnessAdherence.count} tasks) |`);
+    lines.push(`| Substantive tasks | ${categoryBreakdown.substantiveTasks.score.toFixed(1)}% (${categoryBreakdown.substantiveTasks.count} tasks) |`);
+  }
   lines.push("");
   lines.push("## Iterations");
   lines.push("");
@@ -11433,10 +11837,12 @@ async function generateJsonReport(workspacePath) {
   const iterations = await loadAllIterations(workspacePath);
   const tasks = await loadTasks(workspacePath);
   const baselineScore = iterations.length > 0 ? iterations[0].score : 0;
-  const bestIter = iterations.length > 0 ? iterations.reduce((best, curr) => curr.score > best.score ? curr : best, iterations[0]) : { score: 0, iteration: 0 };
+  const bestIterLog = iterations.length > 0 ? iterations.reduce((best, curr) => curr.score > best.score ? curr : best, iterations[0]) : void 0;
+  const bestIter = bestIterLog ?? { score: 0, iteration: 0 };
   const improvement = bestIter.score - baselineScore;
   const counterfactuals = diagnoseCounterfactuals(iterations, tasks);
   const leaderboard = buildLeaderboard(iterations, tasks);
+  const categoryBreakdown = bestIterLog ? computeCategoryBreakdown(tasks, bestIterLog.taskResults) : void 0;
   return {
     overview: {
       title: "Evolution Report",
@@ -11444,7 +11850,8 @@ async function generateJsonReport(workspacePath) {
       baselineScore,
       bestScore: bestIter.score,
       bestIteration: bestIter.iteration,
-      improvement
+      improvement,
+      ...categoryBreakdown ? { categoryBreakdown } : {}
     },
     iterations: iterations.map((iter) => {
       const stddevs = Object.values(iter.taskResults).map((s) => s.variance?.stddev).filter((v) => v !== void 0);
@@ -11470,13 +11877,13 @@ init_mutator();
 init_baseline();
 init_mutator();
 init_trace();
-import fs32 from "fs/promises";
-import path32 from "path";
+import fs33 from "fs/promises";
+import path33 from "path";
 async function listIterations(workspacePath) {
-  const iterationsDir = path32.join(workspacePath, "iterations");
+  const iterationsDir = path33.join(workspacePath, "iterations");
   let entries;
   try {
-    entries = await fs32.readdir(iterationsDir);
+    entries = await fs33.readdir(iterationsDir);
   } catch {
     return [];
   }
@@ -11485,7 +11892,7 @@ async function listIterations(workspacePath) {
     const n = parseInt(entry, 10);
     if (!isNaN(n)) {
       try {
-        await fs32.access(path32.join(iterationsDir, entry, "harness"));
+        await fs33.access(path33.join(iterationsDir, entry, "harness"));
         nums.push(n);
       } catch {
       }
@@ -11511,16 +11918,16 @@ async function listFilesRecursive(dir) {
   async function walk(current) {
     let entries;
     try {
-      entries = await fs32.readdir(current, { withFileTypes: true });
+      entries = await fs33.readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path32.join(current, entry.name);
+      const fullPath = path33.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
-        results.push(path32.relative(dir, fullPath));
+        results.push(path33.relative(dir, fullPath));
       }
     }
   }
@@ -11528,10 +11935,10 @@ async function listFilesRecursive(dir) {
   return results;
 }
 async function findBestPBTHarness(workspacePath) {
-  const branchesDir = path32.join(workspacePath, "branches");
+  const branchesDir = path33.join(workspacePath, "branches");
   let branchEntries;
   try {
-    branchEntries = await fs32.readdir(branchesDir);
+    branchEntries = await fs33.readdir(branchesDir);
   } catch {
     return null;
   }
@@ -11539,7 +11946,7 @@ async function findBestPBTHarness(workspacePath) {
   let bestPath = "";
   let bestLabel = "";
   for (const branchId of branchEntries) {
-    const branchPath = path32.join(branchesDir, branchId);
+    const branchPath = path33.join(branchesDir, branchId);
     const branchIterations = await listIterations(branchPath);
     if (branchIterations.length === 0) continue;
     const bestIter = await findBestIteration(branchPath, branchIterations);
@@ -11547,13 +11954,13 @@ async function findBestPBTHarness(workspacePath) {
     const score = log?.score ?? 0;
     if (score > bestScore) {
       bestScore = score;
-      bestPath = path32.join(branchPath, "iterations", bestIter.toString(), "harness");
+      bestPath = path33.join(branchPath, "iterations", bestIter.toString(), "harness");
       bestLabel = `branch ${branchId}, iteration ${bestIter} (${score.toFixed(1)}%)`;
     }
   }
-  const synthesisHarness = path32.join(workspacePath, "synthesis", "harness");
+  const synthesisHarness = path33.join(workspacePath, "synthesis", "harness");
   try {
-    await fs32.access(synthesisHarness);
+    await fs33.access(synthesisHarness);
     const synthesisLog = await loadIterationLog(workspacePath, 999);
     const synthScore = synthesisLog?.score ?? 0;
     if (synthScore > bestScore) {
@@ -11572,26 +11979,26 @@ async function applyEvolution(workspacePath, projectRoot, targetIteration, pbt)
     if (!pbtResult) {
       throw new Error("No PBT results found. Run `kairn evolve pbt` first.");
     }
-    const claudeDir2 = path32.join(projectRoot, ".claude");
+    const claudeDir2 = path33.join(projectRoot, ".claude");
     const diffPreview2 = await generateDiff2(claudeDir2, pbtResult.harnessPath);
     const currentFiles2 = await listFilesRecursive(claudeDir2);
     const targetFiles2 = await listFilesRecursive(pbtResult.harnessPath);
     const allPaths2 = /* @__PURE__ */ new Set([...currentFiles2, ...targetFiles2]);
     const filesChanged2 = [];
     for (const filePath of allPaths2) {
-      const currentContent = await fs32.readFile(path32.join(claudeDir2, filePath), "utf-8").catch(() => null);
-      const targetContent = await fs32.readFile(path32.join(pbtResult.harnessPath, filePath), "utf-8").catch(() => null);
+      const currentContent = await fs33.readFile(path33.join(claudeDir2, filePath), "utf-8").catch(() => null);
+      const targetContent = await fs33.readFile(path33.join(pbtResult.harnessPath, filePath), "utf-8").catch(() => null);
       if (currentContent !== targetContent) {
         filesChanged2.push(filePath);
       }
     }
-    await fs32.rm(claudeDir2, { recursive: true, force: true });
+    await fs33.rm(claudeDir2, { recursive: true, force: true });
     await copyDir(pbtResult.harnessPath, claudeDir2);
-    const harnessMcpJson2 = path32.join(pbtResult.harnessPath, ".mcp.json");
-    const projectMcpJson2 = path32.join(projectRoot, ".mcp.json");
+    const harnessMcpJson2 = path33.join(pbtResult.harnessPath, ".mcp.json");
+    const projectMcpJson2 = path33.join(projectRoot, ".mcp.json");
     try {
-      await fs32.access(harnessMcpJson2);
-      await fs32.copyFile(harnessMcpJson2, projectMcpJson2);
+      await fs33.access(harnessMcpJson2);
+      await fs33.copyFile(harnessMcpJson2, projectMcpJson2);
       if (!filesChanged2.includes(".mcp.json")) filesChanged2.push(".mcp.json");
     } catch {
     }
@@ -11617,37 +12024,37 @@ async function applyEvolution(workspacePath, projectRoot, targetIteration, pbt)
   } else {
     iter = await findBestIteration(workspacePath, iterations);
   }
-  const harnessPath = path32.join(
+  const harnessPath = path33.join(
     workspacePath,
     "iterations",
     iter.toString(),
     "harness"
   );
-  const claudeDir = path32.join(projectRoot, ".claude");
+  const claudeDir = path33.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 fs32.readFile(path32.join(claudeDir, filePath), "utf-8").catch(() => null);
-    const targetContent = await fs32.readFile(path32.join(harnessPath, filePath), "utf-8").catch(() => null);
+    const currentContent = await fs33.readFile(path33.join(claudeDir, filePath), "utf-8").catch(() => null);
+    const targetContent = await fs33.readFile(path33.join(harnessPath, filePath), "utf-8").catch(() => null);
     if (currentContent !== targetContent) {
       filesChanged.push(filePath);
     }
   }
-  await fs32.rm(claudeDir, { recursive: true, force: true });
+  await fs33.rm(claudeDir, { recursive: true, force: true });
   await copyDir(harnessPath, claudeDir);
-  const harnessMcpJson = path32.join(harnessPath, ".mcp.json");
-  const projectMcpJson = path32.join(projectRoot, ".mcp.json");
+  const harnessMcpJson = path33.join(harnessPath, ".mcp.json");
+  const projectMcpJson = path33.join(projectRoot, ".mcp.json");
   try {
-    await fs32.access(harnessMcpJson);
-    const currentMcp = await fs32.readFile(projectMcpJson, "utf-8").catch(() => null);
-    const targetMcp = await fs32.readFile(harnessMcpJson, "utf-8").catch(() => null);
+    await fs33.access(harnessMcpJson);
+    const currentMcp = await fs33.readFile(projectMcpJson, "utf-8").catch(() => null);
+    const targetMcp = await fs33.readFile(harnessMcpJson, "utf-8").catch(() => null);
     if (currentMcp !== targetMcp) {
       filesChanged.push(".mcp.json");
     }
-    await fs32.copyFile(harnessMcpJson, projectMcpJson);
+    await fs33.copyFile(harnessMcpJson, projectMcpJson);
   } catch {
   }
   return {
@@ -11680,7 +12087,7 @@ var DEFAULT_CONFIG = {
 };
 async function loadEvolveConfigFromWorkspace(workspacePath) {
   try {
-    const configStr = await fs35.readFile(path36.join(workspacePath, "config.yaml"), "utf-8");
+    const configStr = await fs36.readFile(path37.join(workspacePath, "config.yaml"), "utf-8");
     const parsed = yamlParse2(configStr);
     return {
       model: parsed.model ?? DEFAULT_CONFIG.model,
@@ -11710,9 +12117,9 @@ evolveCommand.command("init").description("Initialize an evolution workspace wit
   try {
     const projectRoot = process.cwd();
     console.log(ui.section("Evolve Init"));
-    const claudeDir = path36.join(projectRoot, ".claude");
+    const claudeDir = path37.join(projectRoot, ".claude");
     try {
-      await fs35.access(claudeDir);
+      await fs36.access(claudeDir);
     } catch {
       console.log(ui.error("No .claude/ directory found. Run kairn describe first."));
       process.exit(1);
@@ -11762,7 +12169,7 @@ evolveCommand.command("init").description("Initialize an evolution workspace wit
           if (config) {
             let claudeMd = "";
             try {
-              claudeMd = await fs35.readFile(path36.join(claudeDir, "CLAUDE.md"), "utf-8");
+              claudeMd = await fs36.readFile(path37.join(claudeDir, "CLAUDE.md"), "utf-8");
             } catch {
             }
             const profile = await buildProjectProfile(projectRoot);
@@ -11793,16 +12200,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 = path36.join(projectRoot, ".kairn-evolve");
+    const workspace = path37.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve Baseline"));
     try {
-      await fs35.access(workspace);
+      await fs36.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 = path36.join(workspace, "baseline");
+    const baselineDir = path37.join(workspace, "baseline");
     const fileCount = await countFiles(baselineDir);
     console.log(ui.success(`Baseline snapshot created (${fileCount} files)`));
   } catch (err) {
@@ -11814,18 +12221,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("--architect-every <n>", "Run architect proposer every N iterations (default: 3)").option("--schedule <type>", "Architect schedule: explore-exploit, constant, or adaptive (default: explore-exploit)").option("--architect-model <model>", "Model for architect proposer (defaults to proposer model)").option("-i, --interactive", "Configure evolution settings interactively").action(async (options) => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path36.join(projectRoot, ".kairn-evolve");
+    const workspace = path37.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve Run"));
     try {
-      await fs35.access(workspace);
+      await fs36.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
     }
-    const tasksPath = path36.join(workspace, "tasks.yaml");
+    const tasksPath = path37.join(workspace, "tasks.yaml");
     let tasksContent;
     try {
-      tasksContent = await fs35.readFile(tasksPath, "utf-8");
+      tasksContent = await fs36.readFile(tasksPath, "utf-8");
     } catch {
       console.log(ui.error("No tasks.yaml found. Run kairn evolve init first."));
       process.exit(1);
@@ -11844,15 +12251,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 = path36.join(projectRoot, ".claude");
+      const harnessPath = path37.join(projectRoot, ".claude");
       const results = [];
       for (const task of tasksToRun) {
-        const traceDir = path36.join(workspace, "traces", "0", task.id);
+        const traceDir = path37.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 fs35.readFile(path36.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
-          const stderr = await fs35.readFile(path36.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
+          const stdout = await fs36.readFile(path37.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
+          const stderr = await fs36.readFile(path37.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
           const score = await scoreTask(task, traceDir, stdout, stderr, config);
           result.score = score;
           await writeScore(traceDir, score);
@@ -12019,7 +12426,7 @@ evolveCommand.command("run").description("Run tasks against the current harness"
         }
       }
       try {
-        await fs35.access(path36.join(workspace, "iterations", "0", "harness"));
+        await fs36.access(path37.join(workspace, "iterations", "0", "harness"));
       } catch {
         console.log(ui.error("No baseline harness found. Run kairn evolve baseline first."));
         process.exit(1);
@@ -12126,16 +12533,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 = path36.join(projectRoot, ".kairn-evolve");
+    const workspace = path37.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve PBT"));
     try {
-      await fs35.access(workspace);
+      await fs36.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
     }
     try {
-      await fs35.access(path36.join(workspace, "iterations", "0", "harness"));
+      await fs36.access(path37.join(workspace, "iterations", "0", "harness"));
     } catch {
       console.log(ui.error("No baseline harness found. Run kairn evolve baseline first."));
       process.exit(1);
@@ -12155,8 +12562,8 @@ evolveCommand.command("pbt").description("Run Population-Based Training with par
     if (sampling === "thompson" || sampling === "uniform") {
       evolveConfig.samplingStrategy = sampling;
     }
-    const tasksPath = path36.join(workspace, "tasks.yaml");
-    const tasksContent = await fs35.readFile(tasksPath, "utf-8");
+    const tasksPath = path37.join(workspace, "tasks.yaml");
+    const tasksContent = await fs36.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"));
@@ -12214,10 +12621,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("--pbt", "Apply best PBT result (branch winner or synthesis)").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 = path36.join(projectRoot, ".kairn-evolve");
+    const workspace = path37.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve Apply"));
     try {
-      await fs35.access(workspace);
+      await fs36.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
@@ -12258,9 +12665,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 = path36.join(projectRoot, ".kairn-evolve");
+    const workspace = path37.join(projectRoot, ".kairn-evolve");
     try {
-      await fs35.access(workspace);
+      await fs36.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
@@ -12281,23 +12688,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 = path36.join(projectRoot, ".kairn-evolve");
+    const workspace = path37.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 = path36.join(workspace, "iterations", iter1.toString(), "harness");
-    const harness2 = path36.join(workspace, "iterations", iter2.toString(), "harness");
+    const harness1 = path37.join(workspace, "iterations", iter1.toString(), "harness");
+    const harness2 = path37.join(workspace, "iterations", iter2.toString(), "harness");
     try {
-      await fs35.access(harness1);
+      await fs36.access(harness1);
     } catch {
       console.log(ui.error(`Iteration ${iter1} harness not found at ${harness1}`));
       process.exit(1);
     }
     try {
-      await fs35.access(harness2);
+      await fs36.access(harness2);
     } catch {
       console.log(ui.error(`Iteration ${iter2} harness not found at ${harness2}`));
       process.exit(1);
@@ -12404,7 +12811,7 @@ evolveCommand.command("research").description("Run cross-repo research to discov
     const reportText = formatResearchReport2(report);
     console.log("\n" + reportText);
     if (options.output) {
-      await fs35.writeFile(options.output, reportText, "utf-8");
+      await fs36.writeFile(options.output, reportText, "utf-8");
       console.log(chalk14.green(`
   Report saved to ${options.output}`));
     }
@@ -12421,10 +12828,10 @@ evolveCommand.command("research").description("Run cross-repo research to discov
 async function countFiles(dir) {
   let count = 0;
   try {
-    const entries = await fs35.readdir(dir, { withFileTypes: true });
+    const entries = await fs36.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        count += await countFiles(path36.join(dir, entry.name));
+        count += await countFiles(path37.join(dir, entry.name));
       } else {
         count++;
       }
@@ -12440,12 +12847,42 @@ init_scan();
 init_analyze();
 init_types3();
 init_cache();
+init_proposer();
 init_ui();
 init_logo();
 import { Command as Command12 } from "commander";
 import chalk15 from "chalk";
+import fs37 from "fs/promises";
+import path38 from "path";
 import ora3 from "ora";
 async function analyzeAction(options) {
+  if (options.ir) {
+    const irPath = path38.join(process.cwd(), ".kairn", "harness-ir.json");
+    try {
+      const raw = await fs37.readFile(irPath, "utf-8");
+      const ir = JSON.parse(raw);
+      if (!options.json) {
+        printCompactBanner();
+        console.log(ui.section("Harness IR"));
+        console.log(buildIRSummary(ir));
+        console.log("");
+        console.log(chalk15.dim(`  Source: ${irPath}`));
+        console.log("");
+      } else {
+        console.log(JSON.stringify(ir, null, 2));
+      }
+    } catch {
+      if (options.json) {
+        console.log(JSON.stringify({ error: "No harness IR found. Run `kairn optimize` first." }));
+      } else {
+        printCompactBanner();
+        console.log(ui.warn("No harness IR found. Run `kairn optimize` first."));
+        console.log("");
+      }
+      process.exit(1);
+    }
+    return;
+  }
   if (!options.json) {
     printCompactBanner();
   }
@@ -12498,11 +12935,14 @@ async function analyzeAction(options) {
     indent: 2
   }).start();
   let analysis;
+  let packedSource = "";
   try {
-    analysis = await analyzeProject(targetDir, profile, config, {
+    const result = await analyzeProject(targetDir, profile, config, {
       refresh: options.refresh,
       tokenBudget: options.tokenBudget
     });
+    analysis = result.analysis;
+    packedSource = result.packedSource;
     analysisSpinner?.succeed(
       options.refresh ? "Re-analyzed from scratch" : "Codebase analyzed"
     );
@@ -12580,9 +13020,10 @@ async function analyzeAction(options) {
     }
   }
   console.log("");
+  const packedStats = packedSource ? ` \xB7 ${packedSource.length.toLocaleString()} chars packed` : "";
   console.log(
     chalk15.dim(
-      `  Sampled ${analysis.sampled_files.length} files \xB7 analyzed ${analysis.analyzed_at}`
+      `  Sampled ${analysis.sampled_files.length} files${packedStats} \xB7 analyzed ${analysis.analyzed_at}`
     )
   );
   console.log(ui.divider());
@@ -12590,7 +13031,7 @@ async function analyzeAction(options) {
 }
 var analyzeCommand = new Command12("analyze").description(
   "Analyze project source code to understand purpose, architecture, and workflows"
-).option("--refresh", "Force re-analysis, bypassing cache").option("--json", "Output raw JSON (for piping)").option("--token-budget <tokens>", "Max tokens of source code to sample (default: 60000)", parseInt).action(analyzeAction);
+).option("--refresh", "Force re-analysis, bypassing cache").option("--json", "Output raw JSON (for piping)").option("--ir", "Display the persisted harness IR from .kairn/harness-ir.json").option("--token-budget <tokens>", "Max tokens of source code to sample (default: 60000)", parseInt).action(analyzeAction);
 
 // src/cli.ts
 var require2 = createRequire(import.meta.url);