kairn-cli 2.2.10 → 2.4.0

package/dist/cli.js

@@ -1,10 +1,107 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/evolve/memory.ts
+var memory_exports = {};
+__export(memory_exports, {
+  buildRunSummary: () => buildRunSummary,
+  formatMemoryForProposer: () => formatMemoryForProposer,
+  loadProposerMemory: () => loadProposerMemory,
+  saveRunSummary: () => saveRunSummary
+});
+import fs19 from "fs/promises";
+import path19 from "path";
+async function loadProposerMemory(workspacePath) {
+  const memoryPath = path19.join(workspacePath, MEMORY_FILE);
+  try {
+    const raw = await fs19.readFile(memoryPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return parsed;
+    return [];
+  } catch {
+    return [];
+  }
+}
+function buildRunSummary(history, baselineScore, bestScore) {
+  const effectiveMutations = [];
+  const regressiveMutations = [];
+  for (let i = 1; i < history.length; i++) {
+    const prev = history[i - 1];
+    const curr = history[i];
+    if (!curr.proposal?.mutations.length) continue;
+    const delta = curr.score - prev.score;
+    const summary = curr.proposal.mutations.map((m) => `${m.action} ${m.file}: ${m.rationale}`).join("; ");
+    if (delta > 0) {
+      effectiveMutations.push(`+${delta.toFixed(1)}: ${summary}`);
+    } else if (delta < -5) {
+      regressiveMutations.push(`${delta.toFixed(1)}: ${summary}`);
+    }
+  }
+  const improvement = bestScore - baselineScore;
+  const insights = improvement > 0 ? `Improved ${improvement.toFixed(1)} points. ${effectiveMutations.length} helpful mutations, ${regressiveMutations.length} regressions.` : `No improvement. ${regressiveMutations.length} regressions observed.`;
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    baselineScore,
+    bestScore,
+    improvement,
+    effectiveMutations,
+    regressiveMutations,
+    insights
+  };
+}
+async function saveRunSummary(workspacePath, summary) {
+  const existing = await loadProposerMemory(workspacePath);
+  existing.push(summary);
+  const trimmed = existing.slice(-MAX_ENTRIES);
+  const memoryPath = path19.join(workspacePath, MEMORY_FILE);
+  await fs19.writeFile(memoryPath, JSON.stringify(trimmed, null, 2), "utf-8");
+}
+function formatMemoryForProposer(memory) {
+  if (memory.length === 0) return "";
+  const lines = ["## Prior Run History\n"];
+  for (const entry of memory) {
+    lines.push(`### Run at ${entry.timestamp}`);
+    lines.push(`- Baseline: ${entry.baselineScore.toFixed(1)}%, Best: ${entry.bestScore.toFixed(1)}%, Improvement: ${entry.improvement >= 0 ? "+" : ""}${entry.improvement.toFixed(1)}`);
+    if (entry.effectiveMutations.length > 0) {
+      lines.push("- Effective mutations:");
+      for (const m of entry.effectiveMutations.slice(0, 3)) {
+        lines.push(`  - ${m}`);
+      }
+    }
+    if (entry.regressiveMutations.length > 0) {
+      lines.push("- Regressive mutations (AVOID these):");
+      for (const m of entry.regressiveMutations.slice(0, 3)) {
+        lines.push(`  - ${m}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var MEMORY_FILE, MAX_ENTRIES;
+var init_memory = __esm({
+  "src/evolve/memory.ts"() {
+    "use strict";
+    MEMORY_FILE = "proposer-memory.json";
+    MAX_ENTRIES = 10;
+  }
+});
+
 // src/cli.ts
 import { Command as Command12 } from "commander";
 import chalk15 from "chalk";
+import { createRequire } from "module";
 
 // src/commands/init.ts
 import { Command } from "commander";
-import { input, password, select } from "@inquirer/prompts";
+import { confirm, input, password, select } from "@inquirer/prompts";
 import chalk3 from "chalk";
 import Anthropic from "@anthropic-ai/sdk";
 import OpenAI from "openai";
@@ -62,6 +159,59 @@ async function saveConfig(config) {
   await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
 }
 
+// src/auth/keychain.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var KEYCHAIN_SERVICE = "Claude Code-credentials";
+var TOKEN_EXPIRY_BUFFER_MS = 6e4;
+function parseKeychainCredentials(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const obj = parsed;
+  const oauth = obj["claudeAiOauth"];
+  if (typeof oauth !== "object" || oauth === null) return null;
+  const oauthObj = oauth;
+  const accessToken = oauthObj["accessToken"];
+  const refreshToken = oauthObj["refreshToken"];
+  const expiresAt = oauthObj["expiresAt"];
+  const subscriptionType = oauthObj["subscriptionType"];
+  if (typeof accessToken !== "string" || !accessToken) return null;
+  if (typeof refreshToken !== "string") return null;
+  if (typeof expiresAt !== "number") return null;
+  return {
+    accessToken,
+    refreshToken,
+    expiresAt,
+    subscriptionType: typeof subscriptionType === "string" ? subscriptionType : "unknown"
+  };
+}
+function isTokenExpired(credentials) {
+  return Date.now() + TOKEN_EXPIRY_BUFFER_MS >= credentials.expiresAt;
+}
+async function readClaudeCodeCredentials(account) {
+  if (process.platform !== "darwin") return null;
+  try {
+    const acct = account ?? "";
+    const cmd = acct ? `security find-generic-password -s "${KEYCHAIN_SERVICE}" -a "${acct}" -w` : `security find-generic-password -s "${KEYCHAIN_SERVICE}" -w`;
+    const { stdout } = await execAsync(cmd, { timeout: 5e3 });
+    return parseKeychainCredentials(stdout.trim());
+  } catch {
+    return null;
+  }
+}
+async function getAccessToken(account) {
+  const creds = await readClaudeCodeCredentials(account);
+  if (!creds) return null;
+  if (isTokenExpired(creds)) return null;
+  return creds.accessToken;
+}
+
 // src/providers.ts
 var PROVIDER_CONFIGS = {
   anthropic: {
@@ -221,7 +371,7 @@ var ui = {
   // Key-value pairs
   kv: (key, value) => `  ${chalk.cyan(key.padEnd(14))} ${value}`,
   // File list
-  file: (path25) => chalk.dim(`    ${path25}`),
+  file: (path26) => chalk.dim(`    ${path26}`),
   // Tool display
   tool: (name, reason) => `    ${warmStone("\u25CF")} ${chalk.bold(name)}
       ${chalk.dim(reason)}`,
@@ -508,30 +658,49 @@ var initCommand = new Command("init").description("Set up Kairn with your API ke
       choices: PROVIDER_MODELS[provider]
     });
   }
-  const apiKey = await password({
-    message: `${providerDisplayName} API key${provider === "other" ? " (Enter to skip)" : ""}`,
-    mask: "*"
-  });
-  if (!apiKey && provider !== "other") {
-    console.log(ui.error("No API key provided. Aborting."));
-    process.exit(1);
+  let apiKey = "";
+  let authType = "api-key";
+  if (provider === "anthropic") {
+    const oauthToken = await getAccessToken();
+    if (oauthToken) {
+      const useOAuth = await confirm({
+        message: "Claude Code subscription detected. Use it instead of an API key? (experimental \u2014 may break)",
+        default: true
+      });
+      if (useOAuth) {
+        authType = "claude-code-oauth";
+        console.log(ui.warn("Using Claude Code OAuth token. This is undocumented and may break at any time."));
+        console.log(ui.success("OAuth token validated"));
+      }
+    }
   }
-  if (apiKey) {
-    console.log(chalk3.dim("\n  Verifying API key..."));
-    const valid = await verifyKey(provider, apiKey, baseURL, model);
-    if (!valid) {
-      console.log(ui.error("Invalid API key. Check your key and try again."));
+  if (authType === "api-key") {
+    apiKey = await password({
+      message: `${providerDisplayName} API key${provider === "other" ? " (Enter to skip)" : ""}`,
+      mask: "*"
+    });
+    if (!apiKey && provider !== "other") {
+      console.log(ui.error("No API key provided. Aborting."));
       process.exit(1);
     }
-    console.log(ui.success("API key verified"));
-  } else {
-    console.log(ui.warn("No API key \u2014 skipping verification"));
+    if (apiKey) {
+      console.log(chalk3.dim("\n  Verifying API key..."));
+      const valid = await verifyKey(provider, apiKey, baseURL, model);
+      if (!valid) {
+        console.log(ui.error("Invalid API key. Check your key and try again."));
+        process.exit(1);
+      }
+      console.log(ui.success("API key verified"));
+    } else {
+      console.log(ui.warn("No API key \u2014 skipping verification"));
+    }
   }
   const config = {
     provider,
-    api_key: apiKey || "",
+    api_key: apiKey,
     model,
     ...baseURL ? { base_url: baseURL } : {},
+    ...authType !== "api-key" ? { auth_type: authType } : {},
     default_runtime: "claude-code",
     created_at: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -555,7 +724,7 @@ var initCommand = new Command("init").description("Set up Kairn with your API ke
 
 // src/commands/describe.ts
 import { Command as Command2 } from "commander";
-import { input as input2, confirm, select as select2 } from "@inquirer/prompts";
+import { input as input2, confirm as confirm2, select as select2 } from "@inquirer/prompts";
 import chalk5 from "chalk";
 
 // src/compiler/compile.ts
@@ -1240,8 +1409,18 @@ async function callLLM(config, userMessage, options) {
   const { systemPrompt } = options;
   const jsonMode = options.jsonMode ?? false;
   const providerName = getProviderName(config.provider);
+  let apiKey = config.api_key;
+  if (config.auth_type === "claude-code-oauth") {
+    const oauthToken = await getAccessToken();
+    if (!oauthToken) {
+      throw new Error(
+        "Claude Code OAuth token unavailable or expired. Run `kairn init` to reconfigure, or launch Claude Code to refresh the token."
+      );
+    }
+    apiKey = oauthToken;
+  }
   if (config.provider === "anthropic") {
-    const client2 = new Anthropic2({ apiKey: config.api_key });
+    const client2 = new Anthropic2({ apiKey });
     const messages = [
       { role: "user", content: userMessage }
     ];
@@ -1262,7 +1441,7 @@ async function callLLM(config, userMessage, options) {
     }
   }
   const resolvedBaseURL = getBaseURL(config.provider, config.base_url);
-  const clientOptions = { apiKey: config.api_key };
+  const clientOptions = { apiKey };
   if (resolvedBaseURL) clientOptions.baseURL = resolvedBaseURL;
   const client = new OpenAI2(clientOptions);
   try {
@@ -2441,7 +2620,7 @@ Autonomy level: ${autonomyLevel} (${autonomyLabel(autonomyLevel)})`;
       console.log("");
     }
   }
-  const proceed = options.yes || await confirm({
+  const proceed = options.yes || await confirm2({
     message: "Generate environment in current directory?",
     default: true
   });
@@ -2656,7 +2835,7 @@ var updateRegistryCommand = new Command5("update-registry").description("Fetch t
 
 // src/commands/optimize.ts
 import { Command as Command6 } from "commander";
-import { confirm as confirm2 } from "@inquirer/prompts";
+import { confirm as confirm3 } from "@inquirer/prompts";
 import chalk9 from "chalk";
 import ora from "ora";
 import fs12 from "fs/promises";
@@ -2718,7 +2897,7 @@ function detectFramework(deps) {
   ];
   const detected = [];
   for (const [packages, name] of frameworks) {
-    if (packages.some((pkg) => deps.includes(pkg))) {
+    if (packages.some((pkg2) => deps.includes(pkg2))) {
       detected.push(name);
     }
   }
@@ -2742,11 +2921,11 @@ function extractEnvKeys(content) {
   return keys;
 }
 async function scanProject(dir) {
-  const pkg = await readJsonSafe(path11.join(dir, "package.json"));
-  const deps = pkg?.dependencies ? Object.keys(pkg.dependencies) : [];
-  const devDeps = pkg?.devDependencies ? Object.keys(pkg.devDependencies) : [];
+  const pkg2 = await readJsonSafe(path11.join(dir, "package.json"));
+  const deps = pkg2?.dependencies ? Object.keys(pkg2.dependencies) : [];
+  const devDeps = pkg2?.devDependencies ? Object.keys(pkg2.devDependencies) : [];
   const allDeps = [...deps, ...devDeps];
-  const scripts = pkg?.scripts || {};
+  const scripts = pkg2?.scripts || {};
   const rootFiles = await listDirSafe(dir);
   const keyFiles = rootFiles.filter(
     (f) => [
@@ -2808,8 +2987,8 @@ async function scanProject(dir) {
     existingSkills = await listDirSafe(path11.join(claudeDir, "skills"));
     existingAgents = (await listDirSafe(path11.join(claudeDir, "agents"))).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
   }
-  const name = pkg?.name || path11.basename(dir);
-  const description = pkg?.description || "";
+  const name = pkg2?.name || path11.basename(dir);
+  const description = pkg2?.description || "";
   return {
     name,
     description,
@@ -3028,7 +3207,7 @@ var optimizeCommand = new Command6("optimize").description("Scan an existing pro
     }
     if (!options.yes) {
       console.log("");
-      const proceed = await confirm2({
+      const proceed = await confirm3({
         message: "Generate optimized environment? This will overwrite existing .claude/ files.",
         default: false
       });
@@ -3040,7 +3219,7 @@ var optimizeCommand = new Command6("optimize").description("Scan an existing pro
   } else {
     console.log(chalk9.dim("\n  No existing .claude/ directory found \u2014 generating from scratch.\n"));
     if (!options.yes) {
-      const proceed = await confirm2({
+      const proceed = await confirm3({
         message: "Generate Claude Code environment for this project?",
         default: true
       });
@@ -3103,7 +3282,7 @@ var optimizeCommand = new Command6("optimize").description("Scan an existing pro
       }
     }
     console.log("");
-    const apply = await confirm2({
+    const apply = await confirm3({
       message: "Apply these changes?",
       default: true
     });
@@ -3699,10 +3878,10 @@ var keysCommand = new Command10("keys").description("Add or update API keys for
 import { Command as Command11 } from "commander";
 import chalk14 from "chalk";
 import ora2 from "ora";
-import fs24 from "fs/promises";
-import path24 from "path";
+import fs25 from "fs/promises";
+import path25 from "path";
 import { parse as yamlParse2 } from "yaml";
-import { confirm as confirm3, select as select4 } from "@inquirer/prompts";
+import { confirm as confirm4, select as select4 } from "@inquirer/prompts";
 
 // src/evolve/init.ts
 import fs15 from "fs/promises";
@@ -3945,14 +4124,14 @@ async function buildProjectProfile(projectRoot) {
       path15.join(projectRoot, "package.json"),
       "utf-8"
     );
-    const pkg = JSON.parse(pkgStr);
+    const pkg2 = JSON.parse(pkgStr);
     profile.language = "typescript";
-    if (pkg.scripts && typeof pkg.scripts === "object") {
-      profile.scripts = pkg.scripts;
+    if (pkg2.scripts && typeof pkg2.scripts === "object") {
+      profile.scripts = pkg2.scripts;
     }
     const deps = {
-      ...pkg.dependencies ?? {},
-      ...pkg.devDependencies ?? {}
+      ...pkg2.dependencies ?? {},
+      ...pkg2.devDependencies ?? {}
     };
     if (deps.next) {
       profile.framework = "Next.js";
@@ -4051,8 +4230,8 @@ async function copyDir(src, dest) {
 }
 
 // src/evolve/runner.ts
-import { exec as exec2, spawn } from "child_process";
-import { promisify as promisify2 } from "util";
+import { exec as exec3, spawn } from "child_process";
+import { promisify as promisify3 } from "util";
 import fs18 from "fs/promises";
 import os3 from "os";
 import path18 from "path";
@@ -4177,11 +4356,11 @@ async function loadIterationLog(workspacePath, iteration) {
 }
 
 // src/evolve/exec.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
 async function execCommand(cmd, cwd, timeoutMs = 3e4) {
-  return execAsync(cmd, { cwd, timeout: timeoutMs });
+  return execAsync2(cmd, { cwd, timeout: timeoutMs });
 }
 
 // src/evolve/scorers.ts
@@ -4341,21 +4520,47 @@ async function rubricScorer(task, workspacePath, stdout, stderr, config) {
     breakdown
   };
 }
+function classifyFailure(score, stdout, stderr) {
+  if (score.pass) return score;
+  const combined = `${stdout}
+${stderr}`.toLowerCase();
+  const scoreValue = score.score ?? 0;
+  let failureCategory = "unknown";
+  let failureReason = "";
+  if (stderr.includes("[setup]") && stderr.includes("Error") || combined.includes("command not found") || combined.includes("no such file or directory")) {
+    failureCategory = "task";
+    failureReason = "Task setup failed or references missing resources";
+  } else if (combined.includes("token limit") || combined.includes("context length") || combined.includes("rate limit") || combined.includes("api error") || combined.includes("429") || combined.includes("overloaded")) {
+    failureCategory = "model";
+    failureReason = "Model API error, token limit, or rate limit";
+  } else if (combined.includes("build failed") && combined.includes("before") || combined.includes("merge conflict") || combined.includes("git dirty") || combined.includes("uncommitted changes")) {
+    failureCategory = "repo";
+    failureReason = "Pre-existing repo issues (build failure, dirty state)";
+  } else if (scoreValue >= 20 && scoreValue < 80) {
+    failureCategory = "harness";
+    failureReason = "Agent attempted the task but did not follow harness conventions";
+  }
+  return { ...score, failureCategory, failureReason };
+}
 async function scoreTask(task, workspacePath, stdout, stderr, config) {
+  let score;
   if (task.scoring === "pass-fail") {
-    return passFailScorer(task, workspacePath, stdout, stderr);
-  }
-  if (task.scoring === "llm-judge" && config) {
-    return llmJudgeScorer(task, workspacePath, stdout, stderr, config);
+    score = await passFailScorer(task, workspacePath, stdout, stderr);
+  } else if (task.scoring === "llm-judge" && config) {
+    score = await llmJudgeScorer(task, workspacePath, stdout, stderr, config);
+  } else if (task.scoring === "rubric" && config) {
+    score = await rubricScorer(task, workspacePath, stdout, stderr, config);
+  } else {
+    score = await passFailScorer(task, workspacePath, stdout, stderr);
   }
-  if (task.scoring === "rubric" && config) {
-    return rubricScorer(task, workspacePath, stdout, stderr, config);
+  if (!score.pass) {
+    score = classifyFailure(score, stdout, stderr);
   }
-  return passFailScorer(task, workspacePath, stdout, stderr);
+  return score;
 }
 
 // src/evolve/runner.ts
-var execAsync2 = promisify2(exec2);
+var execAsync3 = promisify3(exec3);
 var COPY_SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".kairn-evolve", ".claude"]);
 async function deployMcpJson(harnessPath, workDir) {
   const src = path18.join(harnessPath, ".mcp.json");
@@ -4365,12 +4570,12 @@ async function deployMcpJson(harnessPath, workDir) {
 async function createIsolatedWorkspace(projectRoot, harnessPath) {
   const suffix = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
   try {
-    await execAsync2("git rev-parse --is-inside-work-tree", {
+    await execAsync3("git rev-parse --is-inside-work-tree", {
       cwd: projectRoot,
       timeout: 5e3
     });
     const tmpDir2 = path18.join(os3.tmpdir(), `kairn-evolve-wt-${suffix}`);
-    await execAsync2(`git worktree add --detach "${tmpDir2}" HEAD`, {
+    await execAsync3(`git worktree add --detach "${tmpDir2}" HEAD`, {
       cwd: projectRoot,
       timeout: 3e4
     });
@@ -4409,14 +4614,14 @@ async function copyProjectDir(src, dest) {
 async function cleanupIsolatedWorkspace(workDir, isWorktree, projectRoot) {
   if (isWorktree) {
     try {
-      await execAsync2(`git worktree remove "${workDir}" --force`, {
+      await execAsync3(`git worktree remove "${workDir}" --force`, {
         cwd: projectRoot,
         timeout: 1e4
       });
     } catch {
       await fs18.rm(workDir, { recursive: true, force: true }).catch(() => {
       });
-      await execAsync2("git worktree prune", {
+      await execAsync3("git worktree prune", {
         cwd: projectRoot,
         timeout: 5e3
       }).catch(() => {
@@ -4437,7 +4642,7 @@ async function runTask(task, harnessPath, traceDir, iteration, projectRoot) {
     let setupStderr = "";
     if (task.setup.trim()) {
       try {
-        await execAsync2(task.setup, { cwd: workDir, timeout: 6e4 });
+        await execAsync3(task.setup, { cwd: workDir, timeout: 6e4 });
       } catch (err) {
         setupStderr = err instanceof Error ? err.message : String(err);
       }
@@ -4685,12 +4890,12 @@ async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config,
 }
 
 // src/evolve/loop.ts
-import fs21 from "fs/promises";
-import path21 from "path";
+import fs22 from "fs/promises";
+import path22 from "path";
 
 // src/evolve/proposer.ts
-import fs19 from "fs/promises";
-import path19 from "path";
+import fs20 from "fs/promises";
+import path20 from "path";
 var PROPOSER_SYSTEM_PROMPT = `You are an expert agent environment optimizer. Your job is to improve a Claude Code
 agent environment (.claude/ directory) based on execution traces from real tasks.
 
@@ -4763,18 +4968,18 @@ async function readHarnessFiles(harnessPath) {
   async function walk(dir, prefix) {
     let entries;
     try {
-      entries = await fs19.readdir(dir, { withFileTypes: true });
+      entries = await fs20.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const relativePath = prefix ? path19.join(prefix, entry.name) : entry.name;
-      const fullPath = path19.join(dir, entry.name);
+      const relativePath = prefix ? path20.join(prefix, entry.name) : entry.name;
+      const fullPath = path20.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath, relativePath);
       } else if (entry.isFile()) {
         try {
-          result[relativePath] = await fs19.readFile(fullPath, "utf-8");
+          result[relativePath] = await fs20.readFile(fullPath, "utf-8");
         } catch {
         }
       }
@@ -4790,7 +4995,7 @@ function truncateStdout(stdout, limit) {
   return `[...truncated, showing last ${limit} chars...]
 ${stdout.slice(-limit)}`;
 }
-function buildProposerUserMessage(harnessFiles, traces, tasks, history) {
+function buildProposerUserMessage(harnessFiles, traces, tasks, history, memorySection) {
   const harnessSection = ["## Current Harness Files\n"];
   const fileEntries = Object.entries(harnessFiles);
   if (fileEntries.length === 0) {
@@ -4826,7 +5031,8 @@ ${content}
   const historyBudget = remainingBudget - traceBudget;
   const traceSection = buildTraceSection(traces, traceBudget);
   const historySection = buildHistorySection(history, historyBudget);
-  return fixedContent + "\n" + traceSection + "\n" + historySection;
+  const memoryPart = memorySection ? "\n" + memorySection : "";
+  return fixedContent + "\n" + traceSection + "\n" + historySection + memoryPart;
 }
 function buildTraceSection(traces, budget) {
   if (traces.length === 0) return "## Execution Traces\n\n(No traces available)\n";
@@ -4981,7 +5187,10 @@ function parseProposerResponse(raw) {
 async function propose(iteration, workspacePath, harnessPath, history, tasks, config, proposerModel) {
   const harnessFiles = await readHarnessFiles(harnessPath);
   const traces = await loadIterationTraces(workspacePath, iteration);
-  const userMessage = buildProposerUserMessage(harnessFiles, traces, tasks, history);
+  const { loadProposerMemory: loadProposerMemory2, formatMemoryForProposer: formatMemoryForProposer2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
+  const memory = await loadProposerMemory2(workspacePath);
+  const memorySection = formatMemoryForProposer2(memory);
+  const userMessage = buildProposerUserMessage(harnessFiles, traces, tasks, history, memorySection);
   const proposerConfig = { ...config, model: proposerModel };
   const response = await callLLM(proposerConfig, userMessage, {
     systemPrompt: PROPOSER_SYSTEM_PROMPT,
@@ -4992,60 +5201,60 @@ async function propose(iteration, workspacePath, harnessPath, history, tasks, co
 }
 
 // src/evolve/mutator.ts
-import fs20 from "fs/promises";
-import path20 from "path";
+import fs21 from "fs/promises";
+import path21 from "path";
 async function applyMutations(currentHarnessPath, nextIterationDir, mutations) {
-  const newHarnessPath = path20.join(nextIterationDir, "harness");
+  const newHarnessPath = path21.join(nextIterationDir, "harness");
   await copyDir(currentHarnessPath, newHarnessPath);
   for (const mutation of mutations) {
     if (mutation.file.includes("..")) {
       continue;
     }
-    const filePath = path20.join(newHarnessPath, mutation.file);
+    const filePath = path21.join(newHarnessPath, mutation.file);
     if (mutation.action === "replace") {
       if (!mutation.oldText) {
         continue;
       }
-      const content = await fs20.readFile(filePath, "utf-8");
+      const content = await fs21.readFile(filePath, "utf-8");
       if (!content.includes(mutation.oldText)) {
         continue;
       }
-      await fs20.writeFile(
+      await fs21.writeFile(
         filePath,
         content.replace(mutation.oldText, mutation.newText),
         "utf-8"
       );
     } else if (mutation.action === "add_section") {
       try {
-        const content = await fs20.readFile(filePath, "utf-8");
-        await fs20.writeFile(
+        const content = await fs21.readFile(filePath, "utf-8");
+        await fs21.writeFile(
           filePath,
           content + "\n\n" + mutation.newText,
           "utf-8"
         );
       } catch {
-        await fs20.mkdir(path20.dirname(filePath), { recursive: true });
-        await fs20.writeFile(filePath, mutation.newText, "utf-8");
+        await fs21.mkdir(path21.dirname(filePath), { recursive: true });
+        await fs21.writeFile(filePath, mutation.newText, "utf-8");
       }
     } else if (mutation.action === "create_file") {
-      await fs20.mkdir(path20.dirname(filePath), { recursive: true });
-      await fs20.writeFile(filePath, mutation.newText, "utf-8");
+      await fs21.mkdir(path21.dirname(filePath), { recursive: true });
+      await fs21.writeFile(filePath, mutation.newText, "utf-8");
     } else if (mutation.action === "delete_section") {
       if (!mutation.oldText) {
         continue;
       }
       let sectionContent;
       try {
-        sectionContent = await fs20.readFile(filePath, "utf-8");
+        sectionContent = await fs21.readFile(filePath, "utf-8");
       } catch {
         continue;
       }
       if (!sectionContent.includes(mutation.oldText)) {
         continue;
       }
-      await fs20.writeFile(filePath, sectionContent.replace(mutation.oldText, ""), "utf-8");
+      await fs21.writeFile(filePath, sectionContent.replace(mutation.oldText, ""), "utf-8");
     } else if (mutation.action === "delete_file") {
-      await fs20.unlink(filePath).catch(() => {
+      await fs21.unlink(filePath).catch(() => {
       });
     }
   }
@@ -5093,17 +5302,17 @@ async function readAllFiles(dir) {
   async function walk(current) {
     let entries;
     try {
-      entries = await fs20.readdir(current, { withFileTypes: true });
+      entries = await fs21.readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path20.join(current, entry.name);
-      const relativePath = path20.relative(dir, fullPath);
+      const fullPath = path21.join(current, entry.name);
+      const relativePath = path21.relative(dir, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
-        result[relativePath] = await fs20.readFile(fullPath, "utf-8");
+        result[relativePath] = await fs21.readFile(fullPath, "utf-8");
       }
     }
   }
@@ -5112,20 +5321,27 @@ async function readAllFiles(dir) {
 }
 
 // src/evolve/loop.ts
+function computeMutationCap(iter, maxIterations, maxMutations) {
+  if (maxIterations <= 1) return maxMutations;
+  const progress = iter / (maxIterations - 1);
+  if (progress <= 0.4) return maxMutations;
+  const decayProgress = (progress - 0.4) / 0.6;
+  return Math.max(1, Math.round(maxMutations * (1 - decayProgress * (1 - 1 / maxMutations))));
+}
 async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgress) {
   const history = [];
   let bestScore = -1;
   let bestIteration = 0;
   let baselineScore = 0;
   for (let iter = 0; iter < evolveConfig.maxIterations; iter++) {
-    const harnessPath = path21.join(
+    const harnessPath = path22.join(
       workspacePath,
       "iterations",
       iter.toString(),
       "harness"
     );
     try {
-      await fs21.access(harnessPath);
+      await fs22.access(harnessPath);
     } catch {
       if (iter === 0) {
         throw new Error(
@@ -5158,6 +5374,29 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
           tasksToRun.push(task);
         }
       }
+      const sampleSize = evolveConfig.evalSampleSize;
+      if (sampleSize > 0 && sampleSize < tasksToRun.length) {
+        const shuffled = [...tasksToRun].sort((a, b) => {
+          const hashA = (iter * 31 + a.id.charCodeAt(0)) % 1e3;
+          const hashB = (iter * 31 + b.id.charCodeAt(0)) % 1e3;
+          return hashA - hashB;
+        });
+        const sampled = new Set(shuffled.slice(0, sampleSize).map((t) => t.id));
+        for (const task of tasksToRun) {
+          if (!sampled.has(task.id)) {
+            const prev = prevLog.taskResults[task.id];
+            const prevVal = prev ? prev.score ?? (prev.pass ? 100 : 0) : 0;
+            carriedScores[task.id] = { pass: prevVal >= 50, score: prevVal };
+            onProgress?.({
+              type: "task-skipped",
+              iteration: iter,
+              taskId: task.id,
+              message: `Sampled out ${task.id} (mini-batch ${sampleSize}/${tasksToRun.length})`
+            });
+          }
+        }
+        tasksToRun = tasksToRun.filter((t) => sampled.has(t.id));
+      }
     }
     const { results: evalResults, aggregate: evalAggregate } = await evaluateAll(
       tasksToRun,
@@ -5218,7 +5457,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       };
       await writeIterationLog(workspacePath, rollbackLog);
       history.push(rollbackLog);
-      const bestHarnessPath = path21.join(
+      const bestHarnessPath = path22.join(
         workspacePath,
         "iterations",
         bestIteration.toString(),
@@ -5236,13 +5475,14 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
             kairnConfig,
             evolveConfig.proposerModel
           );
-          if (rollbackProposal.mutations.length > evolveConfig.maxMutationsPerIteration) {
+          const rollbackCap = computeMutationCap(iter, evolveConfig.maxIterations, evolveConfig.maxMutationsPerIteration);
+          if (rollbackProposal.mutations.length > rollbackCap) {
             rollbackProposal = {
               ...rollbackProposal,
-              mutations: rollbackProposal.mutations.slice(0, evolveConfig.maxMutationsPerIteration)
+              mutations: rollbackProposal.mutations.slice(0, rollbackCap)
             };
           }
-          const nextIterDir2 = path21.join(workspacePath, "iterations", (iter + 1).toString());
+          const nextIterDir2 = path22.join(workspacePath, "iterations", (iter + 1).toString());
           await applyMutations(bestHarnessPath, nextIterDir2, rollbackProposal.mutations);
           onProgress?.({
             type: "mutations-applied",
@@ -5250,8 +5490,8 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
             mutationCount: rollbackProposal.mutations.length
           });
         } catch {
-          const nextIterDir2 = path21.join(workspacePath, "iterations", (iter + 1).toString());
-          await copyDir(bestHarnessPath, path21.join(nextIterDir2, "harness"));
+          const nextIterDir2 = path22.join(workspacePath, "iterations", (iter + 1).toString());
+          await copyDir(bestHarnessPath, path22.join(nextIterDir2, "harness"));
         }
       }
       continue;
@@ -5297,10 +5537,11 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         kairnConfig,
         evolveConfig.proposerModel
       );
-      if (proposal.mutations.length > evolveConfig.maxMutationsPerIteration) {
+      const iterCap = computeMutationCap(iter, evolveConfig.maxIterations, evolveConfig.maxMutationsPerIteration);
+      if (proposal.mutations.length > iterCap) {
         proposal = {
           ...proposal,
-          mutations: proposal.mutations.slice(0, evolveConfig.maxMutationsPerIteration)
+          mutations: proposal.mutations.slice(0, iterCap)
         };
       }
     } catch (err) {
@@ -5310,12 +5551,12 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
         iteration: iter,
         message: `Proposer failed: ${errMsg}`
       });
-      const nextIterDir2 = path21.join(
+      const nextIterDir2 = path22.join(
         workspacePath,
         "iterations",
         (iter + 1).toString()
       );
-      await copyDir(harnessPath, path21.join(nextIterDir2, "harness"));
+      await copyDir(harnessPath, path22.join(nextIterDir2, "harness"));
       const skipLog = {
         iteration: iter,
         score: aggregate,
@@ -5328,7 +5569,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       history.push(skipLog);
       continue;
     }
-    const nextIterDir = path21.join(
+    const nextIterDir = path22.join(
       workspacePath,
       "iterations",
       (iter + 1).toString()
@@ -5342,7 +5583,7 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
       );
       diffPatch = mutationResult.diffPatch;
     } catch {
-      await copyDir(harnessPath, path21.join(nextIterDir, "harness"));
+      await copyDir(harnessPath, path22.join(nextIterDir, "harness"));
     }
     onProgress?.({
       type: "mutations-applied",
@@ -5360,6 +5601,62 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
     await writeIterationLog(workspacePath, iterLog);
     history.push(iterLog);
   }
+  if (evolveConfig.usePrincipal && history.length >= 2) {
+    onProgress?.({ type: "proposing", iteration: history.length, message: "Principal Proposer synthesizing final harness" });
+    const baselineHarnessPath = path22.join(workspacePath, "iterations", "0", "harness");
+    try {
+      const principalProposal = await propose(
+        history.length,
+        workspacePath,
+        baselineHarnessPath,
+        history,
+        tasks,
+        kairnConfig,
+        evolveConfig.proposerModel
+      );
+      if (principalProposal.mutations.length > evolveConfig.maxMutationsPerIteration) {
+        principalProposal.mutations = principalProposal.mutations.slice(0, evolveConfig.maxMutationsPerIteration);
+      }
+      const principalIterNum = history.length;
+      const principalIterDir = path22.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(
+        tasks,
+        mutResult.newHarnessPath,
+        workspacePath,
+        principalIterNum,
+        kairnConfig,
+        onProgress,
+        evolveConfig.runsPerTask,
+        evolveConfig.parallelTasks
+      );
+      onProgress?.({ type: "iteration-scored", iteration: principalIterNum, score: principalAggregate });
+      const principalLog = {
+        iteration: principalIterNum,
+        score: principalAggregate,
+        taskResults: principalResults,
+        proposal: principalProposal,
+        diffPatch: mutResult.diffPatch,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await writeIterationLog(workspacePath, principalLog);
+      history.push(principalLog);
+      if (principalAggregate > bestScore) {
+        bestScore = principalAggregate;
+        bestIteration = principalIterNum;
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      onProgress?.({ type: "proposer-error", iteration: history.length, message: `Principal failed: ${errMsg}` });
+    }
+  }
+  try {
+    const { buildRunSummary: buildRunSummary2, saveRunSummary: saveRunSummary2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
+    const summary = buildRunSummary2(history, baselineScore, bestScore);
+    await saveRunSummary2(workspacePath, summary);
+  } catch {
+  }
   onProgress?.({
     type: "complete",
     iteration: history.length > 0 ? history.length - 1 : 0,
@@ -5374,8 +5671,8 @@ async function evolve(workspacePath, tasks, kairnConfig, evolveConfig, onProgres
 }
 
 // src/evolve/report.ts
-import fs22 from "fs/promises";
-import path22 from "path";
+import fs23 from "fs/promises";
+import path23 from "path";
 
 // src/evolve/diagnosis.ts
 function numericScore(s) {
@@ -5425,10 +5722,10 @@ function numericScore2(s) {
   return s.score ?? (s.pass ? 100 : 0);
 }
 async function loadAllIterations(workspacePath) {
-  const iterDir = path22.join(workspacePath, "iterations");
+  const iterDir = path23.join(workspacePath, "iterations");
   let entries;
   try {
-    entries = await fs22.readdir(iterDir);
+    entries = await fs23.readdir(iterDir);
   } catch {
     return [];
   }
@@ -5442,7 +5739,7 @@ async function loadAllIterations(workspacePath) {
 }
 async function loadTasks(workspacePath) {
   try {
-    const content = await fs22.readFile(path22.join(workspacePath, "tasks.yaml"), "utf-8");
+    const content = await fs23.readFile(path23.join(workspacePath, "tasks.yaml"), "utf-8");
     const parsed = yamlParse(content);
     return parsed?.tasks ?? [];
   } catch {
@@ -5453,6 +5750,7 @@ function buildLeaderboard(iterations, tasks) {
   const taskIds = tasks.map((t) => t.id);
   return taskIds.map((taskId) => {
     const scores = {};
+    const variance = {};
     let bestScore = -1;
     let bestIteration = 0;
     for (const iter of iterations) {
@@ -5460,13 +5758,21 @@ function buildLeaderboard(iterations, tasks) {
       if (s) {
         const score = numericScore2(s);
         scores[iter.iteration] = score;
+        if (s.variance) {
+          variance[iter.iteration] = {
+            mean: s.variance.mean,
+            stddev: s.variance.stddev,
+            runs: s.variance.runs
+          };
+        }
         if (score > bestScore) {
           bestScore = score;
           bestIteration = iter.iteration;
         }
       }
     }
-    return { taskId, scores, bestIteration, bestScore };
+    const hasVariance = Object.keys(variance).length > 0;
+    return { taskId, scores, bestIteration, bestScore, ...hasVariance ? { variance } : {} };
   });
 }
 function iterationStatus(iter, bestIteration) {
@@ -5502,13 +5808,29 @@ async function generateMarkdownReport(workspacePath) {
   lines.push("");
   lines.push("## Iterations");
   lines.push("");
-  lines.push("| Iter | Score | Mutations | Status |");
-  lines.push("|------|-------|-----------|--------|");
+  const hasVariance = iterations.some(
+    (iter) => Object.values(iter.taskResults).some((s) => s.variance)
+  );
+  if (hasVariance) {
+    lines.push("| Iter | Score | Mutations | Status |");
+    lines.push("|------|-------|-----------|--------|");
+  } else {
+    lines.push("| Iter | Score | Mutations | Status |");
+    lines.push("|------|-------|-----------|--------|");
+  }
   for (const iter of iterations) {
     const mutations = iter.proposal?.mutations.length ?? 0;
     const mutStr = mutations > 0 ? mutations.toString() : "-";
     const status = iterationStatus(iter, bestIter.iteration);
-    lines.push(`| ${iter.iteration} | ${iter.score.toFixed(1)}% | ${mutStr} | ${status} |`);
+    let scoreStr = `${iter.score.toFixed(1)}%`;
+    if (hasVariance) {
+      const stddevs = Object.values(iter.taskResults).map((s) => s.variance?.stddev).filter((v) => v !== void 0);
+      if (stddevs.length > 0) {
+        const avgStddev = stddevs.reduce((a, b) => a + b, 0) / stddevs.length;
+        scoreStr = `${iter.score.toFixed(1)}% \xB1${avgStddev.toFixed(1)}`;
+      }
+    }
+    lines.push(`| ${iter.iteration} | ${scoreStr} | ${mutStr} | ${status} |`);
   }
   lines.push("");
   if (leaderboard.length > 0) {
@@ -5521,7 +5843,10 @@ async function generateMarkdownReport(workspacePath) {
     for (const entry of leaderboard) {
       const scoreCols = iterNums.map((n) => {
         const s = entry.scores[n];
-        return s !== void 0 ? `${s.toFixed(0)}%` : "-";
+        if (s === void 0) return "-";
+        const v = entry.variance?.[n];
+        if (v && v.runs > 1) return `${s.toFixed(0)}% \xB1${v.stddev.toFixed(1)}`;
+        return `${s.toFixed(0)}%`;
       });
       lines.push(`| ${entry.taskId} | ${scoreCols.join(" | ")} | ${entry.bestScore.toFixed(0)}% (iter ${entry.bestIteration}) |`);
     }
@@ -5571,25 +5896,30 @@ async function generateJsonReport(workspacePath) {
       bestIteration: bestIter.iteration,
       improvement
     },
-    iterations: iterations.map((iter) => ({
-      iteration: iter.iteration,
-      score: iter.score,
-      mutationCount: iter.proposal?.mutations.length ?? 0,
-      status: iterationStatus(iter, bestIter.iteration)
-    })),
+    iterations: iterations.map((iter) => {
+      const stddevs = Object.values(iter.taskResults).map((s) => s.variance?.stddev).filter((v) => v !== void 0);
+      const avgStddev = stddevs.length > 0 ? stddevs.reduce((a, b) => a + b, 0) / stddevs.length : void 0;
+      return {
+        iteration: iter.iteration,
+        score: iter.score,
+        ...avgStddev !== void 0 ? { stddev: avgStddev } : {},
+        mutationCount: iter.proposal?.mutations.length ?? 0,
+        status: iterationStatus(iter, bestIter.iteration)
+      };
+    }),
     leaderboard,
     counterfactuals
   };
 }
 
 // src/evolve/apply.ts
-import fs23 from "fs/promises";
-import path23 from "path";
+import fs24 from "fs/promises";
+import path24 from "path";
 async function listIterations(workspacePath) {
-  const iterationsDir = path23.join(workspacePath, "iterations");
+  const iterationsDir = path24.join(workspacePath, "iterations");
   let entries;
   try {
-    entries = await fs23.readdir(iterationsDir);
+    entries = await fs24.readdir(iterationsDir);
   } catch {
     return [];
   }
@@ -5598,7 +5928,7 @@ async function listIterations(workspacePath) {
     const n = parseInt(entry, 10);
     if (!isNaN(n)) {
       try {
-        await fs23.access(path23.join(iterationsDir, entry, "harness"));
+        await fs24.access(path24.join(iterationsDir, entry, "harness"));
         nums.push(n);
       } catch {
       }
@@ -5624,16 +5954,16 @@ async function listFilesRecursive(dir) {
   async function walk(current) {
     let entries;
     try {
-      entries = await fs23.readdir(current, { withFileTypes: true });
+      entries = await fs24.readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path23.join(current, entry.name);
+      const fullPath = path24.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
-        results.push(path23.relative(dir, fullPath));
+        results.push(path24.relative(dir, fullPath));
       }
     }
   }
@@ -5656,37 +5986,37 @@ async function applyEvolution(workspacePath, projectRoot, targetIteration) {
   } else {
     iter = await findBestIteration(workspacePath, iterations);
   }
-  const harnessPath = path23.join(
+  const harnessPath = path24.join(
     workspacePath,
     "iterations",
     iter.toString(),
     "harness"
   );
-  const claudeDir = path23.join(projectRoot, ".claude");
+  const claudeDir = path24.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 fs23.readFile(path23.join(claudeDir, filePath), "utf-8").catch(() => null);
-    const targetContent = await fs23.readFile(path23.join(harnessPath, filePath), "utf-8").catch(() => null);
+    const currentContent = await fs24.readFile(path24.join(claudeDir, filePath), "utf-8").catch(() => null);
+    const targetContent = await fs24.readFile(path24.join(harnessPath, filePath), "utf-8").catch(() => null);
     if (currentContent !== targetContent) {
       filesChanged.push(filePath);
     }
   }
-  await fs23.rm(claudeDir, { recursive: true, force: true });
+  await fs24.rm(claudeDir, { recursive: true, force: true });
   await copyDir(harnessPath, claudeDir);
-  const harnessMcpJson = path23.join(harnessPath, ".mcp.json");
-  const projectMcpJson = path23.join(projectRoot, ".mcp.json");
+  const harnessMcpJson = path24.join(harnessPath, ".mcp.json");
+  const projectMcpJson = path24.join(projectRoot, ".mcp.json");
   try {
-    await fs23.access(harnessMcpJson);
-    const currentMcp = await fs23.readFile(projectMcpJson, "utf-8").catch(() => null);
-    const targetMcp = await fs23.readFile(harnessMcpJson, "utf-8").catch(() => null);
+    await fs24.access(harnessMcpJson);
+    const currentMcp = await fs24.readFile(projectMcpJson, "utf-8").catch(() => null);
+    const targetMcp = await fs24.readFile(harnessMcpJson, "utf-8").catch(() => null);
     if (currentMcp !== targetMcp) {
       filesChanged.push(".mcp.json");
     }
-    await fs23.copyFile(harnessMcpJson, projectMcpJson);
+    await fs24.copyFile(harnessMcpJson, projectMcpJson);
   } catch {
   }
   return {
@@ -5706,11 +6036,13 @@ var DEFAULT_CONFIG = {
   runsPerTask: 1,
   maxMutationsPerIteration: 3,
   pruneThreshold: 95,
-  maxTaskDrop: 20
+  maxTaskDrop: 20,
+  usePrincipal: false,
+  evalSampleSize: 0
 };
 async function loadEvolveConfigFromWorkspace(workspacePath) {
   try {
-    const configStr = await fs24.readFile(path24.join(workspacePath, "config.yaml"), "utf-8");
+    const configStr = await fs25.readFile(path25.join(workspacePath, "config.yaml"), "utf-8");
     const parsed = yamlParse2(configStr);
     return {
       model: parsed.model ?? DEFAULT_CONFIG.model,
@@ -5721,7 +6053,9 @@ async function loadEvolveConfigFromWorkspace(workspacePath) {
       runsPerTask: parsed.runs_per_task ?? DEFAULT_CONFIG.runsPerTask,
       maxMutationsPerIteration: parsed.max_mutations_per_iteration ?? DEFAULT_CONFIG.maxMutationsPerIteration,
       pruneThreshold: parsed.prune_threshold ?? DEFAULT_CONFIG.pruneThreshold,
-      maxTaskDrop: parsed.max_task_drop ?? DEFAULT_CONFIG.maxTaskDrop
+      maxTaskDrop: parsed.max_task_drop ?? DEFAULT_CONFIG.maxTaskDrop,
+      usePrincipal: parsed.use_principal ?? DEFAULT_CONFIG.usePrincipal,
+      evalSampleSize: parsed.eval_sample_size ?? DEFAULT_CONFIG.evalSampleSize
     };
   } catch {
     return { ...DEFAULT_CONFIG };
@@ -5732,9 +6066,9 @@ evolveCommand.command("init").description("Initialize an evolution workspace wit
   try {
     const projectRoot = process.cwd();
     console.log(ui.section("Evolve Init"));
-    const claudeDir = path24.join(projectRoot, ".claude");
+    const claudeDir = path25.join(projectRoot, ".claude");
     try {
-      await fs24.access(claudeDir);
+      await fs25.access(claudeDir);
     } catch {
       console.log(ui.error("No .claude/ directory found. Run kairn describe first."));
       process.exit(1);
@@ -5766,7 +6100,7 @@ evolveCommand.command("init").description("Initialize an evolution workspace wit
     let addMore = true;
     while (addMore) {
       try {
-        addMore = await confirm3({ message: "Add another eval task?", default: false });
+        addMore = await confirm4({ message: "Add another eval task?", default: false });
       } catch {
         addMore = false;
       }
@@ -5784,7 +6118,7 @@ evolveCommand.command("init").description("Initialize an evolution workspace wit
           if (config) {
             let claudeMd = "";
             try {
-              claudeMd = await fs24.readFile(path24.join(claudeDir, "CLAUDE.md"), "utf-8");
+              claudeMd = await fs25.readFile(path25.join(claudeDir, "CLAUDE.md"), "utf-8");
             } catch {
             }
             const profile = await buildProjectProfile(projectRoot);
@@ -5815,16 +6149,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 = path24.join(projectRoot, ".kairn-evolve");
+    const workspace = path25.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve Baseline"));
     try {
-      await fs24.access(workspace);
+      await fs25.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 = path24.join(workspace, "baseline");
+    const baselineDir = path25.join(workspace, "baseline");
     const fileCount = await countFiles(baselineDir);
     console.log(ui.success(`Baseline snapshot created (${fileCount} files)`));
   } catch (err) {
@@ -5833,21 +6167,21 @@ evolveCommand.command("baseline").description("Snapshot current .claude/ directo
     process.exit(1);
   }
 });
-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").action(async (options) => {
+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").action(async (options) => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path24.join(projectRoot, ".kairn-evolve");
+    const workspace = path25.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve Run"));
     try {
-      await fs24.access(workspace);
+      await fs25.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
     }
-    const tasksPath = path24.join(workspace, "tasks.yaml");
+    const tasksPath = path25.join(workspace, "tasks.yaml");
     let tasksContent;
     try {
-      tasksContent = await fs24.readFile(tasksPath, "utf-8");
+      tasksContent = await fs25.readFile(tasksPath, "utf-8");
     } catch {
       console.log(ui.error("No tasks.yaml found. Run kairn evolve init first."));
       process.exit(1);
@@ -5866,15 +6200,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 = path24.join(projectRoot, ".claude");
+      const harnessPath = path25.join(projectRoot, ".claude");
       const results = [];
       for (const task of tasksToRun) {
-        const traceDir = path24.join(workspace, "traces", "0", task.id);
+        const traceDir = path25.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 fs24.readFile(path24.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
-          const stderr = await fs24.readFile(path24.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
+          const stdout = await fs25.readFile(path25.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
+          const stderr = await fs25.readFile(path25.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
           const score = await scoreTask(task, traceDir, stdout, stderr, config);
           result.score = score;
           await writeScore(traceDir, score);
@@ -5932,8 +6266,17 @@ evolveCommand.command("run").description("Run tasks against the current harness"
         process.exit(1);
       }
       evolveConfig.maxTaskDrop = maxTaskDrop;
+      if (options.principal) {
+        evolveConfig.usePrincipal = true;
+      }
+      const evalSample = parseInt(options.evalSample ?? "0", 10);
+      if (isNaN(evalSample) || evalSample < 0) {
+        console.log(ui.error("--eval-sample must be a non-negative integer"));
+        process.exit(1);
+      }
+      evolveConfig.evalSampleSize = evalSample;
       try {
-        await fs24.access(path24.join(workspace, "iterations", "0", "harness"));
+        await fs25.access(path25.join(workspace, "iterations", "0", "harness"));
       } catch {
         console.log(ui.error("No baseline harness found. Run kairn evolve baseline first."));
         process.exit(1);
@@ -6027,10 +6370,10 @@ evolveCommand.command("run").description("Run tasks against the current harness"
 evolveCommand.command("apply").description("Apply the best evolved harness to your project").option("--iter <n>", "Apply a specific iteration instead of the best").option("--force", "Apply even if git working tree is dirty").option("--no-commit", "Skip automatic git commit after applying").action(async (options) => {
   try {
     const projectRoot = process.cwd();
-    const workspace = path24.join(projectRoot, ".kairn-evolve");
+    const workspace = path25.join(projectRoot, ".kairn-evolve");
     console.log(ui.section("Evolve Apply"));
     try {
-      await fs24.access(workspace);
+      await fs25.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
@@ -6071,9 +6414,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 = path24.join(projectRoot, ".kairn-evolve");
+    const workspace = path25.join(projectRoot, ".kairn-evolve");
     try {
-      await fs24.access(workspace);
+      await fs25.access(workspace);
     } catch {
       console.log(ui.error("No .kairn-evolve/ directory found. Run kairn evolve init first."));
       process.exit(1);
@@ -6094,23 +6437,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 = path24.join(projectRoot, ".kairn-evolve");
+    const workspace = path25.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 = path24.join(workspace, "iterations", iter1.toString(), "harness");
-    const harness2 = path24.join(workspace, "iterations", iter2.toString(), "harness");
+    const harness1 = path25.join(workspace, "iterations", iter1.toString(), "harness");
+    const harness2 = path25.join(workspace, "iterations", iter2.toString(), "harness");
     try {
-      await fs24.access(harness1);
+      await fs25.access(harness1);
     } catch {
       console.log(ui.error(`Iteration ${iter1} harness not found at ${harness1}`));
       process.exit(1);
     }
     try {
-      await fs24.access(harness2);
+      await fs25.access(harness2);
     } catch {
       console.log(ui.error(`Iteration ${iter2} harness not found at ${harness2}`));
       process.exit(1);
@@ -6165,10 +6508,10 @@ evolveCommand.command("diff <iter1> <iter2>").description("Show harness changes
 async function countFiles(dir) {
   let count = 0;
   try {
-    const entries = await fs24.readdir(dir, { withFileTypes: true });
+    const entries = await fs25.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        count += await countFiles(path24.join(dir, entry.name));
+        count += await countFiles(path25.join(dir, entry.name));
       } else {
         count++;
       }
@@ -6179,10 +6522,12 @@ async function countFiles(dir) {
 }
 
 // src/cli.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
 var program = new Command12();
 program.name("kairn").description(
   "Compile natural language intent into optimized Claude Code environments"
-).version("1.9.0").option("--no-color", "Disable colored output");
+).version(pkg.version).option("--no-color", "Disable colored output");
 program.addCommand(initCommand);
 program.addCommand(describeCommand);
 program.addCommand(optimizeCommand);