kairn-cli 2.9.0 → 2.11.1

package/dist/cli.js

@@ -181,6 +181,101 @@ var init_providers = __esm({
   }
 });
 
+// src/compiler/agents/types.ts
+function validatePlan(plan) {
+  if (plan == null || typeof plan !== "object") {
+    throw new Error("CompilationPlan must be a non-null object");
+  }
+  const obj = plan;
+  if (typeof obj["project_context"] !== "string") {
+    throw new Error(
+      "CompilationPlan.project_context must be a string"
+    );
+  }
+  if (obj["project_context"].length === 0) {
+    throw new Error(
+      "CompilationPlan.project_context must not be empty"
+    );
+  }
+  if (!Array.isArray(obj["phases"])) {
+    throw new Error("CompilationPlan.phases must be an array");
+  }
+  if (obj["phases"].length === 0) {
+    throw new Error(
+      "CompilationPlan.phases must contain at least one phase"
+    );
+  }
+  for (let pi = 0; pi < obj["phases"].length; pi++) {
+    validatePhase(obj["phases"][pi], pi);
+  }
+  return plan;
+}
+function validatePhase(phase, index) {
+  if (phase == null || typeof phase !== "object") {
+    throw new Error(`phases[${index}] must be a non-null object`);
+  }
+  const obj = phase;
+  if (typeof obj["id"] !== "string") {
+    throw new Error(`phases[${index}].id must be a string`);
+  }
+  if (!Array.isArray(obj["agents"])) {
+    throw new Error(`phases[${index}].agents must be an array`);
+  }
+  for (let ai = 0; ai < obj["agents"].length; ai++) {
+    validateAgentTask(obj["agents"][ai], index, ai);
+  }
+  if (!Array.isArray(obj["dependsOn"])) {
+    throw new Error(`phases[${index}].dependsOn must be an array`);
+  }
+}
+function validateAgentTask(task, phaseIndex, taskIndex) {
+  if (task == null || typeof task !== "object") {
+    throw new Error(
+      `phases[${phaseIndex}].agents[${taskIndex}] must be a non-null object`
+    );
+  }
+  const obj = task;
+  const prefix = `phases[${phaseIndex}].agents[${taskIndex}]`;
+  if (typeof obj["agent"] !== "string") {
+    throw new Error(`${prefix}.agent must be a string`);
+  }
+  if (!VALID_AGENT_NAMES.includes(obj["agent"])) {
+    throw new Error(
+      `${prefix}.agent "${obj["agent"]}" is not a valid agent name. Valid names: ${VALID_AGENT_NAMES.join(", ")}`
+    );
+  }
+  if (!Array.isArray(obj["items"])) {
+    throw new Error(`${prefix}.items must be an array`);
+  }
+  if (typeof obj["max_tokens"] !== "number") {
+    throw new Error(`${prefix}.max_tokens must be a number`);
+  }
+}
+var VALID_AGENT_NAMES, TruncationError;
+var init_types = __esm({
+  "src/compiler/agents/types.ts"() {
+    "use strict";
+    VALID_AGENT_NAMES = [
+      "sections-writer",
+      "command-writer",
+      "agent-writer",
+      "rule-writer",
+      "doc-writer",
+      "skill-writer"
+    ];
+    TruncationError = class extends Error {
+      agentName;
+      tokensUsed;
+      constructor(message, options) {
+        super(message);
+        this.name = "TruncationError";
+        this.agentName = options.agentName;
+        this.tokensUsed = options.tokensUsed;
+      }
+    };
+  }
+});
+
 // src/llm.ts
 import Anthropic2 from "@anthropic-ai/sdk";
 import OpenAI2 from "openai";
@@ -242,12 +337,22 @@ async function callLLM(config, userMessage, options) {
         system: cacheControl ? [{ type: "text", text: systemPrompt, cache_control: { type: "ephemeral" } }] : systemPrompt,
         messages
       });
+      if (response.stop_reason === "max_tokens") {
+        const agentLabel = options.agentName ?? "unknown";
+        throw new TruncationError(
+          `Response truncated at ${maxTokens} tokens. Agent: ${agentLabel}`,
+          { agentName: agentLabel, tokensUsed: maxTokens }
+        );
+      }
       const textBlock = response.content.find((block) => block.type === "text");
       if (!textBlock || textBlock.type !== "text") {
         throw new Error("No text response from compiler LLM");
       }
       return textBlock.text;
     } catch (err) {
+      if (err instanceof TruncationError) {
+        throw err;
+      }
       throw new Error(classifyError(err, providerName));
     }
   }
@@ -265,12 +370,22 @@ async function callLLM(config, userMessage, options) {
       ],
       ...jsonMode ? { response_format: { type: "json_object" } } : {}
     });
+    if (response.choices[0]?.finish_reason === "length") {
+      const agentLabel = options.agentName ?? "unknown";
+      throw new TruncationError(
+        `Response truncated at ${maxTokens} tokens. Agent: ${agentLabel}`,
+        { agentName: agentLabel, tokensUsed: maxTokens }
+      );
+    }
     const text = response.choices[0]?.message?.content;
     if (!text) {
       throw new Error("No text response from compiler LLM");
     }
     return text;
   } catch (err) {
+    if (err instanceof TruncationError) {
+      throw err;
+    }
     throw new Error(classifyError(err, providerName));
   }
 }
@@ -279,142 +394,409 @@ var init_llm = __esm({
     "use strict";
     init_providers();
     init_keychain();
+    init_types();
   }
 });
 
