@autonoma-ai/planner 0.1.2 → 0.1.3-canary.23ca19e

package/dist/index.js

@@ -20,13 +20,13 @@ var init_esm_shims = __esm({
 
 // src/core/context.ts
 import { readFile, writeFile } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 async function saveContext(outputDir, ctx) {
-  await writeFile(join2(outputDir, CONTEXT_FILE), JSON.stringify(ctx, null, 2), "utf-8");
+  await writeFile(join3(outputDir, CONTEXT_FILE), JSON.stringify(ctx, null, 2), "utf-8");
 }
 async function loadContext(outputDir) {
   try {
-    const raw = await readFile(join2(outputDir, CONTEXT_FILE), "utf-8");
+    const raw = await readFile(join3(outputDir, CONTEXT_FILE), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -39,9 +39,9 @@ function formatContext(ctx) {
 
 **Why they want testing:** ${ctx.testingGoal}
 
-**Critical flows to prioritize:** ${ctx.criticalFlows}
+**Critical flows (user-declared \u2014 these MUST be covered):** ${ctx.criticalFlows}
 
-Use this context to prioritize your exploration. Start with the critical flows the user mentioned, then expand to cover the rest of the application.`;
+These are flows the user explicitly said cannot break. Treat them as authoritative: every one of them must be represented faithfully in your output \u2014 never drop or downplay them. Start with these, then expand to cover the rest of the application.`;
   if (ctx.pages?.length) {
     output += `
 
@@ -150,7 +150,7 @@ function createStepLogger(agentId, maxSteps) {
   function writeSpinner(message) {
     const frame = SPINNER_FRAMES[frameIdx % SPINNER_FRAMES.length];
     frameIdx++;
-    process.stderr.write(`${CLEAR_LINE}  ${DIM}${frame} ${message}${RESET}`);
+    process.stderr.write(`${CLEAR_LINE}  ${DIM2}${frame} ${message}${RESET2}`);
     lastSpinnerLine = true;
   }
   function writePermanent(message) {
@@ -182,52 +182,52 @@ function createStepLogger(agentId, maxSteps) {
         case "write_file": {
           stats.filesWritten++;
           const path3 = String(tc.input.path ?? tc.input.file_path ?? "");
-          writePermanent(`  ${GREEN}\u270E write ${path3}${RESET}`);
+          writePermanent(`  ${GREEN}\u270E write ${path3}${RESET2}`);
           break;
         }
         case "write_test":
           stats.filesWritten++;
-          writePermanent(`  ${GREEN}\u270E test ${summary2}${RESET}`);
+          writePermanent(`  ${GREEN}\u270E test ${summary2}${RESET2}`);
           break;
         case "finish":
-          writePermanent(`  ${GREEN}${BOLD}\u2713 finish${RESET}`);
+          writePermanent(`  ${GREEN}${BOLD}\u2713 done:${RESET2} ${GREEN}${agentId}${RESET2}`);
           break;
         case "subagent":
         case "spawn_researcher":
-          writePermanent(`  ${CYAN}\u2295 subagent: ${summary2}${RESET}`);
+          writePermanent(`  ${CYAN}\u2295 subagent: ${summary2}${RESET2}`);
           break;
         default:
           writeSpinner(`${stepPrefix} \u2014 ${tc.name}${summary2 ? " " + summary2 : ""}`);
       }
     }
     for (const te of info.toolErrors) {
-      writePermanent(`  ${RED}\u2717 ${te.name}: ${te.error}${RESET}`);
+      writePermanent(`  ${RED}\u2717 ${te.name}: ${te.error}${RESET2}`);
     }
     for (const f of info.writtenFiles) {
-      writePermanent(`  ${GREEN}\u{1F4C4} wrote: ${f}${RESET}`);
+      writePermanent(`  ${GREEN}\u{1F4C4} wrote: ${f}${RESET2}`);
     }
   }
   function checkpoint(message) {
-    writePermanent(`  ${YELLOW}\u25B8 ${message}${RESET}`);
+    writePermanent(`  ${YELLOW}\u25B8 ${message}${RESET2}`);
   }
   function summary() {
     clearSpinner();
     if (stats.filesRead > 0 || stats.filesWritten > 0) {
-      console.log(`  ${DIM}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${RESET}`);
+      console.log(`  ${DIM2}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${RESET2}`);
       console.log(
-        `  ${DIM}files read: ${stats.filesRead} | files written: ${stats.filesWritten}${RESET}`
+        `  ${DIM2}files read: ${stats.filesRead} | files written: ${stats.filesWritten}${RESET2}`
       );
     }
   }
   return { log: log8, checkpoint, summary, stats };
 }
-var DIM, RESET, CYAN, GREEN, RED, YELLOW, BOLD, SPINNER_FRAMES, CLEAR_LINE;
+var DIM2, RESET2, CYAN, GREEN, RED, YELLOW, BOLD, SPINNER_FRAMES, CLEAR_LINE;
 var init_display = __esm({
   "src/core/display.ts"() {
     "use strict";
     init_esm_shims();
-    DIM = "\x1B[2m";
-    RESET = "\x1B[0m";
+    DIM2 = "\x1B[2m";
+    RESET2 = "\x1B[0m";
     CYAN = "\x1B[36m";
     GREEN = "\x1B[32m";
     RED = "\x1B[31m";
@@ -286,8 +286,8 @@ function buildStepHandler(config) {
 async function runAgent(config, prompt, extractResult) {
   const stepTimeout = config.stepTimeoutMs ?? STEP_TIMEOUT_MS;
   const modelsToTry = [config.model, ...FALLBACK_MODELS.map((id) => getModel(id))];
-  const YELLOW2 = "\x1B[33m";
-  const RESET4 = "\x1B[0m";
+  const YELLOW3 = "\x1B[33m";
+  const RESET6 = "\x1B[0m";
   for (let modelIdx = 0; modelIdx < modelsToTry.length; modelIdx++) {
     const model = modelsToTry[modelIdx];
     for (let retry = 0; retry < RETRIES_BEFORE_FALLBACK; retry++) {
@@ -312,17 +312,17 @@ async function runAgent(config, prompt, extractResult) {
         const msg = err instanceof Error ? err.message : String(err);
         const isTimeout = msg.includes("timed out") || msg.includes("timeout") || msg.includes("abort");
         if (!isTimeout) throw err;
-        console.log(`  ${YELLOW2}[${config.id}] step timed out after ${stepTimeout / 1e3}s${RESET4}`);
+        console.log(`  ${YELLOW3}[${config.id}] step timed out after ${stepTimeout / 1e3}s${RESET6}`);
         if (retry < RETRIES_BEFORE_FALLBACK - 1) {
           console.log(
-            `  ${YELLOW2}[${config.id}] retrying (${retry + 1}/${RETRIES_BEFORE_FALLBACK})...${RESET4}`
+            `  ${YELLOW3}[${config.id}] retrying (${retry + 1}/${RETRIES_BEFORE_FALLBACK})...${RESET6}`
           );
           continue;
         }
         if (modelIdx < modelsToTry.length - 1) {
           const nextModel = FALLBACK_MODELS[modelIdx];
           console.log(
-            `  ${YELLOW2}[${config.id}] ${RETRIES_BEFORE_FALLBACK} timeouts, switching to ${nextModel}${RESET4}`
+            `  ${YELLOW3}[${config.id}] ${RETRIES_BEFORE_FALLBACK} timeouts, switching to ${nextModel}${RESET6}`
           );
           break;
         }
@@ -351,7 +351,7 @@ var init_agent = __esm({
 
 // src/core/gitignore.ts
 import { readFile as readFile3 } from "fs/promises";
-import { join as join5, relative } from "path";
+import { join as join7, relative } from "path";
 import { glob } from "glob";
 async function loadGitignorePatterns(projectRoot) {
   const patterns = [
@@ -371,10 +371,10 @@ async function loadGitignorePatterns(projectRoot) {
   ];
   const matches = await glob("**/.gitignore", { cwd: projectRoot, dot: true });
   for (const match of matches) {
-    const fullPath = join5(projectRoot, match);
+    const fullPath = join7(projectRoot, match);
     try {
       const content = await readFile3(fullPath, "utf-8");
-      const prefix = relative(projectRoot, join5(projectRoot, match, ".."));
+      const prefix = relative(projectRoot, join7(projectRoot, match, ".."));
       const parsed = parseGitignore(content, prefix);
       patterns.push(...parsed);
     } catch (err) {
@@ -598,7 +598,7 @@ var init_grep = __esm({
 // src/tools/list-directory.ts
 import { readdir } from "fs/promises";
 import { stat } from "fs/promises";
-import { join as join6, relative as relative2 } from "path";
+import { join as join8, relative as relative2 } from "path";
 import { tool as tool4 } from "ai";
 import { z as z4 } from "zod";
 import { minimatch } from "minimatch";
@@ -623,7 +623,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
   const withTypes = [];
   for (const name of rawEntries) {
     try {
-      const s = await stat(join6(dirPath, name));
+      const s = await stat(join8(dirPath, name));
       withTypes.push({ name, isDir: s.isDirectory() });
     } catch {
       withTypes.push({ name, isDir: false });
@@ -643,7 +643,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
     }
     if (entry.isDir) {
       const children = await buildTree(
-        join6(dirPath, entry.name),
+        join8(dirPath, entry.name),
         maxDepth,
         currentDepth + 1,
         isIgnored,
@@ -694,7 +694,7 @@ async function buildListDirectoryTool(workingDirectory) {
         };
       }
       seen.add(cacheKey);
-      const targetDir = input.path === "." ? workingDirectory : join6(workingDirectory, input.path);
+      const targetDir = input.path === "." ? workingDirectory : join8(workingDirectory, input.path);
       try {
         const s = await stat(targetDir);
         if (!s.isDirectory()) {
@@ -800,7 +800,7 @@ import {
 import { z as z6 } from "zod";
 function buildSubagentTools(workingDirectory, onFileRead) {
   const baseReadFile = buildReadFileTool(workingDirectory);
-  const readFile18 = onFileRead ? tool6({
+  const readFile19 = onFileRead ? tool6({
     description: baseReadFile.description,
     inputSchema: baseReadFile.inputSchema,
     execute: async (input, options) => {
@@ -813,7 +813,7 @@ function buildSubagentTools(workingDirectory, onFileRead) {
     bash: buildBashTool(workingDirectory),
     glob: buildGlobTool(workingDirectory),
     grep: buildGrepTool(workingDirectory),
-    read_file: readFile18
+    read_file: readFile19
   };
 }
 function buildSubagentTool(model, workingDirectory, onHeartbeat, onFileRead) {
@@ -1091,12 +1091,12 @@ var init_notify = __esm({
 // src/core/review.ts
 import * as p2 from "@clack/prompts";
 import { access } from "fs/promises";
-import { join as join7, isAbsolute } from "path";
+import { join as join9, isAbsolute } from "path";
 import { spawn } from "child_process";
 import which from "which";
 function resolvePath(artifact, outputDir) {
   if (isAbsolute(artifact)) return artifact;
-  return join7(outputDir, artifact);
+  return join9(outputDir, artifact);
 }
 async function detectEditors() {
   if (cachedEditors) return cachedEditors;
@@ -1122,7 +1122,7 @@ async function openInEditor(files) {
   const editors = await detectEditors();
   if (editors.length === 0) {
     p2.log.warn("No editors found. Review the files manually:");
-    for (const f of files) console.log(`    ${CYAN2}${f}${RESET2}`);
+    for (const f of files) console.log(`    ${CYAN2}${f}${RESET3}`);
     return;
   }
   if (preferredEditor) {
@@ -1164,11 +1164,11 @@ async function openInEditor(files) {
 }
 async function showResults(result, options) {
   console.log("");
-  console.log(`  ${GREEN2}[${options.agentId}] Step complete.${RESET2}`);
+  console.log(`  ${GREEN2}[${options.agentId}] Step complete.${RESET3}`);
   if (result.artifacts.length === 0) {
     const knownFiles = ["AUTONOMA.md", "entity-audit.md", "scenarios.md"];
     for (const f of knownFiles) {
-      const fullPath = join7(options.outputDir, f);
+      const fullPath = join9(options.outputDir, f);
       try {
         await access(fullPath);
         result.artifacts.push(f);
@@ -1178,17 +1178,24 @@ async function showResults(result, options) {
   }
   const resolvedPaths = [];
   if (result.artifacts.length > 0) {
-    console.log(`  ${DIM2}Output files:${RESET2}`);
+    console.log(`  ${DIM3}Output files:${RESET3}`);
     for (const a of result.artifacts) {
       const fullPath = resolvePath(a, options.outputDir);
       resolvedPaths.push(fullPath);
-      console.log(`    ${CYAN2}${fullPath}${RESET2}`);
+      console.log(`    ${CYAN2}${fullPath}${RESET3}`);
     }
   }
   if (result.summary) {
     console.log(`  ${result.summary}`);
   }
   console.log("");
+  if (options.renderSummary) {
+    const rendered = await options.renderSummary();
+    if (rendered) {
+      console.log(rendered);
+      console.log("");
+    }
+  }
   if (options.reviewGuidance) {
     p2.note(options.reviewGuidance, "What to check");
   }
@@ -1226,16 +1233,16 @@ async function reviewLoop(result, options) {
     await showResults(result, options);
   }
 }
-var DIM2, CYAN2, GREEN2, RESET2, EDITORS, cachedEditors, preferredEditor;
+var DIM3, CYAN2, GREEN2, RESET3, EDITORS, cachedEditors, preferredEditor;
 var init_review = __esm({
   "src/core/review.ts"() {
     "use strict";
     init_esm_shims();
     init_notify();
-    DIM2 = "\x1B[2m";
+    DIM3 = "\x1B[2m";
     CYAN2 = "\x1B[36m";
     GREEN2 = "\x1B[32m";
-    RESET2 = "\x1B[0m";
+    RESET3 = "\x1B[0m";
     EDITORS = [
       { command: "cursor", label: "Cursor", args: (f) => f },
       { command: "code", label: "VS Code", args: (f) => f },
@@ -1339,6 +1346,7 @@ pages:
   BAD mission: "Shows analytics charts" (just restates the feature name)
 - coreReason (required when core: true): WHY breakage of this feature makes the product unusable.
 - At least one flow must have core: true
+- Any flow the user explicitly named as critical in the Project Context MUST appear as a feature in core_flows AND be marked core: true with a coreReason. Map the user's wording to the matching feature(s) \u2014 never drop a user-declared critical flow or leave it as core: false.
 - feature_count: total features identified (positive integer)
 - pages: a list of all pages discovered, with their path and brief description
 
@@ -1391,6 +1399,77 @@ After the frontmatter, include:
   }
 });
 
+// src/agents/01-kb-generator/flows.ts
+import { readFile as readFile5 } from "fs/promises";
+import { join as join10 } from "path";
+import matter from "gray-matter";
+async function parseCoreFlows(outputDir) {
+  let raw;
+  try {
+    raw = await readFile5(join10(outputDir, "AUTONOMA.md"), "utf-8");
+  } catch {
+    return [];
+  }
+  try {
+    const parsed = matter(raw);
+    const flows = parsed.data.core_flows;
+    if (!Array.isArray(flows)) return [];
+    return flows.filter((f) => !!f && typeof f === "object").map((f) => ({
+      feature: String(f.feature ?? "").trim(),
+      description: f.description != null ? String(f.description) : void 0,
+      mission: f.mission != null ? String(f.mission) : void 0,
+      core: f.core === true,
+      coreReason: f.coreReason != null ? String(f.coreReason) : void 0
+    })).filter((f) => f.feature.length > 0);
+  } catch {
+    return [];
+  }
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1).trimEnd() + "\u2026";
+}
+function pad(s, width) {
+  return s + " ".repeat(Math.max(0, width - s.length));
+}
+function renderFlowsTable(flows) {
+  if (flows.length === 0) return "";
+  const DESC_MAX = 60;
+  const NAME_MAX = 32;
+  const rows = flows.map((f, i) => ({
+    num: String(i + 1),
+    name: truncate(f.feature, NAME_MAX),
+    crit: f.core ? "core" : "normal",
+    desc: truncate((f.description ?? "").replace(/\s+/g, " ").trim(), DESC_MAX)
+  }));
+  const numW = Math.max(1, ...rows.map((r) => r.num.length));
+  const nameW = Math.max("Flow".length, ...rows.map((r) => r.name.length));
+  const critW = Math.max("Criticality".length, ...rows.map((r) => r.crit.length));
+  const coreCount = flows.filter((f) => f.core).length;
+  const header = `${BOLD2}${pad("#", numW)}  ${pad("Flow", nameW)}  ${pad("Criticality", critW)}  Description${RESET4}`;
+  const sep = `${DIM4}${"\u2500".repeat(numW + nameW + critW + DESC_MAX + 6)}${RESET4}`;
+  const body = rows.map((r) => {
+    const line = `${pad(r.num, numW)}  ${pad(r.name, nameW)}  ${pad(r.crit, critW)}  ${r.desc}`;
+    return r.crit === "core" ? `${YELLOW2}${line}${RESET4}` : line;
+  }).join("\n");
+  const caption = `${DIM4}${flows.length} flows \xB7 ${coreCount} marked core${RESET4}`;
+  return `${header}
+${sep}
+${body}
+${caption}`;
+}
+var RESET4, DIM4, YELLOW2, BOLD2;
+var init_flows = __esm({
+  "src/agents/01-kb-generator/flows.ts"() {
+    "use strict";
+    init_esm_shims();
+    RESET4 = "\x1B[0m";
+    DIM4 = "\x1B[2m";
+    YELLOW2 = "\x1B[33m";
+    BOLD2 = "\x1B[1m";
+  }
+});
+
 // src/agents/01-kb-generator/index.ts
 var kb_generator_exports = {};
 __export(kb_generator_exports, {
@@ -1398,8 +1477,8 @@ __export(kb_generator_exports, {
 });
 import { tool as tool10 } from "ai";
 import { z as z10 } from "zod";
-import { readFile as readFile5 } from "fs/promises";
-import { join as join8 } from "path";
+import { readFile as readFile6 } from "fs/promises";
+import { join as join11 } from "path";
 function buildRegisterPagesTool(tracker) {
   return tool10({
     description: "Register ALL page/route files discovered via glob. Call this ONCE after globbing for page files. The system will track which ones you've read and block finish until all are covered.",
@@ -1513,11 +1592,34 @@ Output files:
   };
   await runAgent(agentConfig, prompt, () => result);
   logger.summary();
+  const declaredCriticalFlows = input.projectContext?.criticalFlows?.trim();
+  if (result?.success && declaredCriticalFlows) {
+    const beforeSelfReview = result;
+    result = void 0;
+    const selfReviewPrompt = `Before this knowledge base is shown to the user, verify it honors the critical flows they explicitly declared.
+
+The user said these flows are critical and cannot break:
+"${declaredCriticalFlows}"
+
+Read your AUTONOMA.md output. For EACH critical flow the user named:
+- Confirm it appears as a feature in core_flows (map the user's wording to the matching feature).
+- Confirm that feature is marked core: true with a coreReason.
+
+If any declared critical flow is missing, mismatched, or left core: false, FIX AUTONOMA.md now \u2014 add the feature if it is genuinely absent, or flip core to true with a coreReason. Do not downgrade or drop anything the user declared critical.
+
+When AUTONOMA.md correctly reflects every declared critical flow, call finish.`;
+    await runAgent(agentConfig, selfReviewPrompt, () => result);
+    if (!result) result = beforeSelfReview;
+  }
   const reviewed = await reviewLoop(result, {
     agentId: "kb-generator",
     outputDir: input.outputDir,
     nonInteractive: input.nonInteractive,
-    reviewGuidance: "Check that every page/route in your app appears in core_flows.\nVerify the mission for each feature describes the ONE thing it must do correctly.\nLook for missing features or incorrectly grouped pages.\nA complex app should have 20-40 features \u2014 if you see fewer than 15, features are probably grouped too aggressively.",
+    renderSummary: async () => {
+      const flows = await parseCoreFlows(input.outputDir);
+      return flows.length ? renderFlowsTable(flows) : void 0;
+    },
+    reviewGuidance: "Check that every page/route in your app appears in core_flows.\nVerify that every flow the user named as critical in the Project Context appears in core_flows and is marked core: true with a coreReason.\nVerify the mission for each feature describes the ONE thing it must do correctly.\nLook for missing features or incorrectly grouped pages.\nA complex app should have 20-40 features \u2014 if you see fewer than 15, features are probably grouped too aggressively.",
     onFeedback: async (feedback) => {
       result = void 0;
       const feedbackPrompt = `The user reviewed your knowledge base output and has this feedback:
@@ -1532,9 +1634,9 @@ Call page_coverage to see current state. When done with changes, call finish aga
     }
   });
   if (!reviewed) {
-    const autonomaPath = join8(input.outputDir, "AUTONOMA.md");
+    const autonomaPath = join11(input.outputDir, "AUTONOMA.md");
     try {
-      await readFile5(autonomaPath, "utf-8");
+      await readFile6(autonomaPath, "utf-8");
       return {
         success: true,
         artifacts: ["AUTONOMA.md"],
@@ -1560,6 +1662,7 @@ var init_kb_generator = __esm({
     init_review();
     init_tools();
     init_prompt();
+    init_flows();
     PageTracker = class {
       registered = /* @__PURE__ */ new Set();
       read = /* @__PURE__ */ new Set();
@@ -1729,8 +1832,8 @@ var entity_audit_exports = {};
 __export(entity_audit_exports, {
   runEntityAudit: () => runEntityAudit
 });
-import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
-import { join as join9 } from "path";
+import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
+import { join as join12 } from "path";
 import { tool as tool11 } from "ai";
 import { z as z11 } from "zod";
 import { glob as glob3 } from "glob";
@@ -1859,7 +1962,7 @@ async function findPrismaSchema(projectRoot) {
   return candidates[0] ?? null;
 }
 async function extractPrismaModels(schemaPath) {
-  const content = await readFile6(schemaPath, "utf-8");
+  const content = await readFile7(schemaPath, "utf-8");
   return content.split("\n").filter((line) => line.startsWith("model ")).map((line) => line.split(/\s+/)[1]).filter((name) => name != null);
 }
 async function detectFrameworkAndModels(projectRoot) {
@@ -1941,7 +2044,7 @@ write_file already targets the output directory \u2014 use just the filename.`;
   logger.summary();
   if (!result && tracker.auditedModels.size > 0) {
     const markdown = tracker.generateAuditMarkdown();
-    const auditPath = join9(input.outputDir, "entity-audit.md");
+    const auditPath = join12(input.outputDir, "entity-audit.md");
     await writeFile4(auditPath, markdown, "utf-8");
     const cov = tracker.coverage();
     result = {
@@ -1970,9 +2073,9 @@ When done with changes, call finish again.`;
     }
   });
   if (!reviewed) {
-    const auditPath = join9(input.outputDir, "entity-audit.md");
+    const auditPath = join12(input.outputDir, "entity-audit.md");
     try {
-      await readFile6(auditPath, "utf-8");
+      await readFile7(auditPath, "utf-8");
       return {
         success: true,
         artifacts: ["entity-audit.md"],
@@ -2109,11 +2212,11 @@ ${duals.length > 0 ? duals.map((m) => `- **${m.name}** \u2014 standalone: ${m.cr
 });
 
 // src/core/parse-entity-audit.ts
-import { readFile as readFile7 } from "fs/promises";
-import { join as join10 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join13 } from "path";
 async function parseEntityNames(outputDir) {
   try {
-    const content = await readFile7(join10(outputDir, "entity-audit.md"), "utf-8");
+    const content = await readFile8(join13(outputDir, "entity-audit.md"), "utf-8");
     const names = [];
     for (const line of content.split("\n")) {
       const match = line.match(/^\s+-\s+name:\s+(.+)$/);
@@ -2196,8 +2299,8 @@ __export(scenario_recipe_exports, {
   feedbackToScenario: () => feedbackToScenario,
   runScenarioRecipe: () => runScenarioRecipe
 });
-import { readFile as readFile8 } from "fs/promises";
-import { join as join11 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join14 } from "path";
 import { tool as tool12 } from "ai";
 import { z as z12 } from "zod";
 function buildFinishTool3(requiredEntities, outputDir, onFinish) {
@@ -2211,7 +2314,7 @@ function buildFinishTool3(requiredEntities, outputDir, onFinish) {
     execute: async (input) => {
       if (requiredEntities.length > 0) {
         try {
-          const content = await readFile8(join11(outputDir, "scenarios.md"), "utf-8");
+          const content = await readFile9(join14(outputDir, "scenarios.md"), "utf-8");
           const missing = requiredEntities.filter(
             (e) => !content.includes(e)
           );
@@ -2294,9 +2397,9 @@ When done with changes, call finish again.`;
     }
   });
   if (!reviewed) {
-    const scenariosPath = join11(input.outputDir, "scenarios.md");
+    const scenariosPath = join14(input.outputDir, "scenarios.md");
     try {
-      await readFile8(scenariosPath, "utf-8");
+      await readFile9(scenariosPath, "utf-8");
       return {
         success: true,
         artifacts: ["scenarios.md"],
@@ -2349,8 +2452,8 @@ var init_scenario_recipe = __esm({
 });
 
 // src/agents/04-recipe-builder/state.ts
-import { readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
+import { join as join15 } from "path";
 function adapterKey(a) {
   return `${a.language}:${a.framework}`;
 }
@@ -2377,14 +2480,14 @@ function initialRecipeState() {
 }
 async function loadRecipeState(outputDir) {
   try {
-    const raw = await readFile9(join12(outputDir, STATE_FILE2), "utf-8");
+    const raw = await readFile10(join15(outputDir, STATE_FILE2), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 async function saveRecipeState(outputDir, state) {
-  await writeFile5(join12(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
+  await writeFile5(join15(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
 }
 var ALL_ADAPTERS, ADAPTER_HINTS, STATE_FILE2;
 var init_state = __esm({
@@ -2430,10 +2533,10 @@ var init_state = __esm({
 });
 
 // src/agents/04-recipe-builder/entity-order.ts
-import { readFile as readFile10 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join16 } from "path";
 async function parseEntityAudit(outputDir) {
-  const raw = await readFile10(join13(outputDir, "entity-audit.md"), "utf-8");
+  const raw = await readFile11(join16(outputDir, "entity-audit.md"), "utf-8");
   const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/);
   if (!fmMatch) throw new Error("entity-audit.md has no YAML frontmatter");
   const yaml = fmMatch[1];
@@ -2690,11 +2793,11 @@ When done, call finish with your findings.`;
 
 // src/core/detect-pkg-manager.ts
 import { existsSync as existsSync2 } from "fs";
-import { join as join14 } from "path";
+import { join as join17 } from "path";
 function detectPackageManager(projectRoot) {
-  if (existsSync2(join14(projectRoot, "bun.lock")) || existsSync2(join14(projectRoot, "bun.lockb"))) return "bun";
-  if (existsSync2(join14(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync2(join14(projectRoot, "yarn.lock"))) return "yarn";
+  if (existsSync2(join17(projectRoot, "bun.lock")) || existsSync2(join17(projectRoot, "bun.lockb"))) return "bun";
+  if (existsSync2(join17(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join17(projectRoot, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function installCommand(pm, ...packages) {
@@ -2724,7 +2827,7 @@ function spanReplacer(_match, cls) {
   return ANSI[mainCls] ?? "";
 }
 function htmlToAnsi(html) {
-  return html.replace(/<span class="hljs-([^"]+)">/g, spanReplacer).replace(/<\/span>/g, RESET3).replace(/&#x27;/g, "'").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"');
+  return html.replace(/<span class="hljs-([^"]+)">/g, spanReplacer).replace(/<\/span>/g, RESET5).replace(/&#x27;/g, "'").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"');
 }
 function highlightCode(code, language = "typescript") {
   try {
@@ -2738,14 +2841,14 @@ function codeNoteFormat(line) {
   if (line.includes("\x1B[")) return line;
   return highlightCode(line);
 }
-var RESET3, ANSI;
+var RESET5, ANSI;
 var init_highlight = __esm({
   "src/core/highlight.ts"() {
     "use strict";
     init_esm_shims();
-    RESET3 = "\x1B[0m";
+    RESET5 = "\x1B[0m";
     ANSI = {
-      reset: RESET3,
+      reset: RESET5,
       keyword: "\x1B[35m",
       string: "\x1B[32m",
       number: "\x1B[33m",
@@ -2770,8 +2873,8 @@ var init_highlight = __esm({
 });
 
 // src/agents/04-recipe-builder/recipe.ts
-import { readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile12, writeFile as writeFile6 } from "fs/promises";
+import { join as join18 } from "path";
 function buildSingleEntityRecipe(entityName, models, entityOrder, allEntities) {
   const chain = getEntityDependencyChain(entityName, models, entityOrder);
   const recipe = {};
@@ -2815,7 +2918,7 @@ function buildSubmittableRecipe(create, description) {
   };
 }
 async function saveRecipe(outputDir, recipe) {
-  await writeFile6(join15(outputDir, RECIPE_FILE), JSON.stringify(recipe, null, 2), "utf-8");
+  await writeFile6(join18(outputDir, RECIPE_FILE), JSON.stringify(recipe, null, 2), "utf-8");
 }
 var RECIPE_FILE;
 var init_recipe = __esm({
@@ -2875,12 +2978,15 @@ var init_http_client = __esm({
 
 // src/agents/04-recipe-builder/phases/entity-loop.ts
 import * as p4 from "@clack/prompts";
-import { writeFile as writeFile7, readFile as readFile12 } from "fs/promises";
-import { join as join16 } from "path";
+import { writeFile as writeFile7, readFile as readFile13 } from "fs/promises";
+import { join as join19 } from "path";
 import { tmpdir } from "os";
 import { spawn as spawn2 } from "child_process";
 import { tool as tool14 } from "ai";
 import { z as z14 } from "zod";
+function summarizeCompletedAliases(completedEntities, excludeName) {
+  return Object.entries(completedEntities).filter(([name, e]) => name !== excludeName && e.recipeData && e.recipeData.length > 0).map(([name, e]) => `${name}: aliases ${e.recipeData.map((r) => r._alias ?? "?").join(", ")}`).join("\n");
+}
 async function proposeRecipeData(entityName, entityIndex, totalEntities, model, outputDir, _projectRoot, completedEntities) {
   let result;
   const { logger, onStepFinish } = buildDefaultStepLogger(`propose:${entityName}`, 20);
@@ -2894,7 +3000,7 @@ async function proposeRecipeData(entityName, entityIndex, totalEntities, model,
       return { accepted: true };
     }
   });
-  const completedAliases = Object.entries(completedEntities).filter(([, e]) => e.recipeData && e.recipeData.length > 0).map(([name, e]) => `${name}: aliases ${e.recipeData.map((r) => r._alias ?? "?").join(", ")}`).join("\n");
+  const completedAliases = summarizeCompletedAliases(completedEntities, entityName);
   const prompt = `[${entityIndex + 1}/${totalEntities}] Propose recipe data for entity "${entityName}".
 
 Read scenarios.md and entity-audit.md from the output directory. Design records that match the scenario data.
@@ -2924,7 +3030,7 @@ Call finish with the JSON array of records.`;
   logger.summary();
   return result ?? [];
 }
-async function reviseRecipeData(entityName, entityIndex, totalEntities, current, feedback, model, outputDir) {
+async function reviseRecipeData(entityName, entityIndex, totalEntities, current, feedback, model, outputDir, completedEntities) {
   let revised;
   const finishTool = tool14({
     description: "Submit the fixed recipe data.",
@@ -2937,14 +3043,19 @@ async function reviseRecipeData(entityName, entityIndex, totalEntities, current,
     }
   });
   const { logger, onStepFinish } = buildDefaultStepLogger(`fix:${entityName}`, 15);
+  const completedAliases = summarizeCompletedAliases(completedEntities, entityName);
+  const aliasBlock = completedAliases ? `Aliases declared by already-created parent entities (these are the ONLY valid _ref targets):
+${completedAliases}
+` : `This is a root entity \u2014 it has no parent entities to _ref.
+`;
   await runAgent(
     {
       id: `fix-${entityName}`,
-      systemPrompt: `You are fixing recipe data that failed validation. Read the error, the current data, and the user's feedback. Read scenarios.md and entity-audit.md if needed. Fix the data and call finish.
+      systemPrompt: `You are fixing recipe data based on user feedback (or a validation failure). Read the error, the current data, and the user's feedback. Read scenarios.md and entity-audit.md if needed. Fix the data and call finish.
 
 Rules:
 - _alias fields must be unique identifiers (e.g., "card_1", "transaction_1")
-- _ref fields reference aliases from OTHER entities that were already created
+- _ref fields must reference an alias that ALREADY EXISTS on a parent entity \u2014 see the list of valid targets below. Never invent a _ref to an alias that isn't listed.
 - Read scenarios.md to verify you're using correct alias names from parent entities
 - Field names must match the entity's schema from entity-audit.md`,
       model,
@@ -2957,13 +3068,14 @@ Rules:
     },
     `[${entityIndex + 1}/${totalEntities}] Fix recipe data for "${entityName}".
 
-Current data that failed:
+Current data:
 ${JSON.stringify(current, null, 2)}
 
-Problem:
+What's wrong / what to change:
 ${feedback}
 
-Read scenarios.md and entity-audit.md to understand the correct aliases and schema. Fix the data and call finish.`,
+${aliasBlock}
+Read scenarios.md and entity-audit.md to understand the correct aliases and schema. Apply the change and call finish.`,
     () => revised
   );
   logger.summary();
@@ -3037,7 +3149,7 @@ Read the creation file from the project to understand the existing service/funct
   logger.summary();
   return result ?? "No instructions generated. Check the entity audit for creation_file and creation_function.";
 }
-async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed, model, outputDir) {
+async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed, model, outputDir, completedEntities) {
   p4.log.info(
     `Legend for recipe fields:
   _alias \u2014 Internal ID used to reference this record from other entities (e.g., { "_ref": "org_1" })
@@ -3060,7 +3172,7 @@ async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed
     if (p4.isCancel(action)) throw new Error("Recipe review cancelled");
     if (action === "keep") return proposed;
     if (action === "edit") {
-      const tmpPath = join16(tmpdir(), `autonoma-recipe-${entityName}.json`);
+      const tmpPath = join19(tmpdir(), `autonoma-recipe-${entityName}.json`);
       await writeFile7(tmpPath, JSON.stringify(proposed, null, 2), "utf-8");
       const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
       p4.log.info(`Opening ${editor}... Save and close when done.`);
@@ -3069,7 +3181,7 @@ async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed
         proc.on("close", () => resolve5());
         proc.on("error", reject);
       });
-      const edited = await readFile12(tmpPath, "utf-8");
+      const edited = await readFile13(tmpPath, "utf-8");
       try {
         proposed = JSON.parse(edited);
         p4.note(JSON.stringify(proposed, null, 2), `Updated data for ${entityName}`, { format: codeNoteFormat });
@@ -3084,43 +3196,16 @@ async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed
         placeholder: "e.g., add more records, change field values, fix references..."
       });
       if (p4.isCancel(feedback) || !feedback.trim()) continue;
-      let revised;
-      const finishTool = tool14({
-        description: "Submit revised recipe data.",
-        inputSchema: z14.object({
-          records: z14.array(z14.record(z14.string(), z14.unknown()))
-        }),
-        execute: async (input) => {
-          revised = input.records;
-          return { done: true };
-        }
-      });
-      const { logger, onStepFinish } = buildDefaultStepLogger(`revise:${entityName}`, 10);
-      await runAgent(
-        {
-          id: `revise-${entityName}`,
-          systemPrompt: "You are revising recipe data based on user feedback. Read the current data, apply the feedback, and call finish with the updated records.",
-          model,
-          maxSteps: 10,
-          tools: (_heartbeat) => ({
-            read_output: buildReadFileTool(outputDir),
-            finish: finishTool
-          }),
-          onStepFinish
-        },
-        `Current data for ${entityName}:
-${JSON.stringify(proposed, null, 2)}
-
-User feedback: "${feedback}"
-
-Revise the data and call finish.`,
-        () => revised
+      proposed = await reviseRecipeData(
+        entityName,
+        entityIndex,
+        totalEntities,
+        proposed,
+        feedback.trim(),
+        model,
+        outputDir,
+        completedEntities
       );
-      logger.summary();
-      if (revised) {
-        proposed = revised;
-        p4.note(JSON.stringify(proposed, null, 2), `Revised data for ${entityName}`, { format: codeNoteFormat });
-      }
     }
   }
 }
@@ -3247,7 +3332,7 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
       );
     }
     if (!nonInteractive) {
-      recipeData = await reviewRecipeData(entityName, i, total, recipeData, model, outputDir);
+      recipeData = await reviewRecipeData(entityName, i, total, recipeData, model, outputDir, state.entities);
     }
     state.entities[entityName] = {
       entityName,
@@ -3270,20 +3355,21 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
         projectRoot,
         outputDir
       );
-      p4.note(instructions, `Implementation guide for ${entityName}`, { format: codeNoteFormat });
       const DOCS_BASE2 = "https://docs.agent.autonoma.app";
       p4.log.info(
-        `Copy the instructions above into Claude Code or your AI coding assistant.
-  They can implement the factory directly in your codebase.
-
-  Autonoma SDK docs: ${DOCS_BASE2}/sdk/environment-factory`
+        `Next: implement the ${entityName} factory. The block below is a copy-paste guide \u2014
+  paste it into Claude Code (or your AI assistant) and it will write the factory in your codebase.
+  A factory teaches the Autonoma SDK how to create and tear down ${entityName} records using your app's own code.
+  Keep it local for now: implement it, run your app on localhost, and we'll test it live here. You deploy later.`
       );
+      p4.note(instructions, `Implementation guide for ${entityName} (paste into your AI assistant)`, { format: codeNoteFormat });
+      p4.log.info(`Autonoma SDK docs: ${DOCS_BASE2}/sdk/environment-factory`);
       if (i === 0) {
-        p4.log.info("This is your first factory \u2014 the instructions include one-time SDK setup. Subsequent entities will only need the factory function.");
+        p4.log.info("This is your first factory \u2014 the guide includes one-time SDK setup. Later entities only need the factory function.");
       }
       notify("Autonoma", `${entityName} \u2014 implementation ready, waiting for you`);
       const ready = await p4.confirm({
-        message: `[${i + 1}/${total}] Is your server running with the ${entityName} factory?`
+        message: `[${i + 1}/${total}] Is your app running locally with the ${entityName} factory wired up?`
       });
       if (p4.isCancel(ready)) throw new Error("Entity loop cancelled");
       if (!ready) {
@@ -3299,7 +3385,7 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
         state.sharedSecret = secret;
         await saveRecipeState(outputDir, state);
         await writeFile7(
-          join16(outputDir, "autonoma-config.json"),
+          join19(outputDir, "autonoma-config.json"),
           JSON.stringify({ sharedSecret: secret, endpointUrl: state.sdkEndpointUrl }, null, 2),
           "utf-8"
         );
@@ -3310,7 +3396,7 @@ Add this to your server's .env file and restart it.
 This is a 64-character hex key used for HMAC-SHA256 request signing.
 The same value must be set in both your server and the Autonoma dashboard.
 
-Saved to: ${join16(outputDir, "autonoma-config.json")}`,
+Saved to: ${join19(outputDir, "autonoma-config.json")}`,
           "Shared secret generated"
         );
         const secretReady = await p4.confirm({
@@ -3332,7 +3418,7 @@ Saved to: ${join16(outputDir, "autonoma-config.json")}`,
         state.sdkEndpointUrl = url.trim() || "http://localhost:3000/api/autonoma";
         await saveRecipeState(outputDir, state);
         await writeFile7(
-          join16(outputDir, "autonoma-config.json"),
+          join19(outputDir, "autonoma-config.json"),
           JSON.stringify({ sharedSecret: state.sharedSecret, endpointUrl: state.sdkEndpointUrl }, null, 2),
           "utf-8"
         );
@@ -3363,7 +3449,8 @@ Saved to: ${join16(outputDir, "autonoma-config.json")}`,
             state.entities[entityName].recipeData,
             testResult.feedback,
             model,
-            outputDir
+            outputDir,
+            state.entities
           );
           state.entities[entityName].recipeData = revised;
           await saveRecipeState(outputDir, state);
@@ -3423,7 +3510,79 @@ When done, call finish with the instructions text.`;
 
 // src/agents/04-recipe-builder/phases/full-validation.ts
 import * as p5 from "@clack/prompts";
-async function runFullValidation(state, _models, outputDir) {
+import { tool as tool15 } from "ai";
+import { z as z15 } from "zod";
+async function reviseFullRecipe(current, feedback, model, outputDir, entityOrder) {
+  let revised;
+  const finishTool = tool15({
+    description: "Submit the revised full recipe: an object mapping each entity name to its array of records.",
+    inputSchema: z15.object({
+      recipe: z15.record(z15.string(), z15.array(z15.record(z15.string(), z15.unknown())))
+    }),
+    execute: async (input) => {
+      revised = input.recipe;
+      return { done: true };
+    }
+  });
+  const { logger, onStepFinish } = buildDefaultStepLogger("revise:full-recipe", 20);
+  await runAgent(
+    {
+      id: "revise-full-recipe",
+      systemPrompt: `You are revising a full test-data recipe based on user feedback after they reviewed the app populated with this data.
+
+The recipe is an object mapping entity names to arrays of records. Records use:
+- _alias: a unique id for a record so other records can point to it
+- _ref: { "_ref": "alias" } points to a parent record's _alias
+
+Rules:
+- Apply the user's feedback across whatever entities it touches.
+- Keep _ref values pointing to aliases that actually exist in the recipe. Never invent a _ref to a missing alias.
+- Entities are created in this order (parents first): ${entityOrder.join(" \u2192 ")}. A record may only _ref an alias declared by an entity earlier in that order.
+- Field names/types must match the schema in entity-audit.md.
+- Read scenarios.md and entity-audit.md from the output directory as needed.
+
+Return the COMPLETE revised recipe (all entities, not just the changed ones) via finish.`,
+      model,
+      maxSteps: 20,
+      tools: (_heartbeat) => ({
+        read_output: buildReadFileTool(outputDir),
+        finish: finishTool
+      }),
+      onStepFinish
+    },
+    `The user reviewed the app with this test data and said it doesn't look right.
+
+Current full recipe:
+${JSON.stringify(current, null, 2)}
+
+User feedback:
+"${feedback}"
+
+Revise the recipe to address the feedback, then call finish with the complete updated recipe.`,
+    () => revised
+  );
+  logger.summary();
+  return revised;
+}
+async function teardown(sdkConfig, refsToken, successMessage) {
+  if (!refsToken) return true;
+  p5.log.step("[Full validation] Tearing down all entities...");
+  let downResult;
+  try {
+    downResult = await down(sdkConfig, refsToken);
+  } catch (err) {
+    p5.log.error(`Full DOWN request failed: ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+  if (!downResult.ok) {
+    p5.log.error(`Full DOWN failed (HTTP ${downResult.status}):`);
+    console.log(JSON.stringify(downResult.body, null, 2));
+    return false;
+  }
+  p5.log.success(successMessage);
+  return true;
+}
+async function runFullValidation(state, _models, outputDir, model) {
   const total = state.entityOrder.length;
   p5.log.info(
     `All individual factories work. Now let's create EVERYTHING together and verify the app looks right with a full dataset. This is the recipe that will run before every test execution.`
@@ -3442,7 +3601,7 @@ async function runFullValidation(state, _models, outputDir) {
     endpointUrl: state.sdkEndpointUrl,
     sharedSecret: state.sharedSecret ?? ""
   };
-  const fullRecipe = buildFullRecipe(state.entityOrder, state.entities);
+  let fullRecipe = buildFullRecipe(state.entityOrder, state.entities);
   while (true) {
     const testRunId = `full-${Date.now()}`;
     p5.log.step(`[Full validation] Creating all ${total} entities...`);
@@ -3500,26 +3659,35 @@ async function runFullValidation(state, _models, outputDir) {
       message: "Does the app look right with the test data?"
     });
     if (p5.isCancel(looksGood)) throw new Error("Cancelled");
-    if (!looksGood) {
-      p5.log.info("You can adjust the recipe by editing recipe.json or re-running individual entities with --resume.");
+    const torndown = await teardown(
+      sdkConfig,
+      refsToken,
+      looksGood ? "Full lifecycle works. All data was created and torn down cleanly." : "Tore down the test data so we can regenerate it."
+    );
+    if (!torndown) return false;
+    if (looksGood) return true;
+    const feedback = await p5.text({
+      message: "What's wrong with the test data? Describe what to change.",
+      placeholder: "e.g. accounts need realistic balances, transactions should reference the right account..."
+    });
+    if (p5.isCancel(feedback) || !feedback.trim()) {
+      p5.log.info("No feedback given. You can edit recipe.json manually and re-run with --resume.");
+      return false;
     }
-    if (refsToken) {
-      p5.log.step("[Full validation] Tearing down all entities...");
-      let downResult;
-      try {
-        downResult = await down(sdkConfig, refsToken);
-      } catch (err) {
-        p5.log.error(`Full DOWN request failed: ${err instanceof Error ? err.message : String(err)}`);
-        return false;
-      }
-      if (!downResult.ok) {
-        p5.log.error(`Full DOWN failed (HTTP ${downResult.status}):`);
-        console.log(JSON.stringify(downResult.body, null, 2));
-        return false;
+    p5.log.info("Revising the full recipe based on your feedback...");
+    const revised = await reviseFullRecipe(fullRecipe, feedback.trim(), model, outputDir, state.entityOrder);
+    if (!revised) {
+      p5.log.warn("Couldn't revise automatically. Edit recipe.json manually and re-run with --resume.");
+      return false;
+    }
+    for (const [name, records] of Object.entries(revised)) {
+      if (state.entities[name]) {
+        state.entities[name].recipeData = records;
       }
-      p5.log.success("Full lifecycle works. All data was created and torn down cleanly.");
     }
-    return true;
+    await saveRecipeState(outputDir, state);
+    fullRecipe = buildFullRecipe(state.entityOrder, state.entities);
+    p5.note(JSON.stringify(fullRecipe, null, 2), "Revised recipe \u2014 re-running full validation", { format: codeNoteFormat });
   }
 }
 var init_full_validation = __esm({
@@ -3527,6 +3695,9 @@ var init_full_validation = __esm({
     "use strict";
     init_esm_shims();
     init_notify();
+    init_agent();
+    init_tools();
+    init_highlight();
     init_state();
     init_recipe();
     init_http_client();
@@ -3632,7 +3803,7 @@ async function runRecipeBuilder(input) {
     }
   }
   if (state.phase === "full-validation") {
-    const success = await runFullValidation(state, models, input.outputDir);
+    const success = await runFullValidation(state, models, input.outputDir, model);
     if (success) {
       state.phase = "submit";
       await saveRecipeState(input.outputDir, state);
@@ -3682,22 +3853,22 @@ var init_recipe_builder = __esm({
 });
 
 // src/agents/05-test-generator/rubrics.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var dimensionResultSchema, structuralIntentRubric, flowCompletenessRubric, uiTextRubric, dataAccuracyRubric, ALL_RUBRICS;
 var init_rubrics = __esm({
   "src/agents/05-test-generator/rubrics.ts"() {
     "use strict";
     init_esm_shims();
-    dimensionResultSchema = z15.object({
-      pass: z15.boolean(),
-      evidence: z15.string().describe("What you checked and found \u2014 cite file paths, line content, or specific strings"),
-      suggestion: z15.string().optional().describe("What the planner agent should fix, if failing")
+    dimensionResultSchema = z16.object({
+      pass: z16.boolean(),
+      evidence: z16.string().describe("What you checked and found \u2014 cite file paths, line content, or specific strings"),
+      suggestion: z16.string().optional().describe("What the planner agent should fix, if failing")
     });
     structuralIntentRubric = {
       name: "structural-intent",
       maxSteps: 8,
       dimensions: ["structuralValidity", "intentQuality", "missionAlignment"],
-      resultSchema: z15.object({
+      resultSchema: z16.object({
         structuralValidity: dimensionResultSchema.describe(
           "Are all step verbs valid (click/type/scroll/assert/hover/drag/read/refresh)? Are asserts visual-only (no URLs, network, console)? No code selectors? No login steps?"
         ),
@@ -3738,7 +3909,7 @@ When done reviewing, call finish with your structured evaluation.`
       name: "flow-completeness",
       maxSteps: 12,
       dimensions: ["actionCompletion", "mutationVerification"],
-      resultSchema: z15.object({
+      resultSchema: z16.object({
         actionCompletion: dimensionResultSchema.describe(
           "Does the test complete a core action and reach an OUTCOME? Not just opening a modal or clicking a tab."
         ),
@@ -3774,7 +3945,7 @@ When done reviewing, call finish with your structured evaluation.`
       name: "ui-text",
       maxSteps: 20,
       dimensions: ["uiTextAuthenticity"],
-      resultSchema: z15.object({
+      resultSchema: z16.object({
         uiTextAuthenticity: dimensionResultSchema.describe(
           "Do all quoted strings in steps reference text a human would actually see on screen? Not translation keys, config paths, component names, enum identifiers, or CSS classes."
         )
@@ -3813,7 +3984,7 @@ When done reviewing, call finish with your structured evaluation.`
       name: "data-accuracy",
       maxSteps: 20,
       dimensions: ["dataAccuracy"],
-      resultSchema: z15.object({
+      resultSchema: z16.object({
         dataAccuracy: dimensionResultSchema.describe(
           "Do the referenced UI elements (buttons, labels, fields, headings, toasts) actually exist in the source code for this page? Are default states correct? Does all test data (names, values, entities) come from the scenario data \u2014 NOT from other tests?"
         )
@@ -3866,12 +4037,12 @@ When done reviewing, call finish with your structured evaluation.`
 // src/agents/05-test-generator/review-pass.ts
 import { basename } from "path";
 import "ai";
-import { tool as tool15 } from "ai";
+import { tool as tool16 } from "ai";
 async function runReviewPass(testContent, testPath, rubric, projectRoot, model, scenarioData) {
   let result;
   const agentLabel = `review:${rubric.name}:${basename(testPath)}`;
   const { onStepFinish } = buildDefaultStepLogger(agentLabel, rubric.maxSteps);
-  const finishTool = tool15({
+  const finishTool = tool16({
     description: "Submit your structured review. Every dimension must have evidence from your investigation.",
     inputSchema: rubric.resultSchema,
     execute: async (input) => {
@@ -3928,8 +4099,8 @@ var init_review_pass = __esm({
 });
 
 // src/agents/05-test-generator/review.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join17, relative as relative5, basename as basename2 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join20, relative as relative5, basename as basename2 } from "path";
 import { glob as glob4 } from "glob";
 import "ai";
 async function reviewSingleTest(testContent, testPath, projectRoot, model, scenarioData) {
@@ -3956,19 +4127,19 @@ async function reviewSingleTest(testContent, testPath, projectRoot, model, scena
   return merged;
 }
 async function runConsolidatedReview(outputDir, projectRoot, model) {
-  const testsDir = join17(outputDir, "qa-tests");
+  const testsDir = join20(outputDir, "qa-tests");
   const logger = createStepLogger("review", 5);
   let scenarioData;
   try {
-    scenarioData = await readFile13(join17(outputDir, "scenarios.md"), "utf-8");
+    scenarioData = await readFile14(join20(outputDir, "scenarios.md"), "utf-8");
   } catch {
   }
-  const testFiles = await glob4(join17(testsDir, "**/*.md"));
+  const testFiles = await glob4(join20(testsDir, "**/*.md"));
   const tests = [];
   for (const testPath of testFiles) {
     if (basename2(testPath) === "INDEX.md") continue;
     if (testPath.includes("/_invalid/")) continue;
-    const content = await readFile13(testPath, "utf-8");
+    const content = await readFile14(testPath, "utf-8");
     const flowMatch = content.match(/^---\n[\s\S]*?flow:\s*["']?([^"'\n]+)["']?\s*\n[\s\S]*?---/m);
     tests.push({
       path: testPath,
@@ -4045,16 +4216,16 @@ var init_review2 = __esm({
 });
 
 // src/agents/05-test-generator/graph.ts
-import { readFile as readFile14, writeFile as writeFile8 } from "fs/promises";
-import { join as join18 } from "path";
+import { readFile as readFile15, writeFile as writeFile8 } from "fs/promises";
+import { join as join21 } from "path";
 async function saveBfsState(outputDir, state) {
-  const path3 = join18(outputDir, STATE_FILE3);
+  const path3 = join21(outputDir, STATE_FILE3);
   await writeFile8(path3, JSON.stringify(state.serialize(), null, 2), "utf-8");
 }
 async function loadBfsState(outputDir) {
-  const path3 = join18(outputDir, STATE_FILE3);
+  const path3 = join21(outputDir, STATE_FILE3);
   try {
-    const raw = await readFile14(path3, "utf-8");
+    const raw = await readFile15(path3, "utf-8");
     return CoverageState.deserialize(JSON.parse(raw));
   } catch {
     return null;
@@ -4146,17 +4317,17 @@ var init_graph = __esm({
 });
 
 // src/agents/00b-feature-discovery/index.ts
-import { readFile as readFile15, writeFile as writeFile9 } from "fs/promises";
-import { join as join19 } from "path";
-import { z as z16 } from "zod";
-import { tool as tool16 } from "ai";
+import { readFile as readFile16, writeFile as writeFile9 } from "fs/promises";
+import { join as join22 } from "path";
+import { z as z17 } from "zod";
+import { tool as tool17 } from "ai";
 async function saveFeatures(outputDir, features) {
   const obj = Object.fromEntries(features);
-  await writeFile9(join19(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile9(join22(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadFeatures(outputDir) {
   try {
-    const raw = await readFile15(join19(outputDir, FEATURES_FILE), "utf-8");
+    const raw = await readFile16(join22(outputDir, FEATURES_FILE), "utf-8");
     const obj = JSON.parse(raw);
     return new Map(Object.entries(obj));
   } catch {
@@ -4187,10 +4358,10 @@ Process every page. Call add_feature for each sub-feature you discover. When don
       const tools = await buildCodebaseTools(model, input.projectRoot, input.outputDir, heartbeat);
       return {
         ...tools,
-        add_feature: tool16({
+        add_feature: tool17({
           description: "Add a discovered sub-feature",
           inputSchema: Feature.extend({
-            id: z16.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
+            id: z17.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
           }),
           execute: (featureInput) => {
             const { id, ...rest } = featureInput;
@@ -4202,19 +4373,19 @@ Process every page. Call add_feature for each sub-feature you discover. When don
             return `Feature "${id}" added (${collector.features.size} total)`;
           }
         }),
-        view_features: tool16({
+        view_features: tool17({
           description: "View all discovered features so far",
-          inputSchema: z16.object({}),
+          inputSchema: z17.object({}),
           execute: () => collector.viewFeatures()
         }),
-        view_pages: tool16({
+        view_pages: tool17({
           description: "View the pages list to know what to analyze",
-          inputSchema: z16.object({}),
+          inputSchema: z17.object({}),
           execute: () => pagesDescription
         }),
-        finish: tool16({
+        finish: tool17({
           description: "Signal that feature discovery is complete",
-          inputSchema: z16.object({ summary: z16.string() }),
+          inputSchema: z17.object({ summary: z17.string() }),
           execute: async (finishInput) => {
             result = {
               success: true,
@@ -4245,13 +4416,13 @@ var init_b_feature_discovery = __esm({
     init_model();
     init_tools();
     FEATURES_FILE = "features.json";
-    Feature = z16.object({
-      name: z16.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
-      type: z16.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
-      parentPagePath: z16.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
-      sourceFiles: z16.array(z16.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
-      interactiveElements: z16.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
-      description: z16.string().min(10).describe("What this sub-feature does")
+    Feature = z17.object({
+      name: z17.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
+      type: z17.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
+      parentPagePath: z17.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
+      sourceFiles: z17.array(z17.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
+      interactiveElements: z17.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
+      description: z17.string().min(10).describe("What this sub-feature does")
     });
     FeatureCollector = class {
       features = /* @__PURE__ */ new Map();
@@ -4332,14 +4503,14 @@ Use kebab-case IDs that indicate the parent page and feature type:
 });
 
 // src/agents/05-test-generator/validation.ts
-import matter from "gray-matter";
+import matter2 from "gray-matter";
 function validateTestContent(content) {
   const errors = [];
   if (!/^---\n[\s\S]*?\n---/.test(content)) {
     errors.push("Missing frontmatter");
   } else {
     try {
-      const { data } = matter(content);
+      const { data } = matter2(content);
       if (!data.verification || typeof data.verification !== "string" || data.verification.length < 20) {
         errors.push("Missing or insufficient 'verification' field in frontmatter \u2014 must describe WHERE to navigate and WHAT to assert at the source of truth");
       }
@@ -4394,18 +4565,18 @@ var init_validation = __esm({
 
 // src/agents/05-test-generator/tools.ts
 import { mkdir as mkdir3, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname2, join as join20 } from "path";
-import { hasToolCall as hasToolCall3, stepCountIs as stepCountIs3, tool as tool17, ToolLoopAgent as ToolLoopAgent3 } from "ai";
-import matter2 from "gray-matter";
-import { z as z17 } from "zod";
+import { dirname as dirname2, join as join23 } from "path";
+import { hasToolCall as hasToolCall3, stepCountIs as stepCountIs3, tool as tool18, ToolLoopAgent as ToolLoopAgent3 } from "ai";
+import matter3 from "gray-matter";
+import { z as z18 } from "zod";
 function buildWriteTestTool(state, outputDir) {
-  return tool17({
+  return tool18({
     description: "Write a test file to qa-tests/{folder}/{filename}.md. Validates frontmatter before writing. Returns error if frontmatter is invalid.",
-    inputSchema: z17.object({
-      folder: z17.string().describe("Subfolder name under qa-tests/"),
-      filename: z17.string().describe("File name (e.g. login-valid-credentials.md)"),
-      content: z17.string().describe("Full file content including YAML frontmatter"),
-      nodeId: z17.string().describe("The FeatureNode ID this test belongs to")
+    inputSchema: z18.object({
+      folder: z18.string().describe("Subfolder name under qa-tests/"),
+      filename: z18.string().describe("File name (e.g. login-valid-credentials.md)"),
+      content: z18.string().describe("Full file content including YAML frontmatter"),
+      nodeId: z18.string().describe("The FeatureNode ID this test belongs to")
     }),
     execute: async (input) => {
       const frontmatter = extractFrontmatter(input.content);
@@ -4454,8 +4625,8 @@ function buildWriteTestTool(state, outputDir) {
           };
         }
       }
-      const relPath = join20("qa-tests", input.folder, input.filename);
-      const absPath = join20(outputDir, relPath);
+      const relPath = join23("qa-tests", input.folder, input.filename);
+      const absPath = join23(outputDir, relPath);
       try {
         await mkdir3(dirname2(absPath), { recursive: true });
         await writeFile10(absPath, input.content, "utf-8");
@@ -4470,16 +4641,16 @@ function buildWriteTestTool(state, outputDir) {
   });
 }
 function buildCreateFolderTool(outputDir) {
-  return tool17({
+  return tool18({
     description: "Create a folder under qa-tests/ for organizing tests.",
-    inputSchema: z17.object({
-      folder: z17.string().describe("Folder name (kebab-case)")
+    inputSchema: z18.object({
+      folder: z18.string().describe("Folder name (kebab-case)")
     }),
     execute: async (input) => {
-      const absPath = join20(outputDir, "qa-tests", input.folder);
+      const absPath = join23(outputDir, "qa-tests", input.folder);
       try {
         await mkdir3(absPath, { recursive: true });
-        return { path: join20("qa-tests", input.folder) };
+        return { path: join23("qa-tests", input.folder) };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { error: `Failed to create folder: ${message}` };
@@ -4488,9 +4659,9 @@ function buildCreateFolderTool(outputDir) {
   });
 }
 function buildNextNodeTool(state, outputDir) {
-  return tool17({
+  return tool18({
     description: "Get the next node to write tests for. If you called next_node before without writing any tests (via write_test), the previous node is auto-skipped. Returns done:true when all nodes are processed.",
-    inputSchema: z17.object({}),
+    inputSchema: z18.object({}),
     execute: async () => {
       const next = state.nextNode();
       await saveBfsState(outputDir, state);
@@ -4517,9 +4688,9 @@ function buildNextNodeTool(state, outputDir) {
   });
 }
 function buildGetProgressTool(state) {
-  return tool17({
+  return tool18({
     description: "Check how many nodes have been tested vs how many remain.",
-    inputSchema: z17.object({}),
+    inputSchema: z18.object({}),
     execute: async () => {
       const stats = state.summary();
       const nodes = [...state.nodes.values()].map((n) => ({
@@ -4533,14 +4704,14 @@ function buildGetProgressTool(state) {
   });
 }
 function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
-  return tool17({
+  return tool18({
     description: "Spawn a research subagent to read and analyze source files without polluting your context. Use for complex sub-features where you don't want to read 20 files yourself.",
-    inputSchema: z17.object({
-      instruction: z17.string().describe("What to research \u2014 be specific about files and what to look for")
+    inputSchema: z18.object({
+      instruction: z18.string().describe("What to research \u2014 be specific about files and what to look for")
     }),
     execute: async (input) => {
-      const resultSchema2 = z17.object({
-        findings: z17.string().describe("Summary of what was found")
+      const resultSchema2 = z18.object({
+        findings: z18.string().describe("Summary of what was found")
       });
       let result;
       const subagent = new ToolLoopAgent3({
@@ -4551,7 +4722,7 @@ function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
           glob: buildGlobTool(workingDirectory),
           grep: buildGrepTool(workingDirectory),
           read_file: buildReadFileTool(workingDirectory),
-          finish: tool17({
+          finish: tool18({
             description: "Report your findings.",
             inputSchema: resultSchema2,
             execute: async (output) => {
@@ -4578,7 +4749,7 @@ function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
 }
 function extractFrontmatter(content) {
   try {
-    const { data } = matter2(content);
+    const { data } = matter3(content);
     return data && Object.keys(data).length > 0 ? data : null;
   } catch {
     return null;
@@ -4592,14 +4763,14 @@ var init_tools2 = __esm({
     init_tools();
     init_graph();
     init_validation();
-    testFrontmatterSchema = z17.object({
-      title: z17.string().min(1),
-      description: z17.string().min(1),
-      intent: z17.string().min(30, "Intent must be at least 30 characters \u2014 describe the BEHAVIOR being tested, not the steps"),
-      criticality: z17.enum(["critical", "high", "mid", "low"]),
-      scenario: z17.string().min(1),
-      flow: z17.string().min(1),
-      verification: z17.string().min(20, "Verification must describe WHERE to navigate and WHAT to assert at the source of truth \u2014 not UI acknowledgments like toasts")
+    testFrontmatterSchema = z18.object({
+      title: z18.string().min(1),
+      description: z18.string().min(1),
+      intent: z18.string().min(30, "Intent must be at least 30 characters \u2014 describe the BEHAVIOR being tested, not the steps"),
+      criticality: z18.enum(["critical", "high", "mid", "low"]),
+      scenario: z18.string().min(1),
+      flow: z18.string().min(1),
+      verification: z18.string().min(20, "Verification must describe WHERE to navigate and WHAT to assert at the source of truth \u2014 not UI acknowledgments like toasts")
     });
   }
 });
@@ -4995,10 +5166,10 @@ var test_generator_exports = {};
 __export(test_generator_exports, {
   runTestGenerator: () => runTestGenerator
 });
-import { mkdir as mkdir4, readFile as readFile16, rmdir, unlink, writeFile as writeFile11 } from "fs/promises";
-import { basename as basename3, join as join21 } from "path";
-import { tool as tool18 } from "ai";
-import { z as z18 } from "zod";
+import { mkdir as mkdir4, readFile as readFile17, rmdir, unlink, writeFile as writeFile11 } from "fs/promises";
+import { basename as basename3, join as join24 } from "path";
+import { tool as tool19 } from "ai";
+import { z as z19 } from "zod";
 import { glob as glob5 } from "glob";
 async function preseedQueue(state, projectRoot, pages, features) {
   let seeded = 0;
@@ -5046,10 +5217,10 @@ async function runTestGenerator(input) {
   const existingState = await loadBfsState(input.outputDir);
   const state = existingState ?? new CoverageState();
   let result;
-  const finishTool = tool18({
+  const finishTool = tool19({
     description: "Call when the BFS queue is empty and all routes have been explored.",
-    inputSchema: z18.object({
-      summary: z18.string().describe("Coverage summary")
+    inputSchema: z19.object({
+      summary: z19.string().describe("Coverage summary")
     }),
     execute: async (finishInput) => {
       const stats = state.summary();
@@ -5078,8 +5249,8 @@ async function runTestGenerator(input) {
   });
   let kbContext = "";
   try {
-    const autonomaMd = await readFile16(
-      join21(input.outputDir, "AUTONOMA.md"),
+    const autonomaMd = await readFile17(
+      join24(input.outputDir, "AUTONOMA.md"),
       "utf-8"
     );
     kbContext += `
@@ -5090,8 +5261,8 @@ ${autonomaMd}
   } catch {
   }
   try {
-    const scenariosMd = await readFile16(
-      join21(input.outputDir, "scenarios.md"),
+    const scenariosMd = await readFile17(
+      join24(input.outputDir, "scenarios.md"),
       "utf-8"
     );
     kbContext += `
@@ -5287,18 +5458,18 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
       console.log(`  Fix pass complete`);
     }
     const allTestFiles = await glob5(
-      join21(input.outputDir, "qa-tests", "**/*.md")
+      join24(input.outputDir, "qa-tests", "**/*.md")
     );
     let markedInvalid = 0;
     for (const testPath of allTestFiles) {
       if (basename3(testPath) === "INDEX.md") continue;
       if (testPath.includes("/_invalid/")) continue;
-      const content = await readFile16(testPath, "utf-8");
+      const content = await readFile17(testPath, "utf-8");
       const validation = validateTestContent(content);
       if (!validation.valid) {
-        const invalidDir = join21(input.outputDir, "qa-tests", "_invalid");
+        const invalidDir = join24(input.outputDir, "qa-tests", "_invalid");
         await mkdir4(invalidDir, { recursive: true });
-        const dest = join21(invalidDir, basename3(testPath));
+        const dest = join24(invalidDir, basename3(testPath));
         const annotated = `<!-- VALIDATION ERRORS: ${validation.errors.join("; ")} -->
 ${content}`;
         await writeFile11(dest, annotated, "utf-8");
@@ -5311,7 +5482,7 @@ ${content}`;
         `  ${markedInvalid} tests still invalid after review cycles \u2014 moved to _invalid/`
       );
     }
-    const dirs = await glob5(join21(input.outputDir, "qa-tests", "**/"), {
+    const dirs = await glob5(join24(input.outputDir, "qa-tests", "**/"), {
       dot: false
     });
     for (const dir of dirs.sort((a, b) => b.length - a.length)) {
@@ -5403,7 +5574,7 @@ async function generateIndex(outputDir, state) {
   for (const paths of state.testsWritten.values()) {
     for (const p9 of paths) {
       try {
-        const content2 = await readFile16(join21(outputDir, p9), "utf-8");
+        const content2 = await readFile17(join24(outputDir, p9), "utf-8");
         const critMatch = content2.match(/criticality:\s*(\w+)/);
         const critVal = critMatch?.[1] ?? "";
         if (critCounts.has(critVal))
@@ -5454,26 +5625,26 @@ ${folders.map((f) => `| ${f.name} | ${f.test_count} |`).join("\n")}
 
 ${[...testsByFolder.entries()].flatMap(([_folder, tests]) => tests.map((t) => `- \`${t}\``)).join("\n")}
 `;
-  await writeFile11(join21(outputDir, "qa-tests", "INDEX.md"), content, "utf-8");
+  await writeFile11(join24(outputDir, "qa-tests", "INDEX.md"), content, "utf-8");
 }
 async function generateJourneyTests(outputDir, model, projectRoot) {
   const logger = createStepLogger("journeys", 50);
   let autonomaMd = "";
   let scenariosMd = "";
   try {
-    autonomaMd = await readFile16(join21(outputDir, "AUTONOMA.md"), "utf-8");
+    autonomaMd = await readFile17(join24(outputDir, "AUTONOMA.md"), "utf-8");
   } catch {
   }
   try {
-    scenariosMd = await readFile16(join21(outputDir, "scenarios.md"), "utf-8");
+    scenariosMd = await readFile17(join24(outputDir, "scenarios.md"), "utf-8");
   } catch {
   }
   if (!autonomaMd) return 0;
-  const existingTests = await glob5(join21(outputDir, "qa-tests", "**/*.md"));
+  const existingTests = await glob5(join24(outputDir, "qa-tests", "**/*.md"));
   const existingTitles = [];
   for (const t of existingTests) {
     if (basename3(t) === "INDEX.md") continue;
-    const content = await readFile16(t, "utf-8");
+    const content = await readFile17(t, "utf-8");
     const titleMatch = content.match(/title:\s*"([^"]+)"/);
     if (titleMatch) existingTitles.push(titleMatch[1]);
   }
@@ -5516,9 +5687,9 @@ Write 5-8 journey tests using the write_test tool with folder "journeys". Then c
     status: "queued"
   });
   let journeyResult;
-  const journeyFinish = tool18({
+  const journeyFinish = tool19({
     description: "Signal journey generation is complete.",
-    inputSchema: z18.object({ summary: z18.string() }),
+    inputSchema: z19.object({ summary: z19.string() }),
     execute: async (finishInput) => {
       journeyResult = {
         success: true,
@@ -5578,17 +5749,90 @@ var init_test_generator = __esm({
 // src/index.ts
 init_esm_shims();
 import * as p8 from "@clack/prompts";
-import { readFile as readFile17, writeFile as writeFile12 } from "fs/promises";
-import { join as join22 } from "path";
+import { readFile as readFile18, writeFile as writeFile12 } from "fs/promises";
+import { join as join25 } from "path";
 
 // src/config.ts
 init_esm_shims();
-import { resolve, join } from "path";
-import { readFileSync } from "fs";
+import { resolve, join as join2 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/core/global-env.ts
+init_esm_shims();
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var AUTONOMA_HOME = join(homedir(), ".autonoma");
+var GLOBAL_ENV_PATH = join(AUTONOMA_HOME, ".env");
+function getGlobalEnvPath() {
+  return GLOBAL_ENV_PATH;
+}
+function parseEnvContent(content) {
+  const out = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    let value = trimmed.slice(eqIdx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function loadGlobalEnv() {
+  let content;
+  try {
+    content = readFileSync(GLOBAL_ENV_PATH, "utf-8");
+  } catch {
+    return;
+  }
+  for (const [key, value] of Object.entries(parseEnvContent(content))) {
+    if (!(key in process.env)) {
+      process.env[key] = value;
+    }
+  }
+}
+function setGlobalEnv(key, value) {
+  mkdirSync(AUTONOMA_HOME, { recursive: true });
+  let lines = [];
+  try {
+    lines = readFileSync(GLOBAL_ENV_PATH, "utf-8").split("\n");
+  } catch {
+    lines = [];
+  }
+  const serialized = `${key}=${value}`;
+  let replaced = false;
+  lines = lines.map((line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || !trimmed.includes("=")) return line;
+    const lineKey = trimmed.slice(0, trimmed.indexOf("=")).trim();
+    if (lineKey === key) {
+      replaced = true;
+      return serialized;
+    }
+    return line;
+  });
+  if (!replaced) {
+    if (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+      lines.splice(lines.length - 1, 0, serialized);
+    } else {
+      lines.push(serialized);
+    }
+  }
+  const output = lines.join("\n").replace(/\n*$/, "\n");
+  writeFileSync(GLOBAL_ENV_PATH, output, { encoding: "utf-8", mode: 384 });
+  process.env[key] = value;
+}
+
+// src/config.ts
 function loadProjectEnv(projectRoot) {
   let content;
   try {
-    content = readFileSync(join(projectRoot, ".env"), "utf-8");
+    content = readFileSync2(join2(projectRoot, ".env"), "utf-8");
   } catch {
     return;
   }
@@ -5610,6 +5854,7 @@ function loadProjectEnv(projectRoot) {
 function loadConfig(args) {
   const projectRoot = resolve(args.project ?? process.cwd());
   loadProjectEnv(projectRoot);
+  loadGlobalEnv();
   const projectSlug = args.slug ?? projectRoot.split("/").pop()?.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") ?? "default";
   return {
     projectRoot,
@@ -5632,11 +5877,11 @@ init_model();
 // src/core/output.ts
 init_esm_shims();
 import { mkdir } from "fs/promises";
-import { join as join3 } from "path";
-import { homedir } from "os";
-var AUTONOMA_HOME = join3(homedir(), ".autonoma");
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
+var AUTONOMA_HOME2 = join4(homedir2(), ".autonoma");
 function getOutputDir(projectSlug) {
-  return join3(AUTONOMA_HOME, projectSlug);
+  return join4(AUTONOMA_HOME2, projectSlug);
 }
 async function ensureOutputDir(projectSlug) {
   const dir = getOutputDir(projectSlug);
@@ -5644,10 +5889,140 @@ async function ensureOutputDir(projectSlug) {
   return dir;
 }
 
+// src/core/interrupt.ts
+init_esm_shims();
+import readline from "readline";
+import { settings } from "@clack/core";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var SHOW_CURSOR = "\x1B[?25h";
+var EXIT_HINT = `${DIM}(press Ctrl+C again to exit)${RESET}`;
+var ARM_WINDOW_MS = 3e3;
+var installed = false;
+var armed = false;
+var armTimer = null;
+var onExit = null;
+function disarm() {
+  if (armTimer) clearTimeout(armTimer);
+  armTimer = null;
+  armed = false;
+}
+function handleInterrupt() {
+  if (armed) {
+    disarm();
+    onExit?.();
+    return;
+  }
+  armed = true;
+  process.stderr.write(`
+${EXIT_HINT}
+`);
+  armTimer = setTimeout(disarm, ARM_WINDOW_MS);
+}
+function installInterruptHandler(opts) {
+  onExit = opts.onExit;
+  if (installed) return;
+  installed = true;
+  settings.aliases.delete("escape");
+  process.on("SIGINT", handleInterrupt);
+  const original = readline.createInterface.bind(readline);
+  readline.createInterface = ((...args) => {
+    const iface = original(...args);
+    iface.on("SIGINT", handleInterrupt);
+    return iface;
+  });
+}
+function restoreTerminal() {
+  try {
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  } catch {
+  }
+  process.stdout.write(SHOW_CURSOR);
+}
+
+// src/core/analytics.ts
+init_esm_shims();
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+import { randomUUID } from "crypto";
+var AUTONOMA_HOME3 = join5(homedir3(), ".autonoma");
+var DEVICE_ID_PATH = join5(AUTONOMA_HOME3, ".device-id");
+var POSTHOG_PUBLIC_KEY = "phc_mUOwUj62r8vyiisFPvXLC3G5RftETIBMnKNSHqTBdka";
+var DEFAULT_HOST = "https://us.i.posthog.com";
+function resolveKey() {
+  return (process.env.AUTONOMA_POSTHOG_KEY ?? POSTHOG_PUBLIC_KEY).trim();
+}
+function resolveHost() {
+  return (process.env.AUTONOMA_POSTHOG_HOST ?? DEFAULT_HOST).replace(/\/+$/, "");
+}
+function trackingDisabled() {
+  const v = process.env.DONT_TRACK;
+  return v === "1" || v === "true";
+}
+function getIdentity() {
+  const id = process.env.AUTONOMA_DISTINCT_ID?.trim();
+  return id && id.length > 0 ? id : void 0;
+}
+var cachedDeviceId = null;
+function getDeviceId() {
+  if (cachedDeviceId) return cachedDeviceId;
+  try {
+    cachedDeviceId = readFileSync3(DEVICE_ID_PATH, "utf-8").trim();
+    if (cachedDeviceId) return cachedDeviceId;
+  } catch {
+  }
+  cachedDeviceId = randomUUID();
+  try {
+    mkdirSync2(AUTONOMA_HOME3, { recursive: true });
+    writeFileSync2(DEVICE_ID_PATH, cachedDeviceId, { encoding: "utf-8", mode: 384 });
+  } catch {
+  }
+  return cachedDeviceId;
+}
+var enabled = null;
+function isEnabled() {
+  if (enabled === null) {
+    enabled = !trackingDisabled() && resolveKey().length > 0;
+  }
+  return enabled;
+}
+var pending = /* @__PURE__ */ new Set();
+function track(event, properties = {}) {
+  if (!isEnabled()) return;
+  const identity = getIdentity();
+  const body = JSON.stringify({
+    api_key: resolveKey(),
+    event,
+    distinct_id: identity ?? getDeviceId(),
+    properties: {
+      ...properties,
+      // Only build a person profile when we have a real identity from the app,
+      // so the CLI joins the existing funnel person instead of creating a new one.
+      $process_person_profile: identity != null,
+      cli_version: process.env.npm_package_version
+    }
+  });
+  const promise = fetch(`${resolveHost()}/capture/`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body
+  }).catch(() => {
+  }).finally(() => pending.delete(promise));
+  pending.add(promise);
+}
+async function flushAnalytics(timeoutMs = 1500) {
+  if (pending.size === 0) return;
+  await Promise.race([
+    Promise.allSettled([...pending]),
+    new Promise((resolve5) => setTimeout(resolve5, timeoutMs))
+  ]);
+}
+
 // src/core/state.ts
 init_esm_shims();
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 var STATE_FILE = ".pipeline-state.json";
 function initialState() {
   return {
@@ -5662,7 +6037,7 @@ function initialState() {
   };
 }
 async function loadState(outputDir) {
-  const path3 = join4(outputDir, STATE_FILE);
+  const path3 = join6(outputDir, STATE_FILE);
   try {
     const raw = await readFile2(path3, "utf-8");
     return JSON.parse(raw);
@@ -5671,7 +6046,7 @@ async function loadState(outputDir) {
   }
 }
 async function saveState(outputDir, state) {
-  const path3 = join4(outputDir, STATE_FILE);
+  const path3 = join6(outputDir, STATE_FILE);
   await writeFile2(path3, JSON.stringify(state, null, 2), "utf-8");
 }
 async function markStep(outputDir, state, step, status) {
@@ -5691,11 +6066,11 @@ function nextPendingStep(state) {
 var PAGES_FILE = "pages.json";
 async function savePages(outputDir, pages) {
   const obj = Object.fromEntries(pages);
-  await writeFile12(join22(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile12(join25(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadPages(outputDir) {
   try {
-    const raw = await readFile17(join22(outputDir, PAGES_FILE), "utf-8");
+    const raw = await readFile18(join25(outputDir, PAGES_FILE), "utf-8");
     const obj = JSON.parse(raw);
     return new Map(Object.entries(obj));
   } catch {
@@ -5732,12 +6107,14 @@ var STEP_INTROS = {
   kb: "Reading every page file to build a knowledge base (AUTONOMA.md). This gives the AI context about your features, flows, and UI patterns.",
   entityAudit: "Identifying every database model and tracing how each gets created \u2014 which service function, what side effects. This determines which entities need test data factories.",
   scenarioRecipe: "Designing test data scenarios with realistic values from your entity audit. The scenario defines exactly WHAT data will exist in the database during tests.",
-  recipeBuilder: "Guiding you through implementing Autonoma SDK factories for each entity. You'll implement each factory and we'll test them live (create + teardown) before moving on.",
+  recipeBuilder: "Guiding you through implementing Autonoma SDK factories for each entity. For each one we give you a copy-paste guide to hand to Claude (or your AI assistant), which implements the factory in your codebase. Work locally: run your app on localhost and we'll test each factory live (create + teardown) against it. You deploy later, once everything passes.",
   testGenerator: "Generating exhaustive E2E test cases by exploring every page and feature. Each area gets test coverage proportional to its complexity."
 };
 async function runStep(step, outputDir, state, config, projectContext, nonInteractive) {
   const label = STEP_LABELS[step];
   p8.note(STEP_INTROS[step], `Step: ${label}`);
+  const stepStartedAt = Date.now();
+  track("cli_step_started", { step });
   state = await markStep(outputDir, state, step, "running");
   if (step !== "pagesFinder" && projectContext && !projectContext.pages) {
     const pages = await loadPages(outputDir);
@@ -5837,6 +6214,11 @@ async function runStep(step, outputDir, state, config, projectContext, nonIntera
     const message = err instanceof Error ? err.message : String(err);
     p8.log.error(`Failed: ${label} \u2014 ${message}`);
   }
+  track("cli_step_completed", {
+    step,
+    status: state.steps[step],
+    duration_ms: Date.now() - stepStartedAt
+  });
   return state;
 }
 async function showStatus(outputDir) {
@@ -5849,15 +6231,33 @@ async function showStatus(outputDir) {
   }
 }
 var BANNER = `
-\x1B[36m\x1B[1m  ___        _
- / _ \\      | |
-/ /_\\ \\_   _| |_ ___  _ __   ___  _ __ ___   __ _
-|  _  | | | | __/ _ \\| '_ \\ / _ \\| '_ \` _ \\ / _\` |
-| | | | |_| | || (_) | | | | (_) | | | | | | (_| |
-\\_| |_/\\__,_|\\__\\___/|_| |_|\\___/|_| |_| |_|\\__,_|
+\x1B[36m\x1B[1m \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551
+\u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D   \u2588\u2588\u2551   \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551
+\u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D    \u255A\u2550\u255D    \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D     \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D
 \x1B[0m
 \x1B[2m  E2E Test Planner \u2014 Generate exhaustive test suites from your codebase\x1B[0m
 `;
+async function ensureOpenRouterKey(nonInteractive) {
+  if (process.env.OPENROUTER_API_KEY) return true;
+  if (nonInteractive) {
+    p8.log.error(
+      "OPENROUTER_API_KEY is not set. Set it in your environment or run interactively once to save it."
+    );
+    return false;
+  }
+  p8.log.info("You'll need an OpenRouter API key to run the planner. Get one at https://openrouter.ai/keys");
+  const key = await p8.password({
+    message: "Paste your OpenRouter API key",
+    validate: (value) => (value ?? "").trim().length === 0 ? "API key cannot be empty" : void 0
+  });
+  if (p8.isCancel(key)) return false;
+  setGlobalEnv("OPENROUTER_API_KEY", key.trim());
+  p8.log.success(`Saved your API key to ${getGlobalEnvPath()} \u2014 you won't be asked again.`);
+  return true;
+}
 async function gatherProjectContext() {
   const description = await p8.text({
     message: "What is this project? (a short description so the agent knows what it's looking at)",
@@ -5905,18 +6305,34 @@ async function main() {
   }
   console.log(BANNER);
   p8.intro("Let's generate your test suite");
+  const resumeCommand = `autonoma-planner --resume` + (args.project ? ` --project ${args.project}` : "");
+  installInterruptHandler({
+    onExit: () => {
+      track("cli_run_exited");
+      restoreTerminal();
+      console.log("");
+      p8.log.warn(`Your progress is saved. To resume, run:
+  ${resumeCommand}`);
+      void flushAnalytics().finally(() => process.exit(0));
+    }
+  });
   const config = loadConfig({
     project: args.project,
     model: args.model,
     slug: args.slug
   });
+  const nonInteractive = !!args["non-interactive"];
+  if (!await ensureOpenRouterKey(nonInteractive)) {
+    p8.log.warn("Cancelled.");
+    return;
+  }
   const modelName = config.modelId ?? process.env.OPENROUTER_MODEL ?? DEFAULT_MODEL;
   if (!args.project) {
     p8.log.info(`No --project flag passed; using current working directory.`);
   }
   p8.log.info(`Project: ${config.projectRoot}`);
   p8.log.info(`Model: ${modelName}`);
-  const nonInteractive = !!args["non-interactive"];
+  track("cli_run_started", { model: modelName, non_interactive: nonInteractive });
   const outputDir = await ensureOutputDir(config.projectSlug);
   let state = await loadState(outputDir);
   let isResuming = !!(args.resume || args.step);
@@ -5956,7 +6372,14 @@ async function main() {
     }
     await saveContext(outputDir, projectContext);
   }
-  p8.log.step(`Output: ${outputDir}`);
+  p8.note(
+    `${outputDir}
+
+All generated files (knowledge base, scenarios, recipe, tests) live here.
+It's a hidden folder in your home directory \u2014 in Finder/Explorer use "Go to folder"
+or reveal hidden files (macOS: Cmd+Shift+. ) to see it.`,
+    "Output folder"
+  );
   console.log("");
   p8.log.info(
     `Got it. I'll focus on: ${projectContext.criticalFlows}
@@ -5991,7 +6414,8 @@ async function main() {
         p8.log.error("Pipeline stopped due to failure.");
         break;
       }
-      if (i < steps.length - 1 && !nonInteractive) {
+      const skipConfirmAfter = ["pagesFinder"];
+      if (i < steps.length - 1 && !nonInteractive && !skipConfirmAfter.includes(step)) {
         const nextStep = steps[i + 1];
         const shouldContinue = await p8.confirm({
           message: `Continue to ${STEP_LABELS[nextStep]}?`
@@ -6009,10 +6433,13 @@ async function main() {
     }
     throw err;
   }
+  const stepsDone = Object.values(state.steps).filter((s) => s === "done").length;
+  track("cli_run_completed", { steps_done: stepsDone });
   p8.outro("Done");
 }
-main().catch((err) => {
+main().then(() => flushAnalytics()).catch(async (err) => {
   console.error(err);
+  await flushAnalytics();
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map