-// src/evolve/baseline.ts
-import fs16 from "fs/promises";
-import path16 from "path";
-async function snapshotBaseline(projectRoot, workspacePath) {
-  const claudeDir = path16.join(projectRoot, ".claude");
-  const baselineDir = path16.join(workspacePath, "baseline");
-  const iter0Dir = path16.join(workspacePath, "iterations", "0", "harness");
-  try {
-    await fs16.access(claudeDir);
-  } catch {
-    throw new Error(`.claude/ directory not found in ${projectRoot}`);
+// src/ir/types.ts
+function createEmptyIR() {
+  return {
+    meta: {
+      name: "",
+      purpose: "",
+      techStack: { language: "" },
+      autonomyLevel: 2
+    },
+    sections: [],
+    commands: [],
+    rules: [],
+    agents: [],
+    skills: [],
+    docs: [],
+    hooks: [],
+    settings: createEmptySettings(),
+    mcpServers: [],
+    intents: []
+  };
+}
+function createEmptySettings() {
+  return { hooks: {}, raw: {} };
+}
+function createSection(id, heading, content, order) {
+  return { id, heading, content, order };
+}
+function createCommandNode(name, content, description) {
+  return { name, description: description ?? "", content };
+}
+function createRuleNode(name, content, paths) {
+  const node = { name, content };
+  if (paths !== void 0) {
+    node.paths = paths;
   }
-  await copyDir(claudeDir, baselineDir);
-  await copyDir(claudeDir, iter0Dir);
-  const mcpJsonPath = path16.join(projectRoot, ".mcp.json");
-  try {
-    await fs16.access(mcpJsonPath);
-    await fs16.copyFile(mcpJsonPath, path16.join(baselineDir, ".mcp.json"));
-    await fs16.copyFile(mcpJsonPath, path16.join(iter0Dir, ".mcp.json"));
-  } catch {
+  return node;
+}
+function createAgentNode(name, content, model) {
+  const node = { name, content };
+  if (model !== void 0) {
+    node.model = model;
   }
+  return node;
 }
-async function copyDir(src, dest) {
-  await fs16.mkdir(dest, { recursive: true });
-  const entries = await fs16.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path16.join(src, entry.name);
-    const destPath = path16.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      await copyDir(srcPath, destPath);
-    } else {
-      await fs16.copyFile(srcPath, destPath);
+function createEmptyDiff() {
+  return {
+    sections: {
+      added: [],
+      removed: [],
+      modified: [],
+      reordered: []
+    },
+    commands: {
+      added: [],
+      removed: [],
+      modified: []
+    },
+    rules: {
+      added: [],
+      removed: [],
+      modified: []
+    },
+    agents: {
+      added: [],
+      removed: [],
+      modified: []
+    },
+    mcpServers: {
+      added: [],
+      removed: []
+    },
+    settings: {
+      changes: []
     }
-  }
+  };
 }
-var init_baseline = __esm({
-  "src/evolve/baseline.ts"() {
+var init_types2 = __esm({
+  "src/ir/types.ts"() {
     "use strict";
   }
 });
 
-// src/evolve/trace.ts
-import fs17 from "fs/promises";
-import path17 from "path";
-async function loadTrace(traceDir) {
-  const stdout = await fs17.readFile(path17.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
-  const stderr = await fs17.readFile(path17.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
-  const filesChangedStr = await fs17.readFile(
-    path17.join(traceDir, "files_changed.json"),
-    "utf-8"
-  ).catch(() => "{}");
-  const timingStr = await fs17.readFile(
-    path17.join(traceDir, "timing.json"),
-    "utf-8"
-  ).catch(() => "{}");
-  const scoreStr = await fs17.readFile(
-    path17.join(traceDir, "score.json"),
-    "utf-8"
-  ).catch(() => '{"pass": false}');
-  const toolCallsStr = await fs17.readFile(
-    path17.join(traceDir, "tool_calls.jsonl"),
-    "utf-8"
-  ).catch(() => "");
-  const toolCalls = toolCallsStr.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
-  const parentDir = path17.basename(path17.dirname(traceDir));
-  const iteration = parseInt(parentDir, 10) || 0;
-  return {
-    taskId: path17.basename(traceDir),
-    iteration,
-    stdout,
-    stderr,
-    toolCalls,
-    filesChanged: JSON.parse(filesChangedStr),
-    score: JSON.parse(scoreStr),
-    timing: JSON.parse(timingStr)
-  };
-}
-async function loadIterationTraces(workspacePath, iteration) {
-  const tracesDir = path17.join(workspacePath, "traces", iteration.toString());
-  const traces = [];
-  try {
-    const taskDirs = await fs17.readdir(tracesDir);
-    for (const taskId of taskDirs) {
-      const trace = await loadTrace(path17.join(tracesDir, taskId));
-      traces.push(trace);
+// src/ir/renderer.ts
+function renderClaudeMd(_meta, sections) {
+  const sorted = [...sections].sort((a, b) => a.order - b.order);
+  const blocks = [];
+  for (const section of sorted) {
+    if (section.heading && section.content) {
+      blocks.push(`${section.heading}
+
+${section.content}`);
+    } else if (section.heading) {
+      blocks.push(section.heading);
+    } else if (section.content) {
+      blocks.push(section.content);
     }
-  } catch {
   }
-  return traces;
-}
-async function writeTrace(traceDir, trace) {
-  await fs17.mkdir(traceDir, { recursive: true });
-  await fs17.writeFile(path17.join(traceDir, "stdout.log"), trace.stdout, "utf-8");
-  await fs17.writeFile(path17.join(traceDir, "stderr.log"), trace.stderr, "utf-8");
-  const toolCallsLines = trace.toolCalls.map((tc) => JSON.stringify(tc)).join("\n");
-  await fs17.writeFile(path17.join(traceDir, "tool_calls.jsonl"), toolCallsLines, "utf-8");
-  await fs17.writeFile(
-    path17.join(traceDir, "files_changed.json"),
-    JSON.stringify(trace.filesChanged, null, 2),
-    "utf-8"
-  );
-  await fs17.writeFile(
-    path17.join(traceDir, "timing.json"),
-    JSON.stringify(trace.timing, null, 2),
-    "utf-8"
-  );
-  await fs17.writeFile(
-    path17.join(traceDir, "score.json"),
-    JSON.stringify(trace.score, null, 2),
-    "utf-8"
-  );
-}
-async function writeScore(traceDir, score) {
-  await fs17.writeFile(
-    path17.join(traceDir, "score.json"),
-    JSON.stringify(score, null, 2),
-    "utf-8"
-  );
+  if (blocks.length === 0) {
+    return "\n";
+  }
+  return blocks.join("\n\n") + "\n";
 }
-async function writeIterationLog(workspacePath, log) {
-  const iterDir = path17.join(workspacePath, "iterations", log.iteration.toString());
-  await fs17.mkdir(iterDir, { recursive: true });
-  await fs17.writeFile(
-    path17.join(iterDir, "scores.json"),
-    JSON.stringify({ score: log.score, taskResults: log.taskResults }, null, 2),
-    "utf-8"
-  );
-  await fs17.writeFile(
-    path17.join(iterDir, "proposer_reasoning.md"),
-    log.proposal?.reasoning ?? "Baseline evaluation (no proposal)",
-    "utf-8"
+function renderSettings(settings) {
+  const result = JSON.parse(
+    JSON.stringify(settings.raw)
   );
-  await fs17.writeFile(
+  if (settings.denyPatterns && settings.denyPatterns.length > 0) {
+    const permissions = result["permissions"] ?? {};
+    permissions["deny"] = settings.denyPatterns;
+    result["permissions"] = permissions;
+  }
+  if (settings.statusLine) {
+    result["statusLine"] = settings.statusLine;
+  }
+  const hookEvents = [
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "SessionStart",
+    "PostCompact"
+  ];
+  const hooksObj = {};
+  let hasHooks = false;
+  for (const event of hookEvents) {
+    const entries = settings.hooks[event];
+    if (entries && entries.length > 0) {
+      hooksObj[event] = entries;
+      hasHooks = true;
+    }
+  }
+  if (hasHooks) {
+    result["hooks"] = hooksObj;
+  }
+  return JSON.stringify(result, null, 2) + "\n";
+}
+function renderMcpConfig(servers) {
+  if (servers.length === 0) {
+    return "";
+  }
+  const mcpServers = {};
+  for (const server of servers) {
+    const entry = {
+      command: server.command,
+      args: server.args
+    };
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry["env"] = server.env;
+    }
+    mcpServers[server.id] = entry;
+  }
+  return JSON.stringify({ mcpServers }, null, 2) + "\n";
+}
+function renderRuleWithFrontmatter(rule) {
+  if (!rule.paths || rule.paths.length === 0) {
+    return rule.content;
+  }
+  const yamlLines = ["---", "paths:"];
+  for (const p of rule.paths) {
+    yamlLines.push(`  - ${p}`);
+  }
+  yamlLines.push("---");
+  return yamlLines.join("\n") + "\n\n" + rule.content;
+}
+function renderAgentWithFrontmatter(agent) {
+  const hasModel = agent.model !== void 0;
+  const hasDisallowed = agent.disallowedTools !== void 0 && agent.disallowedTools.length > 0;
+  const hasRouting = agent.modelRouting !== void 0;
+  const hasExtra = agent.extraFrontmatter !== void 0 && Object.keys(agent.extraFrontmatter).length > 0;
+  if (!hasModel && !hasDisallowed && !hasRouting && !hasExtra) {
+    return agent.content;
+  }
+  const yamlLines = ["---"];
+  if (hasModel) {
+    yamlLines.push(`model: ${agent.model}`);
+  }
+  if (hasDisallowed) {
+    yamlLines.push("disallowedTools:");
+    for (const tool of agent.disallowedTools) {
+      yamlLines.push(`  - ${tool}`);
+    }
+  }
+  if (hasRouting) {
+    yamlLines.push("modelRouting:");
+    yamlLines.push(`  default: ${agent.modelRouting.default}`);
+    if (agent.modelRouting.escalateTo) {
+      yamlLines.push(`  escalateTo: ${agent.modelRouting.escalateTo}`);
+    }
+    if (agent.modelRouting.escalateWhen) {
+      yamlLines.push(`  escalateWhen: ${agent.modelRouting.escalateWhen}`);
+    }
+  }
+  if (hasExtra) {
+    for (const [key, value] of Object.entries(agent.extraFrontmatter)) {
+      if (Array.isArray(value)) {
+        yamlLines.push(`${key}:`);
+        for (const item of value) {
+          yamlLines.push(`  - ${String(item)}`);
+        }
+      } else if (typeof value === "object" && value !== null) {
+        yamlLines.push(`${key}:`);
+        for (const [subKey, subVal] of Object.entries(value)) {
+          yamlLines.push(`  ${subKey}: ${String(subVal)}`);
+        }
+      } else {
+        yamlLines.push(`${key}: ${String(value)}`);
+      }
+    }
+  }
+  yamlLines.push("---");
+  return yamlLines.join("\n") + "\n\n" + agent.content;
+}
+function settingsHasContent(settings) {
+  if (settings.statusLine) return true;
+  if (settings.denyPatterns && settings.denyPatterns.length > 0) return true;
+  if (Object.keys(settings.raw).length > 0) return true;
+  const hookEvents = [
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "SessionStart",
+    "PostCompact"
+  ];
+  for (const event of hookEvents) {
+    const entries = settings.hooks[event];
+    if (entries && entries.length > 0) return true;
+  }
+  return false;
+}
+function renderHarness(ir) {
+  const files = /* @__PURE__ */ new Map();
+  if (ir.sections.length > 0 || ir.meta.name) {
+    files.set("CLAUDE.md", renderClaudeMd(ir.meta, ir.sections));
+  }
+  if (settingsHasContent(ir.settings)) {
+    files.set("settings.json", renderSettings(ir.settings));
+  }
+  for (const cmd of ir.commands) {
+    files.set(`commands/${cmd.name}.md`, cmd.content);
+  }
+  for (const rule of ir.rules) {
+    files.set(`rules/${rule.name}.md`, renderRuleWithFrontmatter(rule));
+  }
+  for (const agent of ir.agents) {
+    files.set(`agents/${agent.name}.md`, renderAgentWithFrontmatter(agent));
+  }
+  for (const skill of ir.skills) {
+    files.set(`skills/${skill.name}.md`, skill.content);
+  }
+  for (const doc of ir.docs) {
+    files.set(`docs/${doc.name}.md`, doc.content);
+  }
+  for (const hook of ir.hooks) {
+    files.set(`hooks/${hook.name}.mjs`, hook.content);
+  }
+  const mcpContent = renderMcpConfig(ir.mcpServers);
+  if (mcpContent) {
+    files.set(".mcp.json", mcpContent);
+  }
+  return files;
+}
+var init_renderer = __esm({
+  "src/ir/renderer.ts"() {
+    "use strict";
+  }
+});
+
+// src/evolve/baseline.ts
+import fs16 from "fs/promises";
+import path16 from "path";
+async function snapshotBaseline(projectRoot, workspacePath) {
+  const claudeDir = path16.join(projectRoot, ".claude");
+  const baselineDir = path16.join(workspacePath, "baseline");
+  const iter0Dir = path16.join(workspacePath, "iterations", "0", "harness");
+  try {
+    await fs16.access(claudeDir);
+  } catch {
+    throw new Error(`.claude/ directory not found in ${projectRoot}`);
+  }
+  await copyDir(claudeDir, baselineDir);
+  await copyDir(claudeDir, iter0Dir);
+  const mcpJsonPath = path16.join(projectRoot, ".mcp.json");
+  try {
+    await fs16.access(mcpJsonPath);
+    await fs16.copyFile(mcpJsonPath, path16.join(baselineDir, ".mcp.json"));
+    await fs16.copyFile(mcpJsonPath, path16.join(iter0Dir, ".mcp.json"));
+  } catch {
+  }
+}
+async function copyDir(src, dest) {
+  await fs16.mkdir(dest, { recursive: true });
+  const entries = await fs16.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path16.join(src, entry.name);
+    const destPath = path16.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs16.copyFile(srcPath, destPath);
+    }
+  }
+}
+var init_baseline = __esm({
+  "src/evolve/baseline.ts"() {
+    "use strict";
+  }
+});
+
+// src/evolve/trace.ts
+import fs17 from "fs/promises";
+import path17 from "path";
+async function loadTrace(traceDir) {
+  const stdout = await fs17.readFile(path17.join(traceDir, "stdout.log"), "utf-8").catch(() => "");
+  const stderr = await fs17.readFile(path17.join(traceDir, "stderr.log"), "utf-8").catch(() => "");
+  const filesChangedStr = await fs17.readFile(
+    path17.join(traceDir, "files_changed.json"),
+    "utf-8"
+  ).catch(() => "{}");
+  const timingStr = await fs17.readFile(
+    path17.join(traceDir, "timing.json"),
+    "utf-8"
+  ).catch(() => "{}");
+  const scoreStr = await fs17.readFile(
+    path17.join(traceDir, "score.json"),
+    "utf-8"
+  ).catch(() => '{"pass": false}');
+  const toolCallsStr = await fs17.readFile(
+    path17.join(traceDir, "tool_calls.jsonl"),
+    "utf-8"
+  ).catch(() => "");
+  const toolCalls = toolCallsStr.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+  const parentDir = path17.basename(path17.dirname(traceDir));
+  const iteration = parseInt(parentDir, 10) || 0;
+  return {
+    taskId: path17.basename(traceDir),
+    iteration,
+    stdout,
+    stderr,
+    toolCalls,
+    filesChanged: JSON.parse(filesChangedStr),
+    score: JSON.parse(scoreStr),
+    timing: JSON.parse(timingStr)
+  };
+}
+async function loadIterationTraces(workspacePath, iteration) {
+  const tracesDir = path17.join(workspacePath, "traces", iteration.toString());
+  const traces = [];
+  try {
+    const taskDirs = await fs17.readdir(tracesDir);
+    for (const taskId of taskDirs) {
+      const trace = await loadTrace(path17.join(tracesDir, taskId));
+      traces.push(trace);
+    }
+  } catch {
+  }
+  return traces;
+}
+async function writeTrace(traceDir, trace) {
+  await fs17.mkdir(traceDir, { recursive: true });
+  await fs17.writeFile(path17.join(traceDir, "stdout.log"), trace.stdout, "utf-8");
+  await fs17.writeFile(path17.join(traceDir, "stderr.log"), trace.stderr, "utf-8");
+  const toolCallsLines = trace.toolCalls.map((tc) => JSON.stringify(tc)).join("\n");
+  await fs17.writeFile(path17.join(traceDir, "tool_calls.jsonl"), toolCallsLines, "utf-8");
+  await fs17.writeFile(
+    path17.join(traceDir, "files_changed.json"),
+    JSON.stringify(trace.filesChanged, null, 2),
+    "utf-8"
+  );
+  await fs17.writeFile(
+    path17.join(traceDir, "timing.json"),
+    JSON.stringify(trace.timing, null, 2),
+    "utf-8"
+  );
+  await fs17.writeFile(
+    path17.join(traceDir, "score.json"),
+    JSON.stringify(trace.score, null, 2),
+    "utf-8"
+  );
+}
+async function writeScore(traceDir, score) {
+  await fs17.writeFile(
+    path17.join(traceDir, "score.json"),
+    JSON.stringify(score, null, 2),
+    "utf-8"
+  );
+}
+async function writeIterationLog(workspacePath, log) {
+  const iterDir = path17.join(workspacePath, "iterations", log.iteration.toString());
+  await fs17.mkdir(iterDir, { recursive: true });
+  await fs17.writeFile(
+    path17.join(iterDir, "scores.json"),
+    JSON.stringify({ score: log.score, taskResults: log.taskResults }, null, 2),
+    "utf-8"
+  );
+  await fs17.writeFile(
+    path17.join(iterDir, "proposer_reasoning.md"),
+    log.proposal?.reasoning ?? "Baseline evaluation (no proposal)",
+    "utf-8"
+  );
+  await fs17.writeFile(
     path17.join(iterDir, "mutation_diff.patch"),
     log.diffPatch ?? "",
     "utf-8"
@@ -1011,7 +1393,7 @@ function parseToolCalls(stdout) {
     return [];
   }
 }
-async function runWithConcurrency(tasks, limit) {
+async function runWithConcurrency2(tasks, limit) {
   const results = new Array(tasks.length);
   const executing = /* @__PURE__ */ new Set();
   const errors = [];
@@ -1113,7 +1495,7 @@ async function evaluateAll(tasks, harnessPath, workspacePath, iteration, config,
     });
     return { id: task.id, score: finalScore };
   };
-  const taskResults = await runWithConcurrency(
+  const taskResults = await runWithConcurrency2(
     tasks.map((task) => () => evaluateTask(task)),
     concurrency
   );
@@ -1480,147 +1862,65 @@ agent environment (.claude/ directory) based on execution traces from real tasks
 2. Execution traces: Full stdout/stderr, tool call sequences, file changes, and scores
 3. History: Previous iterations' proposals, diffs, and resulting score changes
 
-## Your Task
-Analyze the traces to identify WHY tasks fail or underperform. Then propose specific,
-minimal changes to the harness files that will fix those failures.
-
-## Diagnosis Process
-1. For each failed/low-scoring task:
-   a. Read the full trace (stdout, tool calls, file changes)
-   b. Identify the ROOT CAUSE: bad instruction? Missing tool? Wrong rule?
-   c. Trace the failure back to a specific harness decision
-   d. Propose a fix
-
-2. For each successful task:
-   a. Note what worked well
-   b. Ensure proposed changes don't break what's working
-
-3. Check history for counterfactual evidence
-
-## Available Mutation Actions
-1. **replace** \u2014 Replace old_text with new_text in a file: { "file": "...", "action": "replace", "old_text": "...", "new_text": "...", "rationale": "..." }
-2. **add_section** \u2014 Append new content to a file (or create it): { "file": "...", "action": "add_section", "new_text": "...", "rationale": "..." }
-3. **create_file** \u2014 Create a new file: { "file": "...", "action": "create_file", "new_text": "...", "rationale": "..." }
-4. **delete_section** \u2014 Remove specific text from a file: { "file": "...", "action": "delete_section", "old_text": "...", "rationale": "..." }
-5. **delete_file** \u2014 Delete an entire file: { "file": "...", "action": "delete_file", "rationale": "..." }
-
-## Output Format
-Return a JSON object:
-{
-  "reasoning": "Your full causal analysis...",
-  "mutations": [
-    { "file": "CLAUDE.md", "action": "replace", "old_text": "...", "new_text": "...", "rationale": "..." },
-    { "file": "commands/develop.md", "action": "add_section", "new_text": "...", "rationale": "..." },
-    { "file": "rules/obsolete.md", "action": "delete_file", "rationale": "..." }
-  ],
-  "expected_impact": { "task-id": "+15% \u2014 explanation" }
-}
-
-## MCP Configuration
-You can also mutate .mcp.json to add, remove, or reconfigure MCP servers.
-Treat .mcp.json like any other harness file \u2014 propose changes when traces show
-the agent lacks a tool it needs, or has tools that add noise without benefit.
-
-## Rules
-- Propose AT MOST 3 mutations per iteration. Fewer, targeted mutations are more stable than many broad ones.
-- Each mutation must have a clear rationale tied to a specific trace observation.
-- Never remove something that's working for another task.
-- If a previous iteration's change caused a regression, REVERT it.
-- Consider both additions AND removals. Remove sections that add noise without improving task performance.
-- Bloated harnesses hurt performance \u2014 trim what isn't earning its keep.
-
-## Anti-Gaming (CRITICAL)
-- Mutations must improve GENERAL-PURPOSE development quality, not target specific eval criteria.
-- You do NOT have access to scoring rubrics or expected outcomes. Diagnose problems from traces only.
-- Do NOT add over-specified rules that restate existing conventions with stronger emphasis (e.g., changing "use chalk.green for success" to "MUST use chalk.green, no exceptions"). If a convention already exists, trust it.
-- Do NOT add rules that only apply to a narrow eval scenario (e.g., write permissions for a specific directory just because one task needed it).
-- Ask: "Would this mutation help a developer working on ANY task in this project?" If not, don't propose it.
-
-Return ONLY valid JSON.`;
-    STDOUT_TRUNCATION_LIMIT = 1e3;
-    MAX_CONTEXT_CHARS = 1e5;
-  }
-});
-
-// src/ir/types.ts
-function createEmptyIR() {
-  return {
-    meta: {
-      name: "",
-      purpose: "",
-      techStack: { language: "" },
-      autonomyLevel: 2
-    },
-    sections: [],
-    commands: [],
-    rules: [],
-    agents: [],
-    skills: [],
-    docs: [],
-    hooks: [],
-    settings: createEmptySettings(),
-    mcpServers: [],
-    intents: []
-  };
-}
-function createEmptySettings() {
-  return { hooks: {}, raw: {} };
-}
-function createSection(id, heading, content, order) {
-  return { id, heading, content, order };
-}
-function createCommandNode(name, content, description) {
-  return { name, description: description ?? "", content };
-}
-function createRuleNode(name, content, paths) {
-  const node = { name, content };
-  if (paths !== void 0) {
-    node.paths = paths;
-  }
-  return node;
-}
-function createAgentNode(name, content, model) {
-  const node = { name, content };
-  if (model !== void 0) {
-    node.model = model;
-  }
-  return node;
-}
-function createEmptyDiff() {
-  return {
-    sections: {
-      added: [],
-      removed: [],
-      modified: [],
-      reordered: []
-    },
-    commands: {
-      added: [],
-      removed: [],
-      modified: []
-    },
-    rules: {
-      added: [],
-      removed: [],
-      modified: []
-    },
-    agents: {
-      added: [],
-      removed: [],
-      modified: []
-    },
-    mcpServers: {
-      added: [],
-      removed: []
-    },
-    settings: {
-      changes: []
-    }
-  };
+## Your Task
+Analyze the traces to identify WHY tasks fail or underperform. Then propose specific,
+minimal changes to the harness files that will fix those failures.
+
+## Diagnosis Process
+1. For each failed/low-scoring task:
+   a. Read the full trace (stdout, tool calls, file changes)
+   b. Identify the ROOT CAUSE: bad instruction? Missing tool? Wrong rule?
+   c. Trace the failure back to a specific harness decision
+   d. Propose a fix
+
+2. For each successful task:
+   a. Note what worked well
+   b. Ensure proposed changes don't break what's working
+
+3. Check history for counterfactual evidence
+
+## Available Mutation Actions
+1. **replace** \u2014 Replace old_text with new_text in a file: { "file": "...", "action": "replace", "old_text": "...", "new_text": "...", "rationale": "..." }
+2. **add_section** \u2014 Append new content to a file (or create it): { "file": "...", "action": "add_section", "new_text": "...", "rationale": "..." }
+3. **create_file** \u2014 Create a new file: { "file": "...", "action": "create_file", "new_text": "...", "rationale": "..." }
+4. **delete_section** \u2014 Remove specific text from a file: { "file": "...", "action": "delete_section", "old_text": "...", "rationale": "..." }
+5. **delete_file** \u2014 Delete an entire file: { "file": "...", "action": "delete_file", "rationale": "..." }
+
+## Output Format
+Return a JSON object:
+{
+  "reasoning": "Your full causal analysis...",
+  "mutations": [
+    { "file": "CLAUDE.md", "action": "replace", "old_text": "...", "new_text": "...", "rationale": "..." },
+    { "file": "commands/develop.md", "action": "add_section", "new_text": "...", "rationale": "..." },
+    { "file": "rules/obsolete.md", "action": "delete_file", "rationale": "..." }
+  ],
+  "expected_impact": { "task-id": "+15% \u2014 explanation" }
 }
-var init_types = __esm({
-  "src/ir/types.ts"() {
-    "use strict";
+
+## MCP Configuration
+You can also mutate .mcp.json to add, remove, or reconfigure MCP servers.
+Treat .mcp.json like any other harness file \u2014 propose changes when traces show
+the agent lacks a tool it needs, or has tools that add noise without benefit.
+
+## Rules
+- Propose AT MOST 3 mutations per iteration. Fewer, targeted mutations are more stable than many broad ones.
+- Each mutation must have a clear rationale tied to a specific trace observation.
+- Never remove something that's working for another task.
+- If a previous iteration's change caused a regression, REVERT it.
+- Consider both additions AND removals. Remove sections that add noise without improving task performance.
+- Bloated harnesses hurt performance \u2014 trim what isn't earning its keep.
+
+## Anti-Gaming (CRITICAL)
+- Mutations must improve GENERAL-PURPOSE development quality, not target specific eval criteria.
+- You do NOT have access to scoring rubrics or expected outcomes. Diagnose problems from traces only.
+- Do NOT add over-specified rules that restate existing conventions with stronger emphasis (e.g., changing "use chalk.green for success" to "MUST use chalk.green, no exceptions"). If a convention already exists, trust it.
+- Do NOT add rules that only apply to a narrow eval scenario (e.g., write permissions for a specific directory just because one task needed it).
+- Ask: "Would this mutation help a developer working on ANY task in this project?" If not, don't propose it.
+
+Return ONLY valid JSON.`;
+    STDOUT_TRUNCATION_LIMIT = 1e3;
+    MAX_CONTEXT_CHARS = 1e5;
   }
 });
 
@@ -1718,10 +2018,10 @@ function parseClaudeMd(content) {
     order: 0
   });
   for (let i = 1; i < chunks.length; i++) {
-    const chunk = chunks[i];
-    const newlineIdx = chunk.indexOf("\n");
-    const heading = newlineIdx >= 0 ? chunk.slice(0, newlineIdx).trim() : chunk.trim();
-    const sectionContent = newlineIdx >= 0 ? chunk.slice(newlineIdx + 1).trim() : "";
+    const chunk3 = chunks[i];
+    const newlineIdx = chunk3.indexOf("\n");
+    const heading = newlineIdx >= 0 ? chunk3.slice(0, newlineIdx).trim() : chunk3.trim();
+    const sectionContent = newlineIdx >= 0 ? chunk3.slice(newlineIdx + 1).trim() : "";
     const sectionId = resolveSectionId(heading);
     sections.push({
       id: sectionId,
@@ -2106,7 +2406,7 @@ var SECTION_ID_MAP;
 var init_parser = __esm({
   "src/ir/parser.ts"() {
     "use strict";
-    init_types();
+    init_types2();
     SECTION_ID_MAP = [
       { pattern: /^(purpose|about|what)\b/i, id: "purpose" },
       { pattern: /^(tech\s*stack|technology|stack)\b/i, id: "tech-stack" },
@@ -2292,7 +2592,7 @@ var COMMANDS_PATH_RE, RULES_PATH_RE, AGENTS_PATH_RE;
 var init_translate = __esm({
   "src/ir/translate.ts"() {
     "use strict";
-    init_types();
+    init_types2();
     init_parser();
     COMMANDS_PATH_RE = /^commands\/([^/]+?)(?:\.md)?$/;
     RULES_PATH_RE = /^rules\/([^/]+?)(?:\.md)?$/;
@@ -2503,205 +2803,21 @@ function applyIRMutation(ir, mutation) {
         ...ir,
         settings: applySettingsUpdate(ir.settings, mutation.path, mutation.value)
       };
-    }
-    // -- Raw text (legacy fallback) ----------------------------------------
-    case "raw_text": {
-      console.warn(
-        "raw_text mutation is a legacy fallback \u2014 the text operation will be applied during rendering"
-      );
-      return { ...ir };
-    }
-  }
-}
-var STRUCTURED_SETTINGS_KEYS;
-var init_mutations = __esm({
-  "src/ir/mutations.ts"() {
-    "use strict";
-    STRUCTURED_SETTINGS_KEYS = /* @__PURE__ */ new Set(["statusLine", "hooks", "denyPatterns"]);
-  }
-});
-
-// src/ir/renderer.ts
-function renderClaudeMd(_meta, sections) {
-  const sorted = [...sections].sort((a, b) => a.order - b.order);
-  const blocks = [];
-  for (const section of sorted) {
-    if (section.heading && section.content) {
-      blocks.push(`${section.heading}
-
-${section.content}`);
-    } else if (section.heading) {
-      blocks.push(section.heading);
-    } else if (section.content) {
-      blocks.push(section.content);
-    }
-  }
-  if (blocks.length === 0) {
-    return "\n";
-  }
-  return blocks.join("\n\n") + "\n";
-}
-function renderSettings(settings) {
-  const result = JSON.parse(
-    JSON.stringify(settings.raw)
-  );
-  if (settings.denyPatterns && settings.denyPatterns.length > 0) {
-    const permissions = result["permissions"] ?? {};
-    permissions["deny"] = settings.denyPatterns;
-    result["permissions"] = permissions;
-  }
-  if (settings.statusLine) {
-    result["statusLine"] = settings.statusLine;
-  }
-  const hookEvents = [
-    "PreToolUse",
-    "PostToolUse",
-    "UserPromptSubmit",
-    "SessionStart",
-    "PostCompact"
-  ];
-  const hooksObj = {};
-  let hasHooks = false;
-  for (const event of hookEvents) {
-    const entries = settings.hooks[event];
-    if (entries && entries.length > 0) {
-      hooksObj[event] = entries;
-      hasHooks = true;
-    }
-  }
-  if (hasHooks) {
-    result["hooks"] = hooksObj;
-  }
-  return JSON.stringify(result, null, 2) + "\n";
-}
-function renderMcpConfig(servers) {
-  if (servers.length === 0) {
-    return "";
-  }
-  const mcpServers = {};
-  for (const server of servers) {
-    const entry = {
-      command: server.command,
-      args: server.args
-    };
-    if (server.env && Object.keys(server.env).length > 0) {
-      entry["env"] = server.env;
-    }
-    mcpServers[server.id] = entry;
-  }
-  return JSON.stringify({ mcpServers }, null, 2) + "\n";
-}
-function renderRuleWithFrontmatter(rule) {
-  if (!rule.paths || rule.paths.length === 0) {
-    return rule.content;
-  }
-  const yamlLines = ["---", "paths:"];
-  for (const p of rule.paths) {
-    yamlLines.push(`  - ${p}`);
-  }
-  yamlLines.push("---");
-  return yamlLines.join("\n") + "\n\n" + rule.content;
-}
-function renderAgentWithFrontmatter(agent) {
-  const hasModel = agent.model !== void 0;
-  const hasDisallowed = agent.disallowedTools !== void 0 && agent.disallowedTools.length > 0;
-  const hasRouting = agent.modelRouting !== void 0;
-  const hasExtra = agent.extraFrontmatter !== void 0 && Object.keys(agent.extraFrontmatter).length > 0;
-  if (!hasModel && !hasDisallowed && !hasRouting && !hasExtra) {
-    return agent.content;
-  }
-  const yamlLines = ["---"];
-  if (hasModel) {
-    yamlLines.push(`model: ${agent.model}`);
-  }
-  if (hasDisallowed) {
-    yamlLines.push("disallowedTools:");
-    for (const tool of agent.disallowedTools) {
-      yamlLines.push(`  - ${tool}`);
-    }
-  }
-  if (hasRouting) {
-    yamlLines.push("modelRouting:");
-    yamlLines.push(`  default: ${agent.modelRouting.default}`);
-    if (agent.modelRouting.escalateTo) {
-      yamlLines.push(`  escalateTo: ${agent.modelRouting.escalateTo}`);
-    }
-    if (agent.modelRouting.escalateWhen) {
-      yamlLines.push(`  escalateWhen: ${agent.modelRouting.escalateWhen}`);
-    }
-  }
-  if (hasExtra) {
-    for (const [key, value] of Object.entries(agent.extraFrontmatter)) {
-      if (Array.isArray(value)) {
-        yamlLines.push(`${key}:`);
-        for (const item of value) {
-          yamlLines.push(`  - ${String(item)}`);
-        }
-      } else if (typeof value === "object" && value !== null) {
-        yamlLines.push(`${key}:`);
-        for (const [subKey, subVal] of Object.entries(value)) {
-          yamlLines.push(`  ${subKey}: ${String(subVal)}`);
-        }
-      } else {
-        yamlLines.push(`${key}: ${String(value)}`);
-      }
-    }
-  }
-  yamlLines.push("---");
-  return yamlLines.join("\n") + "\n\n" + agent.content;
-}
-function settingsHasContent(settings) {
-  if (settings.statusLine) return true;
-  if (settings.denyPatterns && settings.denyPatterns.length > 0) return true;
-  if (Object.keys(settings.raw).length > 0) return true;
-  const hookEvents = [
-    "PreToolUse",
-    "PostToolUse",
-    "UserPromptSubmit",
-    "SessionStart",
-    "PostCompact"
-  ];
-  for (const event of hookEvents) {
-    const entries = settings.hooks[event];
-    if (entries && entries.length > 0) return true;
-  }
-  return false;
-}
-function renderHarness(ir) {
-  const files = /* @__PURE__ */ new Map();
-  if (ir.sections.length > 0 || ir.meta.name) {
-    files.set("CLAUDE.md", renderClaudeMd(ir.meta, ir.sections));
-  }
-  if (settingsHasContent(ir.settings)) {
-    files.set("settings.json", renderSettings(ir.settings));
-  }
-  for (const cmd of ir.commands) {
-    files.set(`commands/${cmd.name}.md`, cmd.content);
-  }
-  for (const rule of ir.rules) {
-    files.set(`rules/${rule.name}.md`, renderRuleWithFrontmatter(rule));
-  }
-  for (const agent of ir.agents) {
-    files.set(`agents/${agent.name}.md`, renderAgentWithFrontmatter(agent));
-  }
-  for (const skill of ir.skills) {
-    files.set(`skills/${skill.name}.md`, skill.content);
-  }
-  for (const doc of ir.docs) {
-    files.set(`docs/${doc.name}.md`, doc.content);
-  }
-  for (const hook of ir.hooks) {
-    files.set(`hooks/${hook.name}.mjs`, hook.content);
-  }
-  const mcpContent = renderMcpConfig(ir.mcpServers);
-  if (mcpContent) {
-    files.set(".mcp.json", mcpContent);
+    }
+    // -- Raw text (legacy fallback) ----------------------------------------
+    case "raw_text": {
+      console.warn(
+        "raw_text mutation is a legacy fallback \u2014 the text operation will be applied during rendering"
+      );
+      return { ...ir };
+    }
   }
-  return files;
 }
-var init_renderer = __esm({
-  "src/ir/renderer.ts"() {
+var STRUCTURED_SETTINGS_KEYS;
+var init_mutations = __esm({
+  "src/ir/mutations.ts"() {
     "use strict";
+    STRUCTURED_SETTINGS_KEYS = /* @__PURE__ */ new Set(["statusLine", "hooks", "denyPatterns"]);
   }
 });
 
@@ -2964,7 +3080,7 @@ function deepEqual(a, b) {
 var init_diff = __esm({
   "src/ir/diff.ts"() {
     "use strict";
-    init_types();
+    init_types2();
   }
 });
 
@@ -3590,7 +3706,8 @@ var init_targeting = __esm({
       "refactor": ["architecture", "conventions"],
       "test-writing": ["verification", "commands"],
       "config-change": ["settings", "mcp"],
-      "documentation": ["general"]
+      "documentation": ["general"],
+      "persistence-completion": ["commands", "verification"]
     };
   }
 });
@@ -4585,7 +4702,7 @@ function estimateTime(model, intent) {
     "qwen": 10
   };
   const basePerPass = Object.entries(perPass).find(([k]) => model.toLowerCase().includes(k))?.[1] ?? 20;
-  const totalBase = basePerPass * 2;
+  const totalBase = basePerPass * 3;
   if (isComplex) {
     const low = Math.floor(totalBase * 1.5);
     const high = Math.floor(totalBase * 4);
@@ -4635,13 +4752,7 @@ function createProgressRenderer() {
         }
         currentPhase = "";
       } else if (progress.status === "warning") {
-        const lastIdx = lines.length - 1;
-        if (lastIdx >= 0) {
-          lines[lastIdx] = `  ${chalk.yellow("\u26A0")} ${progress.message}`;
-        }
-        currentPhase = progress.phase;
-        phaseStart = Date.now();
-        lines.push(`  ${warmStone("\u25D0")} Retrying in concise mode... ${chalk.dim("[0s]")}`);
+        lines.push(`  ${chalk.yellow("\u26A0")} ${progress.message}`);
       }
       render();
     },
@@ -4909,7 +5020,7 @@ You must output a JSON object matching the SkeletonSpec schema.
 - MCP servers: maximum 6. Prefer fewer.
 - Skills: maximum 3. Only include directly relevant ones.
 - Agents: maximum 5. Orchestration pipeline (/develop) agents.
-- Hooks: maximum 4 (auto-format, block-destructive, PostCompact, plus one contextual).
+- Hooks: maximum 5 (auto-format, block-destructive, PostCompact, memory-persistence, plus one contextual).
 
 If the workflow doesn't clearly need a tool, DO NOT include it.
 Each MCP server costs 500-2000 tokens of context window.
@@ -4937,16 +5048,17 @@ Return ONLY valid JSON matching this structure:
 \`\`\`
 
 Return ONLY valid JSON. No markdown fences. No text outside the JSON.`;
-var HARNESS_PROMPT = `You are the Kairn harness compiler. Your job is to generate the full environment content from a project skeleton.
+var SYSTEM_PROMPT = `You are the Kairn environment compiler. Your job is to generate a minimal, optimal Claude Code agent environment from a user's natural language description of what they want their agent to do.
 
 You will receive:
-1. The skeleton (tool selections + project outline)
-2. The user's original intent
+1. The user's intent (what they want to build/do)
+2. A tool registry (available MCP servers, plugins, and hooks)
 
-You must generate all harness content: CLAUDE.md, commands, rules, agents, skills, and docs.
+You must output a JSON object matching the EnvironmentSpec schema.
 
 ## Core Principles
 
+- **Minimalism over completeness.** Fewer, well-chosen tools beat many generic ones. Each MCP server costs 500-2000 context tokens.
 - **Workflow-specific, not generic.** Every instruction, command, and rule must relate to the user's actual workflow.
 - **Concise CLAUDE.md.** Under 150 lines. No generic text like "be helpful." Include build/test commands, reference docs/ and skills/.
 - **Security by default.** Always include deny rules for destructive commands and secret file access.
@@ -5069,494 +5181,1262 @@ Do not add generic filler. Every line must be specific to the user's workflow.
 17. A "Completion Standards" section in CLAUDE.md (never mark done without verifying: requirements met, tests passing, no debug artifacts, reviewed from 3 perspectives)
 18. A "Sprint Contract" section in CLAUDE.md (confirm acceptance criteria exist before implementing, verify each criterion after)
 
-## Shell-Integrated Commands
+## Tool Selection Rules
+
+- Only select tools directly relevant to the described workflow
+- Prefer free tools (auth: "none") when quality is comparable
+- Tier 1 tools (Context7, Sequential Thinking, security-guidance) should be included in most environments
+- For tools requiring API keys (auth: "api_key"), use \${ENV_VAR} syntax \u2014 never hardcode keys
+- Maximum 6-8 MCP servers to avoid context bloat
+- Include a \`reason\` for each selected tool explaining why it fits this workflow
 
-Commands that reference live project state should use Claude Code's \`!\` prefix for shell output:
+## Context Budget (STRICT)
 
-\`\`\`markdown
-# Example: .claude/commands/review.md
-Review the staged changes for quality and security:
+- MCP servers: maximum 6. Prefer fewer.
+- CLAUDE.md: maximum 150 lines.
+- Rules: maximum 5 files, each under 20 lines.
+- Skills: maximum 3. Only include directly relevant ones.
+- Agents: maximum 5. Orchestration pipeline (/develop) agents.
+- Commands: no limit (loaded on demand, zero context cost).
+- Hooks: maximum 5 (auto-format, block-destructive, PostCompact, memory-persistence, plus one contextual).
 
-!git diff --staged
+If the workflow doesn't clearly need a tool, DO NOT include it.
+Each MCP server costs 500-2000 tokens of context window.
 
-Run tests and check for failures:
+## Output Schema
 
-!npm test 2>&1 | tail -20
+Return ONLY valid JSON matching this structure:
 
-Focus on: security, error handling, test coverage.
+\`\`\`json
+{
+  "name": "short-kebab-case-name",
+  "description": "One-line description of the environment",
+  "tools": [
+    { "tool_id": "id-from-registry", "reason": "why this tool fits" }
+  ],
+  "harness": {
+    "claude_md": "The full CLAUDE.md content (under 150 lines)",
+    "settings": {
+      "permissions": {
+        "allow": ["Bash(npm run *)", "Read", "Write", "Edit"],
+        "deny": ["Bash(rm -rf *)", "Bash(curl * | sh)", "Read(./.env)", "Read(./secrets/**)"]
+      }
+    },
+    "mcp_config": {
+      "server-name": { "command": "npx", "args": ["..."], "env": {} }
+    },
+    "commands": {
+      "help": "markdown content for /project:help",
+      "develop": "markdown content for /project:develop",
+      "persist": "markdown content for /project:persist"
+    },
+    "rules": {
+      "continuity": "markdown content for continuity rule",
+      "security": "markdown content for security rule"
+    },
+    "skills": {
+      "skill-name/SKILL": "markdown content with YAML frontmatter"
+    },
+    "agents": {
+      "architect": "agent markdown with YAML frontmatter",
+      "planner": "agent markdown with YAML frontmatter",
+      "implementer": "agent markdown with YAML frontmatter",
+      "fixer": "agent markdown with YAML frontmatter",
+      "doc-updater": "agent markdown with YAML frontmatter"
+    },
+    "docs": {
+      "DECISIONS": "# Decisions\\n\\nArchitectural decisions.",
+      "LEARNINGS": "# Learnings\\n\\nNon-obvious discoveries.",
+      "SPRINT": "# Sprint\\n\\nLiving spec and plan."
+    }
+  }
+}
 \`\`\`
 
-Use \`!\` when a command needs: git status, test results, build output, or file listings.
+Do not include any text outside the JSON object. Do not wrap in markdown code fences.`;
+var CLARIFICATION_PROMPT = `You are helping a user define their project for environment compilation.
 
-## Path-Scoped Rules
+Given their initial description, generate 3-5 clarifying questions to understand:
+1. Language and framework
+2. What the project specifically does (be precise)
+3. Primary workflow (build, research, write, analyze?)
+4. Key dependencies or integrations
+5. Target audience
 
-For code projects with multiple domains (API, frontend, tests), generate path-scoped rules using YAML frontmatter:
+For each question, provide a reasonable suggestion based on the description.
 
-\`\`\`markdown
-# Example: rules/api.md
----
-paths:
-  - "src/api/**"
-  - "src/routes/**"
----
-- All handlers return { data, error } shape
-- Use Zod for request validation
-- Log errors with request ID context
-\`\`\`
+Output ONLY a JSON array:
+[
+  { "question": "Language/framework?", "suggestion": "TypeScript + Node.js" },
+  ...
+]
 
-\`\`\`markdown
-# Example: rules/testing.md
----
-paths:
-  - "tests/**"
-  - "**/*.test.*"
-  - "**/*.spec.*"
----
-- Use AAA pattern: Arrange-Act-Assert
-- One assertion per test when possible
-- Mock external dependencies, never real APIs
-\`\`\`
+Rules:
+- Suggestions should be reasonable guesses, clearly marked as suggestions
+- Keep questions short (under 10 words)
+- Maximum 5 questions
+- If the description is already very detailed, ask fewer questions`;
 
-Keep \`security.md\` and \`continuity.md\` as unconditional (no paths frontmatter).
-Only generate scoped rules when the workflow involves multiple code domains.
+// src/registry/loader.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path3.dirname(__filename2);
+async function loadBundledRegistry() {
+  const candidates = [
+    path3.resolve(__dirname2, "../registry/tools.json"),
+    path3.resolve(__dirname2, "../src/registry/tools.json"),
+    path3.resolve(__dirname2, "../../src/registry/tools.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const data = await fs3.readFile(candidate, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("Could not find tools.json registry");
+}
+async function loadUserRegistry() {
+  try {
+    const data = await fs3.readFile(getUserRegistryPath(), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+async function saveUserRegistry(tools) {
+  await fs3.writeFile(getUserRegistryPath(), JSON.stringify(tools, null, 2), "utf-8");
+}
+async function loadRegistry() {
+  const bundled = await loadBundledRegistry();
+  const user = await loadUserRegistry();
+  if (user.length === 0) return bundled;
+  const merged = /* @__PURE__ */ new Map();
+  for (const tool of bundled) {
+    merged.set(tool.id, tool);
+  }
+  for (const tool of user) {
+    merged.set(tool.id, tool);
+  }
+  return Array.from(merged.values());
+}
 
-## Hooks
+// src/compiler/compile.ts
+init_providers();
+init_llm();
 
-Generate hooks in settings.json based on project type:
+// src/compiler/plan.ts
+init_llm();
+init_types();
+var ORCHESTRATOR_PROMPT = `You are the Kairn compilation planner. Given a project skeleton and user intent, produce a CompilationPlan JSON that determines what to generate and in what order.
+
+## Agent Types
+- sections-writer: generates CLAUDE.md sections (Purpose, Tech Stack, Commands, Architecture, Conventions, Key Commands, Output, Verification, Known Gotchas, Debugging, Git Workflow, Engineering Standards)
+- rule-writer: generates .claude/rules/ files (security, continuity, plus project-specific)
+- doc-writer: generates .claude/docs/ files (DECISIONS, LEARNINGS, SPRINT)
+- command-writer: generates .claude/commands/ files (help, build, test, status, fix, develop, sprint, spec, prove, grill, persist, etc.)
+- agent-writer: generates .claude/agents/ files (architect, planner, implementer, fixer, doc-updater, qa-orchestrator, linter, e2e-tester)
+- skill-writer: generates .claude/skills/ files (tdd, etc.)
+
+## Phase Rules
+- Phase A (no dependencies): sections-writer, rule-writer, doc-writer
+- Phase B (depends on Phase A): command-writer, agent-writer, skill-writer (optional)
+- Phase C (depends on Phase B): reserved for linker (NOT included in plan \u2014 it runs separately)
+
+## Token Budgets
+- sections-writer: 4096, command-writer: 4096, agent-writer: 4096
+- rule-writer: 2048, doc-writer: 2048, skill-writer: 2048
 
-**All code projects** \u2014 block destructive commands, credential leaks, injection, and network exfiltration:
-\`\`\`json
+## Output Format
+Return ONLY valid JSON:
 {
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Bash",
-        "hooks": [{
-          "type": "command",
-          "command": "CMD=$(cat | jq -r '.tool_input.command // empty') && echo \\"$CMD\\" | grep -qiE 'rm\\\\s+-rf\\\\s+/|DROP\\\\s+(TABLE|DATABASE)|curl.*\\\\|\\\\s*sh|:(){ :|:& };:|git\\\\s+push.*--force(?!-with-lease)|ch(mod|own).*-R\\\\s+/|npm\\\\s+publish(?!.*--dry-run)|(api[_-]?key|secret|token|password)\\\\s*[:=]|AKIA[0-9A-Z]{16}|BEGIN.*PRIVATE\\\\s+KEY|;\\\\s*(DROP|DELETE|ALTER|TRUNCATE)\\\\s+|\\\\.\\\\./\\\\.\\\\./\\\\.\\\\./|nc\\\\s+.*-e|/dev/tcp/|bash\\\\s+-i|curl.*-d.*@|wget.*--post-file' && echo 'Blocked dangerous command' >&2 && exit 2 || true"
-        }]
+  "project_context": "2-3 sentence project summary",
+  "phases": [
+    {
+      "id": "phase-a",
+      "agents": [
+        { "agent": "sections-writer", "items": ["purpose", "tech-stack", "commands", ...], "max_tokens": 4096 },
+        { "agent": "rule-writer", "items": ["security", "continuity", ...], "max_tokens": 2048 },
+        { "agent": "doc-writer", "items": ["DECISIONS", "LEARNINGS", "SPRINT"], "max_tokens": 2048 }
+      ],
+      "dependsOn": []
+    },
+    {
+      "id": "phase-b",
+      "agents": [...],
+      "dependsOn": ["phase-a"]
+    }
+  ]
+}`;
+var STANDARD_SECTION_ITEMS = [
+  "purpose",
+  "tech-stack",
+  "commands",
+  "architecture",
+  "conventions",
+  "key-commands",
+  "output",
+  "verification",
+  "gotchas",
+  "debugging",
+  "git-workflow"
+];
+var STANDARD_DOC_ITEMS = ["DECISIONS", "LEARNINGS", "SPRINT"];
+var TOKEN_BUDGETS = {
+  "sections-writer": 4096,
+  "command-writer": 4096,
+  "agent-writer": 4096,
+  "rule-writer": 2048,
+  "doc-writer": 2048,
+  "skill-writer": 2048
+};
+async function generatePlan(intent, skeleton, config) {
+  try {
+    const userMessage = buildPlanMessage(intent, skeleton);
+    const response = await callLLM(config, userMessage, {
+      systemPrompt: ORCHESTRATOR_PROMPT,
+      maxTokens: 2048,
+      cacheControl: true
+    });
+    const parsed = parsePlanResponse(response);
+    return validatePlan(parsed);
+  } catch {
+    return generateDefaultPlan(skeleton);
+  }
+}
+function generateDefaultPlan(skeleton) {
+  const projectContext = `${skeleton.name}: ${skeleton.description}`;
+  const sectionItems = [...STANDARD_SECTION_ITEMS];
+  const ruleItems = ["security", "continuity", ...skeleton.outline.custom_rules];
+  const docItems = [...STANDARD_DOC_ITEMS];
+  const phaseA = {
+    id: "phase-a",
+    agents: [
+      { agent: "sections-writer", items: sectionItems, max_tokens: TOKEN_BUDGETS["sections-writer"] },
+      { agent: "rule-writer", items: ruleItems, max_tokens: TOKEN_BUDGETS["rule-writer"] },
+      { agent: "doc-writer", items: docItems, max_tokens: TOKEN_BUDGETS["doc-writer"] }
+    ],
+    dependsOn: []
+  };
+  const commandItems = ["help", ...skeleton.outline.key_commands];
+  const phaseBAgents = [
+    { agent: "command-writer", items: commandItems, max_tokens: TOKEN_BUDGETS["command-writer"] }
+  ];
+  if (skeleton.outline.custom_agents.length > 0) {
+    phaseBAgents.push({
+      agent: "agent-writer",
+      items: skeleton.outline.custom_agents,
+      max_tokens: TOKEN_BUDGETS["agent-writer"]
+    });
+  }
+  if (skeleton.outline.custom_skills.length > 0) {
+    phaseBAgents.push({
+      agent: "skill-writer",
+      items: skeleton.outline.custom_skills,
+      max_tokens: TOKEN_BUDGETS["skill-writer"]
+    });
+  }
+  const phaseB = {
+    id: "phase-b",
+    agents: phaseBAgents,
+    dependsOn: ["phase-a"]
+  };
+  return {
+    project_context: projectContext,
+    phases: [phaseA, phaseB]
+  };
+}
+function buildPlanMessage(intent, skeleton) {
+  return [
+    "## Intent",
+    intent,
+    "",
+    "## Skeleton",
+    JSON.stringify(skeleton, null, 2),
+    "",
+    "Generate the CompilationPlan JSON now."
+  ].join("\n");
+}
+function parsePlanResponse(text) {
+  let cleaned = text.trim();
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+  }
+  const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error("Orchestrator did not return valid JSON");
+  }
+  return JSON.parse(jsonMatch[0]);
+}
+
+// src/compiler/batch.ts
+init_types();
+init_types2();
+function mergeIntoIR(ir, result) {
+  switch (result.agent) {
+    case "sections-writer":
+      ir.sections.push(...result.sections);
+      break;
+    case "command-writer":
+      ir.commands.push(...result.commands);
+      break;
+    case "agent-writer":
+      ir.agents.push(...result.agents);
+      break;
+    case "rule-writer":
+      ir.rules.push(...result.rules);
+      break;
+    case "doc-writer":
+      ir.docs.push(...result.docs);
+      break;
+    case "skill-writer":
+      ir.skills.push(...result.skills);
+      break;
+  }
+}
+async function runWithConcurrency(tasks, limit) {
+  if (tasks.length === 0) return [];
+  const results = new Array(tasks.length);
+  let nextIndex = 0;
+  let firstError = void 0;
+  let hasError = false;
+  async function runNext() {
+    while (nextIndex < tasks.length) {
+      const index = nextIndex++;
+      try {
+        results[index] = await tasks[index]();
+      } catch (err) {
+        if (!hasError) {
+          hasError = true;
+          firstError = err;
+        }
+        return;
+      }
+    }
+  }
+  const workers = [];
+  const workerCount = Math.min(limit, tasks.length);
+  for (let i = 0; i < workerCount; i++) {
+    workers.push(runNext());
+  }
+  await Promise.all(workers);
+  if (hasError) {
+    throw firstError;
+  }
+  return results;
+}
+async function executePlan(plan, executeAgent, concurrency, onProgress) {
+  if (plan.phases.length === 0) {
+    return createEmptyIR();
+  }
+  const phaseIds = new Set(plan.phases.map((p) => p.id));
+  for (const phase of plan.phases) {
+    for (const dep of phase.dependsOn) {
+      if (!phaseIds.has(dep)) {
+        throw new Error(
+          `Phase "${phase.id}" depends on unknown phase "${dep}"`
+        );
+      }
+    }
+  }
+  const phaseIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < plan.phases.length; i++) {
+    phaseIndex.set(plan.phases[i].id, i);
+  }
+  for (const phase of plan.phases) {
+    const myIdx = phaseIndex.get(phase.id);
+    for (const dep of phase.dependsOn) {
+      const depIdx = phaseIndex.get(dep);
+      if (depIdx !== void 0 && depIdx >= myIdx) {
+        throw new Error(
+          `Phase "${phase.id}" has a dependency ordering violation: depends on "${dep}" which is not in an earlier position`
+        );
+      }
+    }
+  }
+  const ir = createEmptyIR();
+  const completed = /* @__PURE__ */ new Set();
+  for (const phase of plan.phases) {
+    for (const dep of phase.dependsOn) {
+      if (!completed.has(dep)) {
+        throw new Error(
+          `Phase "${phase.id}" depends on incomplete phase "${dep}"`
+        );
+      }
+    }
+    onProgress?.({
+      phaseId: phase.id,
+      status: "start",
+      agentCount: phase.agents.length
+    });
+    const agentTasks = phase.agents.map((task) => async () => {
+      try {
+        return await executeAgent(task);
+      } catch (err) {
+        if (err instanceof TruncationError) {
+          const retryTask = {
+            ...task,
+            max_tokens: task.max_tokens * 2
+          };
+          return await executeAgent(retryTask);
+        }
+        throw err;
+      }
+    });
+    const results = await runWithConcurrency(agentTasks, concurrency);
+    for (const result of results) {
+      mergeIntoIR(ir, result);
+    }
+    completed.add(phase.id);
+    onProgress?.({
+      phaseId: phase.id,
+      status: "complete",
+      agentCount: phase.agents.length,
+      completedCount: phase.agents.length
+    });
+  }
+  return ir;
+}
+
+// src/compiler/linker.ts
+init_types2();
+var DEFAULT_HELP_CONTENT = "Show available commands and their descriptions.\n\nList all /project: commands with brief descriptions.";
+var DEFAULT_HELP_DESCRIPTION = "Show available commands";
+var DEFAULT_SECURITY_CONTENT = [
+  "# Security Rules",
+  "",
+  "- NEVER log or echo API keys, tokens, or secrets",
+  "- NEVER write secrets to files",
+  "- NEVER execute user-provided strings as shell commands",
+  "- Validate all inputs before use"
+].join("\n");
+var DEFAULT_CONTINUITY_CONTENT = [
+  "# Continuity",
+  "",
+  "After every significant decision or discovery:",
+  "",
+  "1. Update docs/DECISIONS.md",
+  "2. Update docs/LEARNINGS.md",
+  "3. Update docs/TODO.md task status"
+].join("\n");
+var AGENT_REF_PATTERN = /@([\w-]+)/g;
+var COMMAND_REF_PATTERN = /\/project:([\w-]+)/g;
+function validateAgentReferences(patched, agentNames, report) {
+  for (const cmd of patched.commands) {
+    const refs = cmd.content.matchAll(AGENT_REF_PATTERN);
+    for (const match of refs) {
+      const name = match[1];
+      if (!agentNames.has(name)) {
+        report.warnings.push(
+          `Command "${cmd.name}" references non-existent agent "${name}"`
+        );
+        cmd.content = cmd.content.replace(
+          new RegExp(`@${escapeRegExp(name)}\\b`, "g"),
+          name
+        );
+        report.autoFixes.push(
+          `Removed @${name} mention from command "${cmd.name}"`
+        );
       }
-    ]
+    }
   }
 }
-\`\`\`
-
-**Projects with Prettier/ESLint/Black** \u2014 auto-format on write:
-\`\`\`json
-{
-  "hooks": {
-    "PostToolUse": [{
-      "matcher": "Edit|Write",
-      "hooks": [{
-        "type": "command",
-        "command": "FILE=$(cat | jq -r '.tool_input.file_path // empty') && [ -n \\"$FILE\\" ] && npx prettier --write \\"$FILE\\" 2>/dev/null || true"
-      }]
-    }]
+function validateCommandReferences(patched, commandNames, report) {
+  for (const agent of patched.agents) {
+    const refs = agent.content.matchAll(COMMAND_REF_PATTERN);
+    for (const match of refs) {
+      const name = match[1];
+      if (!commandNames.has(name)) {
+        report.warnings.push(
+          `Agent "${agent.name}" references non-existent command "${name}"`
+        );
+      }
+    }
   }
 }
-\`\`\`
-
-Merge hooks into the \`settings\` object alongside permissions. Choose the formatter hook based on detected dependencies (Prettier \u2192 prettier, ESLint \u2192 eslint, Black \u2192 black).
-
-## PostCompact Hook
-
-All projects should include a PostCompact hook to restore context after compaction:
-
-\`\`\`json
-{
-  "hooks": {
-    "PostCompact": [{
-      "matcher": "",
-      "hooks": [{
-        "type": "prompt",
-        "prompt": "Re-read CLAUDE.md and docs/SPRINT.md (if it exists) to restore project context after compaction."
-      }]
-    }]
+function injectHelpCommand(patched, report) {
+  const commandNames = new Set(patched.commands.map((c) => c.name));
+  if (!commandNames.has("help")) {
+    patched.commands.push(
+      createCommandNode("help", DEFAULT_HELP_CONTENT, DEFAULT_HELP_DESCRIPTION)
+    );
+    report.autoFixes.push("Injected default /project:help command");
   }
 }
-\`\`\`
-
-Merge this into the settings hooks alongside the PreToolUse and PostToolUse hooks.
-
-For long-running sessions (>2 hours or >3 compactions), prefer "Full Reset" over re-inject:
-replace the prompt-type PostCompact hook with a command-type hook that pipes CLAUDE.md + SPRINT.md + DECISIONS.md content directly into additionalContext.
-
-## Memory Persistence Hooks
-
-For projects with multi-session workflows, include SessionStart/End hooks that persist context to \`.claude/memory.json\`:
-- **SessionEnd:** Save recent decisions, sprint status, and known gotchas to \`.claude/memory.json\`
-- **SessionStart:** Load \`.claude/memory.json\` and inject as additionalContext
-
-This ensures accumulated project knowledge survives session boundaries.
-
-## For Code Projects, Additionally Include
-
-- \`/project:plan\` command (plan before coding)
-- \`/project:review\` command (review changes)
-- \`/project:test\` command (run and fix tests)
-- \`/project:commit\` command (conventional commits)
-- \`/project:status\` command (live git status, recent commits, SPRINT.md overview using ! prefix)
-- \`/project:fix\` command (takes $ARGUMENTS as issue number, plans fix, implements, tests, commits)
-- \`/project:sprint\` command (define acceptance criteria before coding, writes to docs/SPRINT.md)
-- \`/project:develop\` command (full development pipeline \u2014 orchestrates @architect \u2192 @planner \u2192 @implementer \u2192 @verifier \u2192 @fixer \u2192 @grill \u2192 @doc-updater through spec, plan, TDD implement, review, and doc update phases). Phase 4 (Verify) MUST validate EACH acceptance criterion from docs/SPRINT.md individually, reporting PASS/FAIL per item as a contract scorecard. MUST include a Phase 7 "Completion Gate" that runs a Completion Verification checklist before marking the feature done: re-read original requirements, confirm each is met with evidence, run test suite + lint/typecheck, review git diff for unexpected changes or debug artifacts, answer 3 perspective questions (test engineer, code reviewer, requesting user). If ANY check fails, loop back to fix before completing.
-- A TDD skill using the 3-phase isolation pattern (RED \u2192 GREEN \u2192 REFACTOR):
-  - RED: Write failing test only. Verify it FAILS.
-  - GREEN: Write MINIMUM code to pass. Nothing extra.
-  - REFACTOR: Improve while keeping tests green.
-  Rules: never write tests and implementation in same step, AAA pattern, one assertion per test.
-- A multi-agent QA pipeline:
-  - \`@qa-orchestrator\` (sonnet) \u2014 delegates to linter and e2e-tester, compiles QA report
-  - \`@linter\` (haiku) \u2014 runs formatters, linters, security scanners
-  - \`@e2e-tester\` (sonnet, only when Playwright is in tools) \u2014 browser-based QA via Playwright
-- A "Model Selection" section in generated agents:
-  \`\`\`
-  ## Model Selection (all agents)
-  - Haiku: simple file edits, linting, formatting, doc updates (<50 lines changed)
-  - Sonnet: implementation, testing, debugging, code review (50-500 lines)
-  - Opus: architecture decisions, spec writing, complex refactors (>500 lines or cross-cutting)
-  Default: Sonnet. Only escalate to Opus when the task involves multi-file architecture or ambiguous requirements.
-  \`\`\`
-- Development pipeline agents (used by /project:develop). Each agent should include a modelRouting field in its YAML frontmatter:
-  - \`@architect\` (default: opus) \u2014 conducts spec interview with user, writes confirmed spec to docs/SPRINT.md with numbered acceptance criteria. Your spec is a CONTRACT \u2014 the verifier will check every criterion. Vague criteria = guaranteed rework.
-  - \`@planner\` (default: sonnet, escalate to opus for cross-cutting changes) \u2014 reads spec and codebase, creates step-by-step implementation plan in docs/PLAN.md
-  - \`@implementer\` (default: sonnet, escalate to opus for cross-cutting changes) \u2014 TDD-focused implementation, writes failing tests then minimum code to pass
-  - \`@fixer\` (default: sonnet, use haiku for single-file fixes) \u2014 targeted bug fixing from verifier/review feedback
-  - \`@doc-updater\` (default: haiku) \u2014 extracts decisions and learnings from completed work, updates docs/DECISIONS.md and docs/LEARNINGS.md
-- \`/project:spec\` command (interview-based spec creation \u2014 asks 5-8 questions one at a time, writes structured spec to docs/SPRINT.md with ## Acceptance Criteria containing 3-8 numbered, testable conditions. Each criterion must be independently verifiable. Does NOT start coding until confirmed)
-- \`/project:prove\` command (runs tests, shows git diff vs main, rates confidence HIGH/MEDIUM/LOW with evidence)
-- \`/project:grill\` command (adversarial code review \u2014 challenges each change with "why this approach?", "what if X input?", rates BLOCKER/SHOULD-FIX/NITPICK, blocks until BLOCKERs resolved)
-- \`/project:reset\` command (reads DECISIONS.md and LEARNINGS.md, proposes clean restart, stashes current work, implements elegant solution)
-
-## For Research Projects, Additionally Include
-
-- \`/project:research\` command (deep research on a topic)
-- \`/project:summarize\` command (summarize findings)
-- A research-synthesis skill
-- A researcher agent
-- Note: the Verification section in CLAUDE.md should adapt for research \u2014 e.g. "Verify all sources are cited" instead of build/test commands
-
-## For Content/Writing Projects, Additionally Include
-
-- \`/project:draft\` command (write first draft)
-- \`/project:edit\` command (review and improve writing)
-- A writing-workflow skill
-
-## Hermes Runtime
-
-When generating for Hermes runtime, the same EnvironmentSpec JSON is produced. The adapter layer handles conversion:
-- MCP config entries \u2192 Hermes config.yaml mcp_servers
-- Commands and skills \u2192 ~/.hermes/skills/ markdown files
-- Rules \u2192 ~/.hermes/skills/rule-*.md files
-
-The LLM output format does not change. Adapter-level conversion happens post-compilation.
-
-## Autonomy Levels
-
-The user may specify an autonomy level (1-4). This affects CLAUDE.md content:
-
-- **Level 1 (Guided):** Add a "Workflow" section showing recommended command flow (e.g., spec \u2192 sprint \u2192 plan \u2192 code \u2192 prove \u2192 grill \u2192 commit) and a "When to Use What" reference table.
-- **Level 2 (Assisted):** Level 1 content + mention /project:loop in the workflow section and @pm in the agents section of CLAUDE.md.
-- **Level 3 (Autonomous):** Level 2 content + mention /project:auto and worktree-based PR delivery workflow.
-- **Level 4 (Full Auto):** Level 3 content + add a prominent warning section about autonomous operation.
-
-The autonomy-specific commands, agents, and hooks are injected post-compilation. Focus on tailoring the CLAUDE.md content and workflow guidance for the selected level.
-
-If no autonomy level is specified, assume Level 1 (Guided).
-
-## Output Schema
-
-Return ONLY valid JSON matching this structure:
-
-\`\`\`json
-{
-  "claude_md": "Full CLAUDE.md content (under 150 lines)",
-  "commands": { "help": "...", "develop": "...", "status": "...", "fix": "...", "sprint": "...", "spec": "...", "prove": "...", "grill": "...", "reset": "..." },
-  "rules": { "continuity": "...", "security": "..." },
-  "agents": { "architect": "...", "planner": "...", "implementer": "...", "fixer": "...", "doc-updater": "...", "qa-orchestrator": "...", "linter": "...", "e2e-tester": "..." },
-  "skills": { "skill-name/SKILL": "..." },
-  "docs": { "DECISIONS": "...", "LEARNINGS": "...", "SPRINT": "..." }
+function injectSecurityRule(patched, report) {
+  const ruleNames = new Set(patched.rules.map((r) => r.name));
+  if (!ruleNames.has("security")) {
+    patched.rules.push(createRuleNode("security", DEFAULT_SECURITY_CONTENT));
+    report.autoFixes.push("Injected default security rule");
+  }
+}
+function injectContinuityRule(patched, report) {
+  const ruleNames = new Set(patched.rules.map((r) => r.name));
+  if (!ruleNames.has("continuity")) {
+    patched.rules.push(createRuleNode("continuity", DEFAULT_CONTINUITY_CONTENT));
+    report.autoFixes.push("Injected default continuity rule");
+  }
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function linkHarness(ir) {
+  const patched = JSON.parse(JSON.stringify(ir));
+  const report = { warnings: [], autoFixes: [] };
+  const agentNames = new Set(patched.agents.map((a) => a.name));
+  const commandNames = new Set(patched.commands.map((c) => c.name));
+  validateAgentReferences(patched, agentNames, report);
+  validateCommandReferences(patched, commandNames, report);
+  injectHelpCommand(patched, report);
+  injectSecurityRule(patched, report);
+  injectContinuityRule(patched, report);
+  return { ir: patched, report };
 }
-\`\`\`
 
-Return ONLY valid JSON. No markdown fences. No text outside the JSON.`;
-var SYSTEM_PROMPT = `You are the Kairn environment compiler. Your job is to generate a minimal, optimal Claude Code agent environment from a user's natural language description of what they want their agent to do.
+// src/compiler/agents/sections-writer.ts
+init_llm();
+init_types2();
+var SECTIONS_SYSTEM_PROMPT = `You are the Kairn sections writer. Generate CLAUDE.md sections for a development environment.
+
+You will receive a project description and a list of section IDs to generate. Each section should be well-structured markdown.
+
+## Standard Sections (generate those requested)
+- purpose: Project purpose and goals (## Purpose heading, but use project-specific title like "# ProjectName Development")
+- tech-stack: Languages, frameworks, tools (## Tech Stack)
+- commands: Build/dev/test commands (## Commands, use code blocks)
+- architecture: Project structure (## Architecture, use code blocks for tree)
+- conventions: Coding conventions (## Conventions, bullet points)
+- key-commands: Slash commands reference (## Key Commands, bullet list)
+- output: Build output paths (## Output)
+- verification: Post-edit verification steps (## Verification)
+- gotchas: Known issues and footguns (## Known Gotchas)
+- debugging: Debugging tips (## Debugging)
+- git-workflow: Git conventions (## Git Workflow)
+- engineering-standards: Code quality standards (## Engineering Standards)
 
-You will receive:
-1. The user's intent (what they want to build/do)
-2. A tool registry (available MCP servers, plugins, and hooks)
+## Rules
+- Each section: 5-20 lines of content
+- Use project-specific details, not generic advice
+- Markdown formatting: headers, bullets, code blocks
+- Be concise but informative
 
-You must output a JSON object matching the EnvironmentSpec schema.
+## Output Format
+Return a JSON array:
+[
+  { "id": "purpose", "heading": "# ProjectName Development", "content": "..." },
+  { "id": "tech-stack", "heading": "## Tech Stack", "content": "..." }
+]`;
+async function generateSections(intent, skeleton, task, config) {
+  if (task.items.length === 0) {
+    return { agent: "sections-writer", sections: [] };
+  }
+  const userMessage = buildUserMessage(intent, skeleton, task);
+  const response = await callLLM(config, userMessage, {
+    systemPrompt: SECTIONS_SYSTEM_PROMPT,
+    maxTokens: task.max_tokens,
+    agentName: "sections-writer",
+    cacheControl: true
+  });
+  const sections = parseSectionsResponse(response);
+  return { agent: "sections-writer", sections };
+}
+function buildUserMessage(intent, skeleton, task) {
+  const parts = [
+    `## Project
+${intent}`,
+    `## Tech Stack
+${skeleton.outline.tech_stack.join(", ")}`,
+    `## Workflow
+${skeleton.outline.workflow_type}`,
+    `## Sections to Generate
+${task.items.join(", ")}`
+  ];
+  if (task.context_hint) {
+    parts.push(`## Additional Context
+${task.context_hint}`);
+  }
+  parts.push("Generate the sections JSON array now.");
+  return parts.join("\n\n");
+}
+function parseSectionsResponse(text) {
+  let cleaned = text.trim();
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+  }
+  const jsonMatch = cleaned.match(/\[[\s\S]*\]/);
+  if (!jsonMatch) {
+    throw new Error(
+      "sections-writer: response did not contain a JSON array"
+    );
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  if (!Array.isArray(parsed)) {
+    throw new Error("sections-writer: expected JSON array");
+  }
+  return parsed.map((item, index) => {
+    const obj = item;
+    return createSection(
+      String(obj.id ?? `section-${index}`),
+      String(obj.heading ?? ""),
+      String(obj.content ?? ""),
+      index
+    );
+  });
+}
 
-## Core Principles
+// src/compiler/agents/rule-writer.ts
+init_llm();
+init_types2();
+var SYSTEM_PROMPT2 = `You are the @rule-writer specialist inside the Kairn compilation pipeline.
 
-- **Minimalism over completeness.** Fewer, well-chosen tools beat many generic ones. Each MCP server costs 500-2000 context tokens.
-- **Workflow-specific, not generic.** Every instruction, command, and rule must relate to the user's actual workflow.
-- **Concise CLAUDE.md.** Under 150 lines. No generic text like "be helpful." Include build/test commands, reference docs/ and skills/.
-- **Security by default.** Always include deny rules for destructive commands and secret file access.
+Your job is to generate Claude Code rule files (.claude/rules/*.md) for a project.
 
-## CLAUDE.md Template (mandatory structure)
+Each rule file may be **global** (applies everywhere) or **path-scoped** (applies only
+when the user edits files matching certain globs).
 
-The \`claude_md\` field MUST follow this exact structure (max 150 lines):
+## Output format
 
-\`\`\`
-# {Project Name}
+Return a JSON array. Each element:
 
-## Purpose
-{one-line description}
+{
+  "name": "rule-slug",
+  "content": "Markdown content of the rule file.",
+  "paths": null
+}
+
+- **name**: kebab-case slug (e.g. "security", "api-conventions", "testing").
+- **content**: The full Markdown body of the rule. Be specific, actionable, and concise.
+  Write imperative statements ("Do X", "Never Y"). Avoid vague advice.
+- **paths**: Either null (global rule) or a string array of glob patterns
+  (e.g. ["src/api/**", "src/routes/**"]).
+
+## Required rules
+
+Every project MUST include:
+1. **security** -- baseline security constraints (no secrets in code, input validation,
+   safe file I/O, no dynamic code execution, deny dangerous shell patterns).
+2. **continuity** -- project memory rules (update decision logs, learning docs, track
+   TODO progress, document gotchas).
+
+If the user's rule list doesn't mention these, generate them anyway.
+
+## Guidelines
+
+- Rules should be 5-20 lines of Markdown each.
+- Use bullet points for lists of constraints.
+- Path-scoped rules are for conventions that only matter in specific directories
+  (e.g. API conventions for src/api/**, test rules for **/*.test.ts).
+- Global rules apply to the whole project (security, continuity, git workflow).
+- Do NOT include YAML frontmatter in the content -- the paths field handles scoping.
+- Return ONLY the JSON array. No explanation, no wrapping text.`;
+var DEFAULT_SECURITY_CONTENT2 = [
+  "# Security Rules",
+  "",
+  "- NEVER log or echo API keys, tokens, or secrets",
+  "- NEVER write secrets to files outside designated config locations",
+  "- NEVER execute user-provided strings as shell commands",
+  "- NEVER use dynamic code execution with untrusted input",
+  "- Validate all external input before processing",
+  "- Sanitize all file paths -- prevent path traversal (../)",
+  "- Deny dangerous shell patterns: rm -rf /, curl|sh, wget|sh"
+].join("\n");
+var DEFAULT_CONTINUITY_CONTENT2 = [
+  "# Continuity",
+  "",
+  "After every significant decision or discovery:",
+  "",
+  "1. Update decision logs with what was decided and why",
+  "2. Document non-obvious behavior, gotchas, and footguns",
+  "3. Update task status as work progresses",
+  "4. If a mistake is corrected, add it to the known gotchas section",
+  "",
+  "These files are the project memory. Keep them current."
+].join("\n");
+function parseRulesJSON(raw) {
+  let cleaned = raw.trim();
+  const fenceStart = /^```(?:json)?\s*\n?/;
+  const fenceEnd = /\n?```\s*$/;
+  if (fenceStart.test(cleaned)) {
+    cleaned = cleaned.replace(fenceStart, "").replace(fenceEnd, "");
+  }
+  const parsed = JSON.parse(cleaned);
+  if (!Array.isArray(parsed)) {
+    throw new Error("Expected JSON array from rule-writer LLM response");
+  }
+  return parsed;
+}
+function buildUserMessage2(intent, skeleton, task) {
+  const lines = [
+    "## Project intent",
+    intent,
+    "",
+    "## Rules to generate",
+    ...task.items.map((item) => `- ${item}`),
+    "",
+    "## Project context",
+    JSON.stringify(skeleton.outline, null, 2)
+  ];
+  return lines.join("\n");
+}
+async function generateRules(intent, skeleton, task, config) {
+  if (task.items.length === 0) {
+    return { agent: "rule-writer", rules: [] };
+  }
+  const userMessage = buildUserMessage2(intent, skeleton, task);
+  const raw = await callLLM(config, userMessage, {
+    systemPrompt: SYSTEM_PROMPT2,
+    cacheControl: true,
+    maxTokens: task.max_tokens
+  });
+  const parsedRules = parseRulesJSON(raw);
+  const rules = parsedRules.map(
+    (r) => createRuleNode(
+      r.name,
+      r.content,
+      r.paths !== null ? r.paths : void 0
+    )
+  );
+  ensureRequiredRule(rules, "security", DEFAULT_SECURITY_CONTENT2);
+  ensureRequiredRule(rules, "continuity", DEFAULT_CONTINUITY_CONTENT2);
+  return { agent: "rule-writer", rules };
+}
+function ensureRequiredRule(rules, name, defaultContent) {
+  const exists = rules.some((r) => r.name === name);
+  if (!exists) {
+    rules.unshift(createRuleNode(name, defaultContent));
+  }
+}
 
-## Tech Stack
-{bullet list of frameworks/languages}
+// src/compiler/agents/doc-writer.ts
+init_llm();
+var DEFAULT_DECISIONS = `# Decisions
 
-## Commands
-{concrete build/test/lint/dev commands}
+| Date | Decision | Rationale |
+|------|----------|-----------|`;
+var DEFAULT_LEARNINGS = `# Learnings
 
-## Architecture
-{brief folder structure, max 10 lines}
+| Date | Learning | Impact |
+|------|----------|--------|`;
+var DEFAULT_SPRINT = `# Sprint
 
-## Conventions
-{3-5 specific coding rules}
+## Acceptance Criteria
 
-## Key Commands
-{list /project: commands with descriptions}
+- [ ] Criterion 1
 
-## Output
-{where results go, key files}
+## Status
 
-## Verification
-After implementing any change, verify it works:
-- {build command} \u2014 must pass with no errors
-- {test command} \u2014 all tests must pass
-- {lint command} \u2014 no warnings or errors
-- {type check command} \u2014 no type errors
+Not started`;
+var REQUIRED_DOCS = [
+  { name: "DECISIONS", defaultContent: DEFAULT_DECISIONS },
+  { name: "LEARNINGS", defaultContent: DEFAULT_LEARNINGS },
+  { name: "SPRINT", defaultContent: DEFAULT_SPRINT }
+];
+var DOC_WRITER_SYSTEM_PROMPT = `You are the doc-writer specialist agent in a multi-agent compilation pipeline.
 
-If any verification step fails, fix the issue before moving on.
-Do NOT skip verification steps.
+Your role: generate documentation files for a Claude Code agent environment's \`.claude/docs/\` directory.
 
-## Known Gotchas
-<!-- After any correction, add it here: "Update CLAUDE.md so you don't make that mistake again." -->
-<!-- Prune this section when it exceeds 10 items \u2014 keep only the recurring ones. -->
-- (none yet \u2014 this section grows as you work)
+## Output Format
 
-## Debugging
-When debugging, paste raw error output. Don't summarize \u2014 Claude works better with raw data.
-Use subagents for deep investigation to keep main context clean.
+Return a JSON array of objects, each with "name" (string) and "content" (string):
 
-## Git Workflow
-- Prefer small, focused commits (one feature or fix per commit)
-- Use conventional commits: feat:, fix:, docs:, refactor:, test:
-- Target < 200 lines per PR when possible
+\`\`\`json
+[
+  { "name": "DECISIONS", "content": "# Decisions\\n\\n| Date | Decision | Rationale |\\n|------|----------|-----------|" },
+  { "name": "LEARNINGS", "content": "# Learnings\\n\\n| Date | Learning | Impact |\\n|------|----------|--------|" }
+]
+\`\`\`
 
-## Engineering Standards
-- Lead with answers over reasoning. Be concise.
-- Use absolute file paths in all references.
-- No filler, no inner monologue, no time estimates.
-- Produce load-bearing code \u2014 every line of output should be actionable.
+## Document Templates
 
-## Tool Usage Policy
-- Prefer Edit tool over sed/awk for file modifications
-- Prefer Grep tool over rg for searching
-- Prefer Read tool over cat for file reading
-- Reserve Bash for: builds, installs, git, network, processes
-- Read and understand existing code before modifying
-- Delete unused code completely \u2014 no compatibility shims
+Each doc should follow these structural patterns:
 
-## Code Philosophy
-- Do not create abstractions for one-time operations
-- Complete the task fully \u2014 don't gold-plate, but don't leave it half-done
-- Prefer editing existing files over creating new ones
+- **DECISIONS**: Markdown table with Date, Decision, Rationale columns. Track architectural and design choices.
+- **LEARNINGS**: Markdown table with Date, Learning, Impact columns. Track non-obvious discoveries and gotchas.
+- **SPRINT**: Must include an "## Acceptance Criteria" section with checkbox items (\`- [ ] ...\`) and a "## Status" section. Track current sprint goals.
 
-## First Turn Protocol
+## Guidelines
 
-At the start of every session, before doing ANY work:
-1. Run \`pwd && ls -la && git status --short\` to orient yourself
-2. Check relevant runtimes (e.g. \`node --version\`, \`python3 --version\` \u2014 pick what fits this project)
-3. Read any task-tracking files (docs/SPRINT.md, docs/DECISIONS.md)
-4. Summarize what you see in 2-3 lines, then proceed
+- Content should be tailored to the project intent provided
+- Use Markdown formatting with clear headers
+- Acceptance Criteria in SPRINT docs must use checkbox format: \`- [ ] Criterion\`
+- Keep templates practical \u2014 they'll be filled in during development
+- Return ONLY the JSON array, no surrounding text`;
+function stripCodeFences(raw) {
+  let text = raw.trim();
+  const openFence = /^```(?:json)?\s*\n/;
+  if (openFence.test(text)) {
+    text = text.replace(openFence, "");
+  }
+  const closeFence = /\n```\s*$/;
+  if (closeFence.test(text)) {
+    text = text.replace(closeFence, "");
+  }
+  return text.trim();
+}
+async function generateDocs(intent, skeleton, task, config) {
+  if (task.items.length === 0) {
+    return { agent: "doc-writer", docs: [] };
+  }
+  const userMessage = buildUserMessage3(intent, skeleton, task);
+  const rawResponse = await callLLM(config, userMessage, {
+    systemPrompt: DOC_WRITER_SYSTEM_PROMPT,
+    cacheControl: true,
+    maxTokens: task.max_tokens
+  });
+  const parsedDocs = parseDocResponse(rawResponse);
+  const docs = ensureRequiredDocs(parsedDocs);
+  return { agent: "doc-writer", docs };
+}
+function buildUserMessage3(intent, _skeleton, task) {
+  const itemList = task.items.map((item) => `- ${item}`).join("\n");
+  return `Project intent: ${intent}
 
-This saves 2-5 exploratory turns. Never ask "what files are here?" \u2014 look first.
+Generate the following documentation files:
+${itemList}
 
-## Sprint Contract
+Return a JSON array of { "name": string, "content": string } objects.`;
+}
+function isDocShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value;
+  return typeof obj.name === "string" && typeof obj.content === "string";
+}
+function parseDocResponse(raw) {
+  const cleaned = stripCodeFences(raw);
+  const parsed = JSON.parse(cleaned);
+  if (!Array.isArray(parsed)) {
+    return [];
+  }
+  return parsed.filter(isDocShape).map(({ name, content }) => ({ name, content }));
+}
+function ensureRequiredDocs(docs) {
+  const result = [...docs];
+  const existingNames = new Set(result.map((d) => d.name));
+  for (const required of REQUIRED_DOCS) {
+    if (!existingNames.has(required.name)) {
+      result.push({
+        name: required.name,
+        content: required.defaultContent
+      });
+    }
+  }
+  return result;
+}
 
-Before implementing, confirm acceptance criteria exist in docs/SPRINT.md.
-Each criterion must be numbered, testable, and independently verifiable.
-After implementing, verify EACH criterion individually. Do not mark done until all pass.
+// src/compiler/agents/command-writer.ts
+init_llm();
+init_types2();
+var BATCH_SIZE = 8;
+var BATCH_THRESHOLD = 10;
+var DEFAULT_HELP_CONTENT2 = `Show available /project: commands and their descriptions.
 
-## Completion Standards
+List all slash commands with a brief description of what each does.`;
+var DEFAULT_HELP_DESCRIPTION2 = "Show available commands and their descriptions";
+var SYSTEM_PROMPT3 = `You are @command-writer, a specialist agent that generates Claude Code slash commands.
 
-Never mark a task "done" without running the Completion Verification checklist.
-Tests passing is necessary but not sufficient \u2014 also verify requirements coverage,
-state cleanliness, and review changes from the perspective of a test engineer,
-code reviewer, and the requesting user.
+## Output Format
+Return a JSON array of command objects. Each object has:
+- "name": the command name (no /project: prefix, just the bare name like "build", "test")
+- "description": a one-line description of what the command does
+- "content": the full command body (markdown text with optional shell integration)
+
+## Shell Integration
+Commands can execute shell commands using the ! prefix:
+- \`!npm run build\` \u2014 runs the command directly
+- \`!$ARGUMENTS\` \u2014 passes user arguments to a shell command
+- Multiple ! lines are run in sequence
+
+## Command Patterns
+- **Build/Test**: Direct shell execution with !
+- **Workflow**: Multi-step orchestration instructions in natural language
+- **Review**: Instructions for Claude to analyze code
+- **Deploy**: Safety checks + shell execution
+
+## Example Output
+\`\`\`json
+[
+  {
+    "name": "build",
+    "description": "Build the project",
+    "content": "Run the full build pipeline.\\n\\n!npm run build"
+  },
+  {
+    "name": "test",
+    "description": "Run the test suite",
+    "content": "Execute all tests and report results.\\n\\n!npm test"
+  },
+  {
+    "name": "review",
+    "description": "Review staged changes",
+    "content": "Review all staged git changes for:\\n- Code quality issues\\n- Security concerns\\n- Missing tests\\n\\nProvide actionable feedback."
+  }
+]
 \`\`\`
 
-Do not add generic filler. Every line must be specific to the user's workflow.
-
-## What You Must Always Include
-
-1. A concise, workflow-specific \`claude_md\` (the CLAUDE.md content)
-2. A \`/project:help\` command that explains the environment
-3. A \`docs/DECISIONS.md\` file for architectural decisions
-4. A \`docs/LEARNINGS.md\` file for non-obvious discoveries
-5. A \`rules/continuity.md\` rule encouraging updates to DECISIONS.md and LEARNINGS.md
-6. A \`rules/security.md\` rule with essential security instructions
-7. settings.json with deny rules for \`rm -rf\`, \`curl|sh\`, reading \`.env\` and \`secrets/\`
-8. A \`/project:status\` command for code projects (uses ! for live git/SPRINT.md output)
-9. A \`/project:fix\` command for code projects (uses $ARGUMENTS for issue number)
-10. A \`docs/SPRINT.md\` file as the living spec/plan (replaces TODO.md \u2014 acceptance criteria, verification steps)
-11. A "Verification" section in CLAUDE.md with concrete verify commands for the project
-12. A "Known Gotchas" section in CLAUDE.md (starts empty, grows with corrections)
-13. A "Debugging" section in CLAUDE.md (2 lines: paste raw errors, use subagents)
-14. A "Git Workflow" section in CLAUDE.md (3 rules: small commits, conventional format, <200 lines PR)
-15. "Engineering Standards", "Tool Usage Policy", and "Code Philosophy" sections in CLAUDE.md
-16. A "First Turn Protocol" section in CLAUDE.md (orient before working: pwd, ls, git status, check relevant runtimes, read task files)
-17. A "Completion Standards" section in CLAUDE.md (never mark done without verifying: requirements met, tests passing, no debug artifacts, reviewed from 3 perspectives)
-18. A "Sprint Contract" section in CLAUDE.md (confirm acceptance criteria exist before implementing, verify each criterion after)
-
-## Tool Selection Rules
+## Rules
+- Command names are kebab-case, lowercase
+- Content should be actionable and specific to the project
+- Include shell commands (!) where appropriate for automation
+- Keep descriptions under 80 characters
+- Return ONLY the JSON array, no surrounding text`;
+function parseCommandResponse(text) {
+  let cleaned = text.trim();
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+  }
+  const arrayMatch = cleaned.match(/\[[\s\S]*\]/);
+  if (!arrayMatch) {
+    throw new Error("@command-writer: LLM response did not contain a JSON array.");
+  }
+  const parsed = JSON.parse(arrayMatch[0]);
+  if (!Array.isArray(parsed)) {
+    throw new Error("@command-writer: parsed response is not an array.");
+  }
+  return parsed.map((item) => {
+    const obj = item;
+    if (typeof obj.name !== "string" || typeof obj.content !== "string") {
+      throw new Error("@command-writer: each command must have 'name' and 'content' strings.");
+    }
+    return {
+      name: obj.name,
+      description: typeof obj.description === "string" ? obj.description : "",
+      content: obj.content
+    };
+  });
+}
+function buildUserMessage4(intent, skeleton, batchItems, phaseAContext) {
+  const lines = [];
+  lines.push("## Project Context");
+  lines.push(`Intent: ${intent}`);
+  lines.push(`Tech stack: ${skeleton.outline.tech_stack.join(", ")}`);
+  lines.push(`Workflow type: ${skeleton.outline.workflow_type}`);
+  lines.push("");
+  if (phaseAContext) {
+    lines.push("## Reference (from Phase A)");
+    lines.push(phaseAContext);
+    lines.push("");
+  }
+  lines.push("## Commands to Generate");
+  for (const item of batchItems) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+  lines.push("Generate the JSON array of command objects now.");
+  return lines.join("\n");
+}
+function chunk(arr, size) {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
+  }
+  return chunks;
+}
+function ensureHelpCommand(commands) {
+  const hasHelp = commands.some((c) => c.name === "help");
+  if (hasHelp) {
+    return commands;
+  }
+  return [
+    ...commands,
+    createCommandNode("help", DEFAULT_HELP_CONTENT2, DEFAULT_HELP_DESCRIPTION2)
+  ];
+}
+function deduplicateCommands(commands) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const cmd of commands) {
+    if (!seen.has(cmd.name)) {
+      seen.add(cmd.name);
+      result.push(cmd);
+    }
+  }
+  return result;
+}
+async function generateBatch(intent, skeleton, batchItems, config, maxTokens, phaseAContext) {
+  const userMessage = buildUserMessage4(intent, skeleton, batchItems, phaseAContext);
+  const responseText = await callLLM(config, userMessage, {
+    systemPrompt: SYSTEM_PROMPT3,
+    cacheControl: true,
+    maxTokens
+  });
+  const rawCommands = parseCommandResponse(responseText);
+  return rawCommands.map(
+    (c) => createCommandNode(c.name, c.content, c.description)
+  );
+}
+async function generateCommands(intent, skeleton, task, config) {
+  if (task.items.length === 0) {
+    return { agent: "command-writer", commands: [] };
+  }
+  let allCommands;
+  if (task.items.length > BATCH_THRESHOLD) {
+    const batches = chunk(task.items, BATCH_SIZE);
+    const batchResults = [];
+    for (const batch of batches) {
+      const nodes = await generateBatch(intent, skeleton, batch, config, task.max_tokens, task.context_hint);
+      batchResults.push(nodes);
+    }
+    allCommands = deduplicateCommands(batchResults.flat());
+  } else {
+    allCommands = await generateBatch(intent, skeleton, task.items, config, task.max_tokens, task.context_hint);
+  }
+  allCommands = ensureHelpCommand(allCommands);
+  return { agent: "command-writer", commands: allCommands };
+}
 
-- Only select tools directly relevant to the described workflow
-- Prefer free tools (auth: "none") when quality is comparable
-- Tier 1 tools (Context7, Sequential Thinking, security-guidance) should be included in most environments
-- For tools requiring API keys (auth: "api_key"), use \${ENV_VAR} syntax \u2014 never hardcode keys
-- Maximum 6-8 MCP servers to avoid context bloat
-- Include a \`reason\` for each selected tool explaining why it fits this workflow
+// src/compiler/agents/agent-writer.ts
+init_llm();
+var BATCH_THRESHOLD2 = 8;
+var BATCH_SIZE2 = 6;
+var AGENT_WRITER_SYSTEM_PROMPT = `You are an expert at designing Claude Code agent personas for the .claude/agents/ directory.
+
+Each agent file uses YAML frontmatter followed by Markdown persona content.
+
+## YAML Frontmatter Conventions
+- \`model\`: optional model hint \u2014 "opus" for complex reasoning, "sonnet" for balanced, "haiku" for fast/cheap
+- \`disallowedTools\`: optional string array of tools the agent should NOT use (e.g. ["Bash", "Write"])
+- \`modelRouting\`: optional object for dynamic model selection:
+  - \`default\`: base model tier ("haiku", "sonnet", or "opus")
+  - \`escalateTo\`: higher tier to escalate to ("sonnet" or "opus")
+  - \`escalateWhen\`: description of when to escalate
+
+## Persona Design Principles
+- Each agent has a clear, focused role (single responsibility)
+- Persona should describe expertise, approach, and boundaries
+- Include specific instructions for the agent's domain
+- Use second person ("You are...")
+- Be concrete about what the agent should and should not do
+- Include relevant workflow steps or checklists where appropriate
+
+## Model Tiering Guidelines
+- "haiku": formatting, linting, simple lookups, boilerplate generation
+- "sonnet": most development tasks, code review, testing, refactoring
+- "opus": architecture decisions, complex debugging, cross-cutting changes, security audits
 
-## Context Budget (STRICT)
+## Output Format
+Return a JSON array. Each element:
+{
+  "name": "agent-name-kebab-case",
+  "content": "You are the ... (full persona markdown)",
+  "model": "sonnet",
+  "disallowedTools": ["Bash"],
+  "modelRouting": { "default": "sonnet", "escalateTo": "opus", "escalateWhen": "cross-cutting changes" }
+}
 
-- MCP servers: maximum 6. Prefer fewer.
-- CLAUDE.md: maximum 150 lines.
-- Rules: maximum 5 files, each under 20 lines.
-- Skills: maximum 3. Only include directly relevant ones.
-- Agents: maximum 5. Orchestration pipeline (/develop) agents.
-- Commands: no limit (loaded on demand, zero context cost).
-- Hooks: maximum 4 (auto-format, block-destructive, PostCompact, plus one contextual).
+Only include model, disallowedTools, and modelRouting when they add value. Not every agent needs all fields.
 
-If the workflow doesn't clearly need a tool, DO NOT include it.
-Each MCP server costs 500-2000 tokens of context window.
+Return ONLY the JSON array, no surrounding text or code fences.`;
+function parseAgentResponse(text) {
+  let cleaned = text.trim();
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+  }
+  const arrayMatch = cleaned.match(/\[[\s\S]*\]/);
+  if (!arrayMatch) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(arrayMatch[0]);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed;
+  } catch {
+    return [];
+  }
+}
+function toAgentNode(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return null;
+  }
+  const obj = raw;
+  if (typeof obj["name"] !== "string" || !obj["name"]) {
+    return null;
+  }
+  if (typeof obj["content"] !== "string" || !obj["content"]) {
+    return null;
+  }
+  const node = {
+    name: obj["name"],
+    content: obj["content"]
+  };
+  if (typeof obj["model"] === "string" && obj["model"]) {
+    node.model = obj["model"];
+  }
+  if (Array.isArray(obj["disallowedTools"])) {
+    const tools = obj["disallowedTools"].filter(
+      (t) => typeof t === "string" && t.length > 0
+    );
+    if (tools.length > 0) {
+      node.disallowedTools = tools;
+    }
+  }
+  if (typeof obj["modelRouting"] === "object" && obj["modelRouting"] !== null) {
+    const routing = obj["modelRouting"];
+    const defaultModel = routing["default"];
+    if (defaultModel === "haiku" || defaultModel === "sonnet" || defaultModel === "opus") {
+      const modelRouting = {
+        default: defaultModel
+      };
+      const escalateTo = routing["escalateTo"];
+      if (escalateTo === "sonnet" || escalateTo === "opus") {
+        modelRouting.escalateTo = escalateTo;
+      }
+      const escalateWhen = routing["escalateWhen"];
+      if (typeof escalateWhen === "string" && escalateWhen) {
+        modelRouting.escalateWhen = escalateWhen;
+      }
+      node.modelRouting = modelRouting;
+    }
+  }
+  return node;
+}
+function buildUserMessage5(items, intent, phaseAContext) {
+  const parts = [];
+  parts.push(`## User Intent
 
-## Output Schema
+${intent}`);
+  if (phaseAContext) {
+    parts.push(`## Project Context (from Phase A)
 
-Return ONLY valid JSON matching this structure:
+${phaseAContext}`);
+  }
+  parts.push(
+    `## Agents to Generate
 
-\`\`\`json
-{
-  "name": "short-kebab-case-name",
-  "description": "One-line description of the environment",
-  "tools": [
-    { "tool_id": "id-from-registry", "reason": "why this tool fits" }
-  ],
-  "harness": {
-    "claude_md": "The full CLAUDE.md content (under 150 lines)",
-    "settings": {
-      "permissions": {
-        "allow": ["Bash(npm run *)", "Read", "Write", "Edit"],
-        "deny": ["Bash(rm -rf *)", "Bash(curl * | sh)", "Read(./.env)", "Read(./secrets/**)"]
+Create agent persona definitions for each of these agents:
+${items.map((item) => `- ${item}`).join("\n")}`
+  );
+  parts.push(
+    "Generate the JSON array now. One object per agent listed above."
+  );
+  return parts.join("\n\n");
+}
+function chunk2(arr, size) {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
+  }
+  return chunks;
+}
+async function generateAgents(intent, _skeleton, task, config) {
+  if (task.items.length === 0) {
+    return { agent: "agent-writer", agents: [] };
+  }
+  const needsBatching = task.items.length > BATCH_THRESHOLD2;
+  const batches = needsBatching ? chunk2(task.items, BATCH_SIZE2) : [task.items];
+  const allAgents = [];
+  for (const batch of batches) {
+    const userMessage = buildUserMessage5(batch, intent, task.context_hint);
+    const response = await callLLM(config, userMessage, {
+      systemPrompt: AGENT_WRITER_SYSTEM_PROMPT,
+      cacheControl: true,
+      maxTokens: task.max_tokens
+    });
+    const rawAgents = parseAgentResponse(response);
+    for (const raw of rawAgents) {
+      const node = toAgentNode(raw);
+      if (node !== null) {
+        allAgents.push(node);
       }
-    },
-    "mcp_config": {
-      "server-name": { "command": "npx", "args": ["..."], "env": {} }
-    },
-    "commands": {
-      "help": "markdown content for /project:help",
-      "develop": "markdown content for /project:develop"
-    },
-    "rules": {
-      "continuity": "markdown content for continuity rule",
-      "security": "markdown content for security rule"
-    },
-    "skills": {
-      "skill-name/SKILL": "markdown content with YAML frontmatter"
-    },
-    "agents": {
-      "architect": "agent markdown with YAML frontmatter",
-      "planner": "agent markdown with YAML frontmatter",
-      "implementer": "agent markdown with YAML frontmatter",
-      "fixer": "agent markdown with YAML frontmatter",
-      "doc-updater": "agent markdown with YAML frontmatter"
-    },
-    "docs": {
-      "DECISIONS": "# Decisions\\n\\nArchitectural decisions.",
-      "LEARNINGS": "# Learnings\\n\\nNon-obvious discoveries.",
-      "SPRINT": "# Sprint\\n\\nLiving spec and plan."
     }
   }
+  return { agent: "agent-writer", agents: allAgents };
 }
-\`\`\`
-
-Do not include any text outside the JSON object. Do not wrap in markdown code fences.`;
-var CLARIFICATION_PROMPT = `You are helping a user define their project for environment compilation.
 
-Given their initial description, generate 3-5 clarifying questions to understand:
-1. Language and framework
-2. What the project specifically does (be precise)
-3. Primary workflow (build, research, write, analyze?)
-4. Key dependencies or integrations
-5. Target audience
+// src/compiler/agents/skill-writer.ts
+init_llm();
+var SYSTEM_PROMPT4 = `You are a specialist agent that writes SKILL.md files for Claude Code environments.
 
-For each question, provide a reasonable suggestion based on the description.
+Each skill is a structured markdown document that teaches Claude Code a repeatable workflow pattern.
 
-Output ONLY a JSON array:
-[
-  { "question": "Language/framework?", "suggestion": "TypeScript + Node.js" },
-  ...
-]
+Output format: a JSON array of objects with "name" (string) and "content" (string) fields.
 
 Rules:
-- Suggestions should be reasonable guesses, clearly marked as suggestions
-- Keep questions short (under 10 words)
-- Maximum 5 questions
-- If the description is already very detailed, ask fewer questions`;
-
-// src/registry/loader.ts
-import fs3 from "fs/promises";
-import path3 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path3.dirname(__filename2);
-async function loadBundledRegistry() {
-  const candidates = [
-    path3.resolve(__dirname2, "../registry/tools.json"),
-    path3.resolve(__dirname2, "../src/registry/tools.json"),
-    path3.resolve(__dirname2, "../../src/registry/tools.json")
-  ];
-  for (const candidate of candidates) {
-    try {
-      const data = await fs3.readFile(candidate, "utf-8");
-      return JSON.parse(data);
-    } catch {
-      continue;
-    }
+- Each skill must have a clear title heading (# Skill Name)
+- Use numbered phases (## Phase 1: NAME, ## Phase 2: NAME, etc.) for multi-step workflows
+- Content should be actionable instructions, not theory
+- Keep each skill concise: 200-400 words
+- For TDD skills, always use the 3-phase pattern: RED (write failing test), GREEN (minimal implementation), REFACTOR (clean up)
+- Output ONLY the JSON array, no surrounding text
+
+Example:
+[
+  {
+    "name": "tdd",
+    "content": "# TDD Skill\\n\\n## Phase 1: RED\\nWrite a failing test first...\\n## Phase 2: GREEN\\nWrite minimal code to make the test pass...\\n## Phase 3: REFACTOR\\nClean up duplication and improve naming..."
+  }
+]`;
+function stripCodeFences2(raw) {
+  const trimmed = raw.trim();
+  const fencePattern = /^```(?:json|JSON)?\s*\n?([\s\S]*?)\n?\s*```$/;
+  const match = trimmed.match(fencePattern);
+  if (match) {
+    return match[1].trim();
   }
-  throw new Error("Could not find tools.json registry");
+  return trimmed;
 }
-async function loadUserRegistry() {
-  try {
-    const data = await fs3.readFile(getUserRegistryPath(), "utf-8");
-    return JSON.parse(data);
-  } catch {
-    return [];
+function parseSkillNodes(raw) {
+  const cleaned = stripCodeFences2(raw);
+  const parsed = JSON.parse(cleaned);
+  if (!Array.isArray(parsed)) {
+    throw new Error("Expected JSON array of skills from LLM response");
   }
+  const skills = [];
+  for (const item of parsed) {
+    if (typeof item !== "object" || item === null || typeof item.name !== "string" || typeof item.content !== "string") {
+      throw new Error(
+        "Each skill must have a string 'name' and string 'content' field"
+      );
+    }
+    skills.push({
+      name: item.name,
+      content: item.content
+    });
+  }
+  return skills;
 }
-async function saveUserRegistry(tools) {
-  await fs3.writeFile(getUserRegistryPath(), JSON.stringify(tools, null, 2), "utf-8");
-}
-async function loadRegistry() {
-  const bundled = await loadBundledRegistry();
-  const user = await loadUserRegistry();
-  if (user.length === 0) return bundled;
-  const merged = /* @__PURE__ */ new Map();
-  for (const tool of bundled) {
-    merged.set(tool.id, tool);
+async function generateSkills(_intent, _skeleton, task, config) {
+  if (task.items.length === 0) {
+    return { agent: "skill-writer", skills: [] };
   }
-  for (const tool of user) {
-    merged.set(tool.id, tool);
+  const userMessage = `Generate SKILL.md content for the following skills:
+
+${task.items.map((name) => `- ${name}`).join("\n")}`;
+  const raw = await callLLM(config, userMessage, {
+    systemPrompt: SYSTEM_PROMPT4,
+    cacheControl: true,
+    maxTokens: task.max_tokens
+  });
+  const skills = parseSkillNodes(raw);
+  return { agent: "skill-writer", skills };
+}
+
+// src/compiler/agents/dispatch.ts
+async function dispatchAgent(task, config, intent, skeleton) {
+  switch (task.agent) {
+    case "sections-writer":
+      return generateSections(intent, skeleton, task, config);
+    case "rule-writer":
+      return generateRules(intent, skeleton, task, config);
+    case "doc-writer":
+      return generateDocs(intent, skeleton, task, config);
+    case "command-writer":
+      return generateCommands(intent, skeleton, task, config);
+    case "agent-writer":
+      return generateAgents(intent, skeleton, task, config);
+    case "skill-writer":
+      return generateSkills(intent, skeleton, task, config);
+    default:
+      throw new Error(`Unknown agent: ${task.agent}`);
   }
-  return Array.from(merged.values());
 }
 
 // src/compiler/compile.ts
-init_providers();
-init_llm();
+init_renderer();
 
 // src/intent/patterns.ts
 var SYNONYM_MAP = {
@@ -5928,19 +6808,6 @@ ${registrySummary}
 
 Generate the skeleton JSON now.`;
 }
-function buildHarnessMessage(intent, skeleton, concise) {
-  const skeletonJson = JSON.stringify(skeleton, null, 2);
-  const conciseNote = concise ? "\n\nIMPORTANT: Be concise. Maximum 80 lines for claude_md. Maximum 5 commands. Keep all content brief." : "";
-  return `## User Intent
-
-${intent}
-
-## Project Skeleton
-
-${skeletonJson}
-
-Generate the harness content JSON now.${conciseNote}`;
-}
 function parseSkeletonResponse(text) {
   let cleaned = text.trim();
   if (cleaned.startsWith("```")) {
@@ -5962,29 +6829,8 @@ function parseSkeletonResponse(text) {
     );
   }
 }
-function parseHarnessResponse(text) {
-  let cleaned = text.trim();
-  if (cleaned.startsWith("```")) {
-    cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
-  }
-  const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) {
-    throw new Error("Pass 2 (harness) did not return valid JSON.");
-  }
-  try {
-    const parsed = JSON.parse(jsonMatch[0]);
-    if (!parsed.claude_md || !parsed.commands) {
-      throw new Error("Harness missing required fields: claude_md, commands");
-    }
-    return parsed;
-  } catch (err) {
-    throw new Error(
-      `Failed to parse harness JSON: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-}
 function buildSettings(skeleton, registry) {
-  const selectedTools = skeleton.tools.map((t) => registry.find((r) => r.id === t.tool_id)).filter(Boolean);
+  const _selectedTools = skeleton.tools.map((t) => registry.find((r) => r.id === t.tool_id)).filter(Boolean);
   const allow = ["Read", "Write", "Edit", "Bash(npm run *)", "Bash(npx *)"];
   const deny = [
     "Bash(rm -rf *)",
@@ -6083,50 +6929,60 @@ async function compile(intent, onProgress) {
     detail: toolNames,
     elapsed: (Date.now() - startTime) / 1e3
   });
-  onProgress?.({ phase: "pass2", status: "running", message: "Pass 2: Generating CLAUDE.md, commands, agents..." });
-  const harnessMsg = buildHarnessMessage(intent, skeleton);
-  let harness;
-  try {
-    const harnessText = await callLLM(config, harnessMsg, {
-      maxTokens: 8192,
-      systemPrompt: HARNESS_PROMPT
-    });
-    harness = parseHarnessResponse(harnessText);
-  } catch {
-    onProgress?.({ phase: "pass2-retry", status: "warning", message: "Pass 2: Response too large, retrying in concise mode..." });
-    const retryMsg = buildHarnessMessage(intent, skeleton, true);
-    const retryText = await callLLM(config, retryMsg, {
-      maxTokens: 8192,
-      systemPrompt: HARNESS_PROMPT
-    });
-    harness = parseHarnessResponse(retryText);
-  }
-  const cmdCount = Object.keys(harness.commands).length;
-  const agentCount = Object.keys(harness.agents ?? {}).length;
-  const ruleCount = Object.keys(harness.rules).length;
+  onProgress?.({ phase: "plan", status: "running", message: "Pass 2: Planning compilation..." });
+  const plan = await generatePlan(intent, skeleton, config);
+  const agentCount = plan.phases.reduce((sum, p) => sum + p.agents.length, 0);
   onProgress?.({
-    phase: "pass2",
+    phase: "plan",
     status: "success",
-    message: `Pass 2: Generated ${cmdCount} commands, ${agentCount} agents, ${ruleCount} rules`,
+    message: `Pass 2: Compilation plan \u2014 ${agentCount} agents across ${plan.phases.length} phases`,
     elapsed: (Date.now() - startTime) / 1e3
   });
-  onProgress?.({ phase: "pass3", status: "running", message: "Pass 3: Configuring MCP servers & settings..." });
+  const concurrency = config.auth_type === "claude-code-oauth" ? 2 : 3;
+  const executeAgent = (task) => dispatchAgent(task, config, intent, skeleton);
+  const batchProgress = (bp) => {
+    if (bp.status === "start") {
+      const phaseLabel = bp.phaseId;
+      onProgress?.({ phase: phaseLabel, status: "running", message: `Pass 3 (${bp.phaseId}): Running ${bp.agentCount} agents...` });
+    } else if (bp.status === "complete") {
+      const phaseLabel = bp.phaseId;
+      onProgress?.({ phase: phaseLabel, status: "success", message: `Pass 3 (${bp.phaseId}): Complete`, elapsed: (Date.now() - startTime) / 1e3 });
+    }
+  };
+  const rawIR = await executePlan(plan, executeAgent, concurrency, batchProgress);
+  onProgress?.({ phase: "phase-c", status: "running", message: "Pass 3c: Cross-reference validation..." });
+  const { ir: linkedIR, report } = linkHarness(rawIR);
+  const ir = linkedIR;
+  if (report.warnings.length > 0) {
+    for (const w of report.warnings) {
+      onProgress?.({ phase: "phase-c", status: "warning", message: `\u26A0 ${w}` });
+    }
+  }
+  onProgress?.({ phase: "phase-c", status: "success", message: "Pass 3c: Cross-reference validation", elapsed: (Date.now() - startTime) / 1e3 });
+  onProgress?.({ phase: "assembly", status: "running", message: "Pass 4: Configuring MCP servers & settings..." });
   const settings = buildSettings(skeleton, registry);
   const mcpConfig = buildMcpConfig(skeleton, registry);
+  const commandsRecord = {};
+  for (const cmd of ir.commands) {
+    commandsRecord[cmd.name] = cmd.content;
+  }
+  const agentsRecord = {};
+  for (const agent of ir.agents) {
+    agentsRecord[agent.name] = agent.content;
+  }
   const projectProfile = {
     language: skeleton.outline.tech_stack[0] ?? "unknown",
     framework: skeleton.outline.tech_stack[1] ?? "none",
     scripts: {}
-    // scripts come from project scanning, not compilation
   };
   const intentPatterns = generateIntentPatterns(
-    harness.commands,
-    harness.agents ?? {},
+    commandsRecord,
+    agentsRecord,
     projectProfile
   );
   const intentPromptTemplate = compileIntentPrompt(
-    harness.commands,
-    harness.agents ?? {}
+    commandsRecord,
+    agentsRecord
   );
   const generationTimestamp = (/* @__PURE__ */ new Date()).toISOString();
   const intentHooks = {};
@@ -6134,7 +6990,27 @@ async function compile(intent, onProgress) {
     intentHooks["intent-router"] = renderIntentRouter(intentPatterns, generationTimestamp);
     intentHooks["intent-learner"] = renderIntentLearner();
   }
-  onProgress?.({ phase: "pass3", status: "success", message: "Pass 3: Configured MCP servers & settings" });
+  onProgress?.({ phase: "assembly", status: "success", message: "Pass 4: Configured MCP servers & settings" });
+  const commands = {};
+  for (const cmd of ir.commands) {
+    commands[cmd.name] = cmd.content;
+  }
+  const rules = {};
+  for (const rule of ir.rules) {
+    rules[rule.name] = rule.content;
+  }
+  const agents = {};
+  for (const agent of ir.agents) {
+    agents[agent.name] = agent.content;
+  }
+  const skills = {};
+  for (const skill of ir.skills) {
+    skills[skill.name] = skill.content;
+  }
+  const docs = {};
+  for (const doc of ir.docs) {
+    docs[doc.name] = doc.content;
+  }
   const spec = {
     id: `env_${crypto.randomUUID()}`,
     intent,
@@ -6143,15 +7019,16 @@ async function compile(intent, onProgress) {
     description: skeleton.description,
     autonomy_level: 1,
     tools: skeleton.tools,
+    ir,
     harness: {
-      claude_md: harness.claude_md,
+      claude_md: renderClaudeMd(ir.meta, ir.sections),
       settings,
       mcp_config: mcpConfig,
-      commands: harness.commands,
-      rules: harness.rules,
-      skills: harness.skills ?? {},
-      agents: harness.agents ?? {},
-      docs: harness.docs,
+      commands,
+      rules,
+      skills,
+      agents,
+      docs,
       hooks: intentHooks,
       intent_patterns: intentPatterns,
       intent_prompt_template: intentPromptTemplate
@@ -6535,6 +7412,9 @@ function applyAutonomyLevel(spec) {
   const agents = spec.harness.agents ?? {};
   const docs = spec.harness.docs ?? {};
   const settings = spec.harness.settings ?? {};
+  if (!("persistence_routing" in settings)) {
+    settings.persistence_routing = level >= 3 ? "auto" : "manual";
+  }
   if (level >= 1) {
     if (!("tour" in commands)) {
       commands.tour = TOUR_COMMAND;
@@ -6606,6 +7486,85 @@ var ENV_LOADER_HOOK = {
     command: 'if [ -f .env ] && [ -n "$CLAUDE_ENV_FILE" ]; then grep -v "^#" .env | grep -v "^$" | grep "=" >> "$CLAUDE_ENV_FILE"; fi'
   }]
 };
+var PERSIST_ROUTER_TEMPLATE = `import { readFileSync } from 'fs';
+
+const input = JSON.parse(readFileSync('/dev/stdin', 'utf8'));
+const prompt = (input.prompt ?? '').trim();
+
+// Pass-through patterns (fast exit)
+const PASSTHROUGH = /^(what|how|why|where|when|can you|does|is |show me|find |search |list |\\/project:)/i;
+const SINGLE_FILE = /^(edit|fix the typo|update the comment|change the|rename) .{3,60}$/i;
+
+if (PASSTHROUGH.test(prompt) || SINGLE_FILE.test(prompt) || prompt.length < 20) {
+  process.stdout.write(JSON.stringify({ continue: true }));
+  process.exit(0);
+}
+
+// Check config for routing mode
+let routingMode = 'auto';
+try {
+  const settings = JSON.parse(readFileSync('.claude/settings.json', 'utf8'));
+  routingMode = settings.persistence_routing ?? 'auto';
+} catch { /* default to auto */ }
+
+if (routingMode === 'off') {
+  process.stdout.write(JSON.stringify({ continue: true }));
+  process.exit(0);
+}
+
+// Complexity signals
+const signals = [];
+
+if (/\\b(then|after that|and also|next|finally|step \\d|first .* then)\\b/i.test(prompt)) {
+  signals.push('multi-step');
+}
+if (/\\b(add|implement|build|create|integrate|set up)\\b.*\\b(feature|auth|api|endpoint|page|component|module|service|database|migration)\\b/i.test(prompt)) {
+  signals.push('feature-scope');
+}
+if (/\\b(migrate|convert|replace|upgrade|refactor|rewrite|restructure)\\b/i.test(prompt)) {
+  signals.push('refactor-scope');
+}
+if (/\\b(when .* happens|steps to reproduce|broken|crash|regression|fails when)\\b/i.test(prompt)) {
+  signals.push('bug-with-repro');
+}
+if (/\\b(persist|keep working|don't stop|until done|until .* pass)\\b/i.test(prompt)) {
+  signals.push('explicit');
+}
+if (prompt.split(/\\s+/).length > 50) {
+  signals.push('long-prompt');
+}
+
+const shouldRoute = routingMode === 'manual'
+  ? signals.includes('explicit')
+  : signals.length >= 2 || signals.includes('explicit');
+
+if (shouldRoute) {
+  process.stdout.write(JSON.stringify({
+    continue: true,
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      additionalContext: [
+        'PERSISTENCE ROUTING: This task has complexity signals (' + signals.join(', ') + ').',
+        'Execute this using the /project:persist workflow:',
+        '1. Ensure acceptance criteria exist in docs/SPRINT.md (create from this prompt if needed)',
+        '2. Initialize .claude/progress.json',
+        '3. Work criterion-by-criterion until all pass',
+        '4. Run review gate before marking complete',
+      ].join('\\n'),
+    },
+  }));
+} else {
+  process.stdout.write(JSON.stringify({ continue: true }));
+}
+`;
+var PERSIST_ROUTER_HOOK = {
+  matcher: "",
+  hooks: [{
+    type: "command",
+    command: 'node "$CLAUDE_PROJECT_DIR/.claude/hooks/persist-router.mjs"',
+    timeout: 5
+  }]
+};
 function resolveSettings(spec, options) {
   const settings = spec.harness.settings;
   const base = settings && Object.keys(settings).length > 0 ? { ...settings } : {};
@@ -6619,6 +7578,13 @@ function resolveSettings(spec, options) {
     hooks.SessionStart = sessionStart;
     base.hooks = hooks;
   }
+  if (isCodeProject(spec) && (spec.autonomy_level ?? 1) >= 3) {
+    const hooks = base.hooks ?? {};
+    const userPromptSubmit = hooks.UserPromptSubmit ?? [];
+    userPromptSubmit.push(PERSIST_ROUTER_HOOK);
+    hooks.UserPromptSubmit = userPromptSubmit;
+    base.hooks = hooks;
+  }
   const hasIntentHooks = spec.harness.hooks && Object.keys(spec.harness.hooks).length > 0;
   if (hasIntentHooks) {
     const hooks = base.hooks ?? {};
@@ -6710,6 +7676,9 @@ function buildFileMap(spec, options) {
       files.set(".claude/hooks/intent-log.jsonl", "");
     }
   }
+  if (isCodeProject(spec) && (spec.autonomy_level ?? 1) >= 3) {
+    files.set(".claude/hooks/persist-router.mjs", PERSIST_ROUTER_TEMPLATE);
+  }
   return files;
 }
 async function writeEnvironment(spec, targetDir, options) {
@@ -6780,6 +7749,11 @@ async function writeEnvironment(spec, targetDir, options) {
       written.push(".claude/hooks/intent-log.jsonl");
     }
   }
+  if (isCodeProject(spec) && (spec.autonomy_level ?? 1) >= 3) {
+    const p = path5.join(claudeDir, "hooks", "persist-router.mjs");
+    await writeFile(p, PERSIST_ROUTER_TEMPLATE);
+    written.push(".claude/hooks/persist-router.mjs");
+  }
   return written;
 }
 function summarizeSpec(spec, registry) {
@@ -6802,12 +7776,20 @@ function summarizeSpec(spec, registry) {
       }
     }
   }
-  return {
-    toolCount: spec.tools.length,
+  const counts = spec.ir ? {
+    commandCount: spec.ir.commands.length,
+    ruleCount: spec.ir.rules.length,
+    skillCount: spec.ir.skills.length,
+    agentCount: spec.ir.agents.length
+  } : {
     commandCount: Object.keys(spec.harness.commands || {}).length,
     ruleCount: Object.keys(spec.harness.rules || {}).length,
     skillCount: Object.keys(spec.harness.skills || {}).length,
-    agentCount: Object.keys(spec.harness.agents || {}).length,
+    agentCount: Object.keys(spec.harness.agents || {}).length
+  };
+  return {
+    toolCount: spec.tools.length,
+    ...counts,
     pluginCommands,
     envSetup
   };
@@ -8478,14 +9460,20 @@ var EVAL_TEMPLATES = {
     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"]
+  },
+  "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"]
   }
 };
 function selectTemplatesForWorkflow(workflowType) {
   const mapping = {
-    "feature-development": ["add-feature", "test-writing", "convention-adherence", "workflow-compliance", "intent-routing"],
-    "api-building": ["add-feature", "fix-bug", "test-writing", "convention-adherence"],
-    "full-stack": ["add-feature", "fix-bug", "test-writing", "convention-adherence"],
-    "maintenance": ["fix-bug", "refactor", "test-writing", "rule-compliance"],
+    "feature-development": ["add-feature", "test-writing", "convention-adherence", "workflow-compliance", "intent-routing", "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"],
     "debugging": ["fix-bug", "test-writing", "rule-compliance"],
     "qa": ["fix-bug", "test-writing", "add-feature", "workflow-compliance"],
     "architecture": ["refactor", "test-writing", "config-change", "convention-adherence"],
@@ -8506,6 +9494,7 @@ IMPORTANT: For harness-aware templates (convention-adherence, workflow-complianc
 - convention-adherence: Task must require following specific conventions from CLAUDE.md (naming, file structure, patterns). Judge by whether output matches the conventions.
 - workflow-compliance: Task must require using project slash commands or workflow steps defined in .claude/commands/. Judge by whether the agent followed the defined workflow.
 - rule-compliance: Task must create a scenario where .claude/rules/ content is relevant. Judge by whether the agent respected all rules.
+- persistence-completion: Task MUST have 3+ acceptance criteria that require sequential implementation. The task description should be a realistic feature request \u2014 the agent must parse it into criteria. Judge by: (a) all criteria met (progress.json status: complete), (b) structured tracking used (progress.json exists with 3+ criteria), (c) tests pass, (d) review gate executed (progress.json review field present).
 
 These harness-aware tasks are critical \u2014 they test whether the .claude/ environment actually improves agent behavior.