@autonoma-ai/planner 0.1.8-canary.bed7cd6 → 0.1.8

package/dist/index.js

@@ -84,9 +84,39 @@ var init_model = __esm({
   }
 });
 
+// src/core/version.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname, join as join5 } from "path";
+function resolveVersion() {
+  try {
+    const here = dirname(fileURLToPath2(import.meta.url));
+    for (const rel of ["../package.json", "../../package.json", "../../../package.json"]) {
+      try {
+        const pkg = JSON.parse(readFileSync3(join5(here, rel), "utf-8"));
+        if (pkg?.name === PACKAGE_NAME && typeof pkg.version === "string") {
+          return pkg.version;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return "unknown";
+}
+var PACKAGE_NAME, CLI_VERSION;
+var init_version = __esm({
+  "src/core/version.ts"() {
+    "use strict";
+    init_esm_shims();
+    PACKAGE_NAME = "@autonoma-ai/planner";
+    CLI_VERSION = resolveVersion();
+  }
+});
+
 // src/core/analytics.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join6 } from "path";
 import { homedir as homedir3 } from "os";
 import { randomUUID } from "crypto";
 function resolveKey() {
@@ -109,7 +139,7 @@ function getRunId() {
 function getDeviceId() {
   if (cachedDeviceId) return cachedDeviceId;
   try {
-    cachedDeviceId = readFileSync3(DEVICE_ID_PATH, "utf-8").trim();
+    cachedDeviceId = readFileSync4(DEVICE_ID_PATH, "utf-8").trim();
     if (cachedDeviceId) return cachedDeviceId;
   } catch {
   }
@@ -140,7 +170,7 @@ function track(event, 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
+      cli_version: CLI_VERSION
     }
   });
   const promise = fetch(`${resolveHost()}/capture/`, {
@@ -177,8 +207,9 @@ var init_analytics = __esm({
   "src/core/analytics.ts"() {
     "use strict";
     init_esm_shims();
-    AUTONOMA_HOME3 = join5(homedir3(), ".autonoma");
-    DEVICE_ID_PATH = join5(AUTONOMA_HOME3, ".device-id");
+    init_version();
+    AUTONOMA_HOME3 = join6(homedir3(), ".autonoma");
+    DEVICE_ID_PATH = join6(AUTONOMA_HOME3, ".device-id");
     POSTHOG_PUBLIC_KEY = "phc_mUOwUj62r8vyiisFPvXLC3G5RftETIBMnKNSHqTBdka";
     DEFAULT_HOST = "https://us.i.posthog.com";
     RUN_ID = randomUUID();
@@ -193,6 +224,9 @@ import { APICallError, RetryError, LoadAPIKeyError, InvalidPromptError, NoSuchMo
 function sleep(ms) {
   return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
+function isUserCancellation(err) {
+  return err instanceof Error && /\bcancell?ed\b/i.test(err.message);
+}
 function chainMessages(err) {
   const parts = [];
   let cur = err;
@@ -217,10 +251,16 @@ function describeKnownError(err) {
       hint: "Set a valid OPENROUTER_API_KEY (https://openrouter.ai/keys). If it's already set, the key may be revoked, empty, or have a stray space."
     };
   }
+  if (msg.includes("fewer max_tokens") || msg.includes("can only afford")) {
+    return {
+      title: "Your OpenRouter account doesn't have enough credit for this run.",
+      hint: "Add credit (even a few dollars goes a long way) at https://openrouter.ai/settings/credits, then re-run. A free balance can't cover a full request."
+    };
+  }
   if (msg.includes("insufficient") || msg.includes("credits") || msg.includes("quota") || status === 402) {
     return {
       title: "OpenRouter ran out of credits for this account.",
-      hint: "Top up your balance at https://openrouter.ai/credits, then re-run."
+      hint: "Add credit at https://openrouter.ai/settings/credits, then re-run."
     };
   }
   if (NoSuchModelError.isInstance(err) || msg.includes("not a valid model") || msg.includes("no endpoints found") || msg.includes("model not found")) {
@@ -240,7 +280,7 @@ function describeKnownError(err) {
 function supportReference(extra = {}) {
   const fields = {
     ref: getRunId(),
-    version: process.env.npm_package_version,
+    version: CLI_VERSION,
     node: process.version,
     platform: `${process.platform}-${process.arch}`,
     ...extra
@@ -286,6 +326,7 @@ var init_errors = __esm({
     "use strict";
     init_esm_shims();
     init_analytics();
+    init_version();
     AgentError = class extends Error {
       constructor(message, phase, cause) {
         super(message);
@@ -650,7 +691,7 @@ var init_agent = __esm({
 
 // src/core/gitignore.ts
 import { readFile as readFile5 } from "fs/promises";
-import { join as join9, relative as relative2 } from "path";
+import { join as join10, relative as relative2 } from "path";
 import { glob as glob2 } from "glob";
 async function loadGitignorePatterns(projectRoot) {
   const patterns = [
@@ -670,10 +711,10 @@ async function loadGitignorePatterns(projectRoot) {
   ];
   const matches = await glob2("**/.gitignore", { cwd: projectRoot, dot: true });
   for (const match of matches) {
-    const fullPath = join9(projectRoot, match);
+    const fullPath = join10(projectRoot, match);
     try {
       const content = await readFile5(fullPath, "utf-8");
-      const prefix = relative2(projectRoot, join9(projectRoot, match, ".."));
+      const prefix = relative2(projectRoot, join10(projectRoot, match, ".."));
       const parsed = parseGitignore(content, prefix);
       patterns.push(...parsed);
     } catch (err) {
@@ -897,7 +938,7 @@ var init_grep = __esm({
 // src/tools/list-directory.ts
 import { readdir } from "fs/promises";
 import { stat } from "fs/promises";
-import { join as join10, relative as relative3 } from "path";
+import { join as join11, relative as relative3 } from "path";
 import { tool as tool4 } from "ai";
 import { z as z4 } from "zod";
 import { minimatch } from "minimatch";
@@ -922,7 +963,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
   const withTypes = [];
   for (const name of rawEntries) {
     try {
-      const s = await stat(join10(dirPath, name));
+      const s = await stat(join11(dirPath, name));
       withTypes.push({ name, isDir: s.isDirectory() });
     } catch {
       withTypes.push({ name, isDir: false });
@@ -942,7 +983,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
     }
     if (entry.isDir) {
       const children = await buildTree(
-        join10(dirPath, entry.name),
+        join11(dirPath, entry.name),
         maxDepth,
         currentDepth + 1,
         isIgnored,
@@ -993,7 +1034,7 @@ async function buildListDirectoryTool(workingDirectory) {
         };
       }
       seen.add(cacheKey);
-      const targetDir = input.path === "." ? workingDirectory : join10(workingDirectory, input.path);
+      const targetDir = input.path === "." ? workingDirectory : join11(workingDirectory, input.path);
       try {
         const s = await stat(targetDir);
         if (!s.isDirectory()) {
@@ -1176,7 +1217,7 @@ Be thorough but focused - only investigate what's relevant to your instruction.`
 
 // src/tools/write-file.ts
 import { writeFile as writeFile4, mkdir as mkdir2 } from "fs/promises";
-import { dirname, relative as relative5, resolve as resolve3 } from "path";
+import { dirname as dirname2, relative as relative5, resolve as resolve3 } from "path";
 import { tool as tool7 } from "ai";
 import { z as z7 } from "zod";
 async function executeWriteFile(outputDirectory, filePath, content) {
@@ -1187,7 +1228,7 @@ async function executeWriteFile(outputDirectory, filePath, content) {
     return { error: "Cannot write files outside the output directory" };
   }
   try {
-    await mkdir2(dirname(absolutePath), { recursive: true });
+    await mkdir2(dirname2(absolutePath), { recursive: true });
     await writeFile4(absolutePath, content, "utf-8");
     return { path: relativePath, bytesWritten: content.length };
   } catch (err) {
@@ -1365,12 +1406,12 @@ var init_pages_finder = __esm({
 // src/core/review.ts
 import * as p3 from "@clack/prompts";
 import { access } from "fs/promises";
-import { join as join11, isAbsolute } from "path";
+import { join as join12, isAbsolute } from "path";
 import { spawn } from "child_process";
 import which from "which";
 function resolvePath(artifact, outputDir) {
   if (isAbsolute(artifact)) return artifact;
-  return join11(outputDir, artifact);
+  return join12(outputDir, artifact);
 }
 async function detectEditors() {
   if (cachedEditors) return cachedEditors;
@@ -1442,7 +1483,7 @@ async function showResults(result, options) {
   if (result.artifacts.length === 0) {
     const knownFiles = ["AUTONOMA.md", "entity-audit.md", "scenarios.md"];
     for (const f of knownFiles) {
-      const fullPath = join11(options.outputDir, f);
+      const fullPath = join12(options.outputDir, f);
       try {
         await access(fullPath);
         result.artifacts.push(f);
@@ -1675,12 +1716,12 @@ After the frontmatter, include:
 
 // src/agents/01-kb-generator/flows.ts
 import { readFile as readFile7 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import matter from "gray-matter";
 async function parseCoreFlows(outputDir) {
   let raw;
   try {
-    raw = await readFile7(join12(outputDir, "AUTONOMA.md"), "utf-8");
+    raw = await readFile7(join13(outputDir, "AUTONOMA.md"), "utf-8");
   } catch {
     return [];
   }
@@ -1752,7 +1793,7 @@ __export(kb_generator_exports, {
 import { tool as tool10 } from "ai";
 import { z as z10 } from "zod";
 import { readFile as readFile8 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } 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.",
@@ -1866,7 +1907,7 @@ Output files:
   };
   await runAgent(agentConfig, prompt, () => result);
   logger.summary();
-  const autonomaPath = join13(input.outputDir, "AUTONOMA.md");
+  const autonomaPath = join14(input.outputDir, "AUTONOMA.md");
   const autonomaExists = await readFile8(autonomaPath, "utf-8").then(() => true).catch(() => false);
   if (!result?.success && autonomaExists) {
     result = {
@@ -1961,12 +2002,30 @@ var init_kb_generator = __esm({
 
 // src/agents/04-recipe-builder/entity-order.ts
 import { readFile as readFile9 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
+import matter2 from "gray-matter";
+import { z as z11 } from "zod";
 async function parseEntityAudit(outputDir) {
-  const raw = await readFile9(join14(outputDir, "entity-audit.md"), "utf-8");
+  const raw = await readFile9(join15(outputDir, "entity-audit.md"), "utf-8");
+  try {
+    const parsed = frontmatterSchema.safeParse(matter2(raw).data);
+    if (parsed.success && parsed.data.models.length > 0) {
+      return parsed.data.models.map((m) => ({
+        name: m.name,
+        independently_created: m.independently_created,
+        creation_file: m.creation_file,
+        creation_function: m.creation_function,
+        side_effects: m.side_effects,
+        created_by: m.created_by
+      }));
+    }
+  } catch {
+  }
+  return parseAuditByLineScan(raw);
+}
+function parseAuditByLineScan(raw) {
   const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/);
-  if (!fmMatch) throw new Error("entity-audit.md has no YAML frontmatter");
-  const yaml = fmMatch[1];
+  const yaml = fmMatch ? fmMatch[1] : raw;
   const models = [];
   let current = null;
   let inCreatedBy = false;
@@ -2120,10 +2179,28 @@ function getEntityDependencyChain(entityName, models, entityOrder) {
   walk(entityName);
   return chain;
 }
+var createdBySchema, auditedModelSchema, frontmatterSchema;
 var init_entity_order = __esm({
   "src/agents/04-recipe-builder/entity-order.ts"() {
     "use strict";
     init_esm_shims();
+    createdBySchema = z11.object({
+      owner: z11.string(),
+      via: z11.string().optional(),
+      why: z11.string().optional()
+    });
+    auditedModelSchema = z11.object({
+      name: z11.string(),
+      independently_created: z11.coerce.boolean().default(false),
+      creation_file: z11.string().optional(),
+      creation_function: z11.string().optional(),
+      side_effects: z11.array(z11.string()).optional(),
+      // Tolerate a stray `created_by:` with no entries (parsed as null by YAML).
+      created_by: z11.array(createdBySchema).nullish().transform((v) => v ?? [])
+    });
+    frontmatterSchema = z11.object({
+      models: z11.array(auditedModelSchema).nullish().transform((v) => v ?? [])
+    });
   }
 });
 
@@ -2333,16 +2410,16 @@ __export(entity_audit_exports, {
   runEntityAudit: () => runEntityAudit
 });
 import { readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { tool as tool11 } from "ai";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 import { glob as glob4 } from "glob";
 function buildRegisterModelsTool(tracker) {
   return tool11({
     description: "Register ALL database models discovered via grep. Call this ONCE after grepping for model definitions. After registering, use next_model to process them one at a time.",
-    inputSchema: z11.object({
-      models: z11.array(z11.string()).describe("All model/table names found by grep"),
-      framework: z11.string().describe("Database framework detected (e.g. 'sqlalchemy', 'prisma', 'drizzle')")
+    inputSchema: z12.object({
+      models: z12.array(z12.string()).describe("All model/table names found by grep"),
+      framework: z12.string().describe("Database framework detected (e.g. 'sqlalchemy', 'prisma', 'drizzle')")
     }),
     execute: async (input) => {
       tracker.register(input.models);
@@ -2358,7 +2435,7 @@ function buildRegisterModelsTool(tracker) {
 function buildNextModelTool(tracker) {
   return tool11({
     description: "Get the next model to audit from the queue. If you called next_model before without calling mark_model_audited, the previous model is auto-skipped (marked as no creation path found). Returns done:true when all models are processed.",
-    inputSchema: z11.object({}),
+    inputSchema: z12.object({}),
     execute: async () => {
       const next = tracker.nextModel();
       if (!next) {
@@ -2378,16 +2455,16 @@ function buildNextModelTool(tracker) {
 function buildMarkModelAuditedTool(tracker) {
   return tool11({
     description: "Mark a model as audited after you have determined its creation paths. Call this for EACH model after reading its creation code and determining independently_created + created_by. Include creation_function (e.g. 'UserService.create'), side_effects (list of things the creation does beyond the model itself), and for each created_by entry include owner, via (function name), and why (one sentence explaining the relationship).",
-    inputSchema: z11.object({
-      model: z11.string().describe("Model name"),
-      independently_created: z11.boolean(),
-      creation_file: z11.string().optional().describe("File containing the creation function"),
-      creation_function: z11.string().optional().describe("Function/method name (e.g. 'UserService.create' or 'create_user')"),
-      side_effects: z11.array(z11.string()).optional().describe("Side effects of creation (e.g. 'creates default Settings row', 'hashes password')"),
-      created_by: z11.array(z11.object({
-        owner: z11.string().describe("Owner model name"),
-        via: z11.string().optional().describe("Function that creates this model (e.g. 'OrganizationService.create')"),
-        why: z11.string().optional().describe("One sentence explaining why this model is created as a side effect")
+    inputSchema: z12.object({
+      model: z12.string().describe("Model name"),
+      independently_created: z12.boolean(),
+      creation_file: z12.string().optional().describe("File containing the creation function"),
+      creation_function: z12.string().optional().describe("Function/method name (e.g. 'UserService.create' or 'create_user')"),
+      side_effects: z12.array(z12.string()).optional().describe("Side effects of creation (e.g. 'creates default Settings row', 'hashes password')"),
+      created_by: z12.array(z12.object({
+        owner: z12.string().describe("Owner model name"),
+        via: z12.string().optional().describe("Function that creates this model (e.g. 'OrganizationService.create')"),
+        why: z12.string().optional().describe("One sentence explaining why this model is created as a side effect")
       })).describe("List of owner models that create this as a side effect, empty array if none")
     }),
     execute: async (input) => {
@@ -2425,16 +2502,16 @@ function buildMarkModelAuditedTool(tracker) {
 function buildModelCoverageTool(tracker) {
   return tool11({
     description: "Check how many registered models you've audited vs how many remain.",
-    inputSchema: z11.object({}),
+    inputSchema: z12.object({}),
     execute: async () => tracker.coverage()
   });
 }
 function buildFinishTool2(tracker, onFinish) {
   return tool11({
     description: "Call when entity audit is complete. BLOCKED if there are unaudited models \u2014 call model_coverage first to check.",
-    inputSchema: z11.object({
-      summary: z11.string().describe("Summary of the audit"),
-      artifacts: z11.array(z11.string()).describe("Files written")
+    inputSchema: z12.object({
+      summary: z12.string().describe("Summary of the audit"),
+      artifacts: z12.array(z12.string()).describe("Files written")
     }),
     execute: async (input) => {
       const cov = tracker.coverage();
@@ -2544,14 +2621,18 @@ write_file already targets the output directory \u2014 use just the filename.`;
 ${formatException(err)}`);
   }
   logger.summary();
-  if (!result && tracker.auditedModels.size > 0) {
-    const markdown = tracker.generateAuditMarkdown();
-    const auditPath = join15(input.outputDir, "entity-audit.md");
-    await writeFile5(auditPath, markdown, "utf-8");
+  const writeCanonicalAudit = async () => {
+    if (tracker.auditedModels.size === 0) return null;
+    const auditPath = join16(input.outputDir, "entity-audit.md");
+    await writeFile5(auditPath, tracker.generateAuditMarkdown(), "utf-8");
+    return auditPath;
+  };
+  const canonicalPath = await writeCanonicalAudit();
+  if (!result && canonicalPath) {
     const cov = tracker.coverage();
     result = {
       success: true,
-      artifacts: [auditPath],
+      artifacts: [canonicalPath],
       summary: `Safety net: agent ran out of steps but audited ${cov.audited}/${cov.totalModels} models. File written from tracker data.`
     };
   }
@@ -2575,11 +2656,12 @@ Call model_coverage to see current state.
 Adjust based on the feedback. You can grep/read source files again if needed.
 When done with changes, call finish again.`;
       await runAgent(agentConfig, feedbackPrompt, () => result);
+      await writeCanonicalAudit();
       return result;
     }
   });
   if (!reviewed) {
-    const auditPath = join15(input.outputDir, "entity-audit.md");
+    const auditPath = join16(input.outputDir, "entity-audit.md");
     try {
       await readFile10(auditPath, "utf-8");
       return {
@@ -2721,10 +2803,10 @@ ${duals.length > 0 ? duals.map((m) => `- **${m.name}** \u2014 standalone: ${m.cr
 
 // src/core/parse-entity-audit.ts
 import { readFile as readFile11 } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 async function parseEntityNames(outputDir) {
   try {
-    const content = await readFile11(join16(outputDir, "entity-audit.md"), "utf-8");
+    const content = await readFile11(join17(outputDir, "entity-audit.md"), "utf-8");
     const names = [];
     for (const line of content.split("\n")) {
       const match = line.match(/^\s+-\s+name:\s+(.+)$/);
@@ -2744,17 +2826,17 @@ var init_parse_entity_audit = __esm({
 
 // src/agents/03-scenario-recipe/scenario-table.ts
 import { readFile as readFile12 } from "fs/promises";
-import { join as join17 } from "path";
-import matter2 from "gray-matter";
+import { join as join18 } from "path";
+import matter3 from "gray-matter";
 async function parseScenario(outputDir) {
   let raw;
   try {
-    raw = await readFile12(join17(outputDir, "scenarios.md"), "utf-8");
+    raw = await readFile12(join18(outputDir, "scenarios.md"), "utf-8");
   } catch {
     return { scenarioNames: [], entityTypes: [] };
   }
   try {
-    const data = matter2(raw).data;
+    const data = matter3(raw).data;
     const varsByEntity = /* @__PURE__ */ new Map();
     for (const vf of data.variable_fields ?? []) {
       const entity = vf?.entity != null ? String(vf.entity) : "";
@@ -2889,21 +2971,21 @@ __export(scenario_recipe_exports, {
   runScenarioRecipe: () => runScenarioRecipe
 });
 import { readFile as readFile13 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import { tool as tool12 } from "ai";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 function buildFinishTool3(requiredEntities, outputDir, onFinish) {
   return tool12({
     description: "Call when scenario design is complete and scenarios.md is written. BLOCKED if any required entities are missing from the scenario.",
-    inputSchema: z12.object({
-      summary: z12.string().describe("Summary of the scenario"),
-      entityCount: z12.number().describe("Number of entity types in the scenario"),
-      artifacts: z12.array(z12.string()).describe("Files written")
+    inputSchema: z13.object({
+      summary: z13.string().describe("Summary of the scenario"),
+      entityCount: z13.number().describe("Number of entity types in the scenario"),
+      artifacts: z13.array(z13.string()).describe("Files written")
     }),
     execute: async (input) => {
       if (requiredEntities.length > 0) {
         try {
-          const content = await readFile13(join18(outputDir, "scenarios.md"), "utf-8");
+          const content = await readFile13(join19(outputDir, "scenarios.md"), "utf-8");
           const missing = requiredEntities.filter(
             (e) => !content.includes(e)
           );
@@ -2990,7 +3072,7 @@ When done with changes, call finish again.`;
     }
   });
   if (!reviewed) {
-    const scenariosPath = join18(input.outputDir, "scenarios.md");
+    const scenariosPath = join19(input.outputDir, "scenarios.md");
     try {
       await readFile13(scenariosPath, "utf-8");
       return {
@@ -3047,7 +3129,7 @@ var init_scenario_recipe = __esm({
 
 // src/agents/04-recipe-builder/state.ts
 import { readFile as readFile14, writeFile as writeFile6 } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function adapterKey(a) {
   return `${a.language}:${a.framework}`;
 }
@@ -3074,14 +3156,14 @@ function initialRecipeState() {
 }
 async function loadRecipeState(outputDir) {
   try {
-    const raw = await readFile14(join19(outputDir, STATE_FILE2), "utf-8");
+    const raw = await readFile14(join20(outputDir, STATE_FILE2), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 async function saveRecipeState(outputDir, state) {
-  await writeFile6(join19(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
+  await writeFile6(join20(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
 }
 var ALL_ADAPTERS, ADAPTER_HINTS, STATE_FILE2;
 var init_state = __esm({
@@ -3128,7 +3210,7 @@ var init_state = __esm({
 
 // src/agents/04-recipe-builder/entity-relevance.ts
 import { Output, generateText } from "ai";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 async function callRanker(model, prompt) {
   const result = await generateText({
     model,
@@ -3210,8 +3292,8 @@ var init_entity_relevance = __esm({
     "use strict";
     init_esm_shims();
     init_errors();
-    rankedSchema = z13.object({
-      ranked: z13.array(z13.string()).describe("Every entity name, ordered most-important first.")
+    rankedSchema = z14.object({
+      ranked: z14.array(z14.string()).describe("Every entity name, ordered most-important first.")
     });
   }
 });
@@ -3219,7 +3301,7 @@ var init_entity_relevance = __esm({
 // src/agents/04-recipe-builder/phases/tech-detect.ts
 import * as p4 from "@clack/prompts";
 import { tool as tool13 } from "ai";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 async function detectTechStack(projectRoot, modelId, nonInteractive) {
   const model = getModel(modelId);
   const ignorePatterns = await loadGitignorePatterns(projectRoot);
@@ -3227,9 +3309,9 @@ async function detectTechStack(projectRoot, modelId, nonInteractive) {
   const { logger, onStepFinish } = buildDefaultStepLogger("tech-detect", 10);
   const finishTool = tool13({
     description: "Report the detected backend technology stack.",
-    inputSchema: z14.object({
-      language: z14.string().describe("Programming language: typescript, python, go, ruby, java, php, rust, elixir"),
-      framework: z14.string().describe("Web framework: express, node, hono, web, flask, fastapi, django, gin, rails, rack, spring, laravel, axum, actix, plug")
+    inputSchema: z15.object({
+      language: z15.string().describe("Programming language: typescript, python, go, ruby, java, php, rust, elixir"),
+      framework: z15.string().describe("Web framework: express, node, hono, web, flask, fastapi, django, gin, rails, rack, spring, laravel, axum, actix, plug")
     }),
     execute: async (input) => {
       detected = input;
@@ -3311,11 +3393,11 @@ When done, call finish with your findings.`;
 
 // src/core/detect-pkg-manager.ts
 import { existsSync as existsSync2 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function detectPackageManager(projectRoot) {
-  if (existsSync2(join20(projectRoot, "bun.lock")) || existsSync2(join20(projectRoot, "bun.lockb"))) return "bun";
-  if (existsSync2(join20(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync2(join20(projectRoot, "yarn.lock"))) return "yarn";
+  if (existsSync2(join21(projectRoot, "bun.lock")) || existsSync2(join21(projectRoot, "bun.lockb"))) return "bun";
+  if (existsSync2(join21(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join21(projectRoot, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function installCommand(pm, ...packages) {
@@ -3392,7 +3474,7 @@ var init_highlight = __esm({
 
 // src/agents/04-recipe-builder/recipe.ts
 import { readFile as readFile15, writeFile as writeFile7 } from "fs/promises";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function buildSingleEntityRecipe(entityName, models, entityOrder, allEntities) {
   const chain = getEntityDependencyChain(entityName, models, entityOrder);
   const recipe = {};
@@ -3436,7 +3518,7 @@ function buildSubmittableRecipe(create, description) {
   };
 }
 async function saveRecipe(outputDir, recipe) {
-  await writeFile7(join21(outputDir, RECIPE_FILE), JSON.stringify(recipe, null, 2), "utf-8");
+  await writeFile7(join22(outputDir, RECIPE_FILE), JSON.stringify(recipe, null, 2), "utf-8");
 }
 var RECIPE_FILE;
 var init_recipe = __esm({
@@ -3494,24 +3576,108 @@ var init_http_client = __esm({
   }
 });
 
+// src/agents/04-recipe-builder/phases/failure-classifier.ts
+import { Output as Output2, generateText as generateText2 } from "ai";
+import { z as z16 } from "zod";
+function buildClassifierPrompt(args) {
+  const errorText = typeof args.error === "string" ? args.error : JSON.stringify(args.error, null, 2);
+  const phaseLine = args.phase === "teardown" ? `This was a DOWN (teardown) request. Teardown runs the developer's delete logic against data the create() step already accepted, so teardown failures are usually implementation-side (wrong delete order, foreign-key cleanup bugs) rather than caused by the recipe.` : `This was an UP (create) request \u2014 the factory tried to insert the recipe records.`;
+  const statusLine = args.httpStatus != null ? `HTTP status: ${args.httpStatus}. (A 5xx usually means the handler threw; a 4xx is more often a rejected payload, but use the error text \u2014 status alone is not decisive.)` : `No HTTP status (the request threw before a response \u2014 often a network/server-process problem, lean implementation or unclear).`;
+  return `${PRIMER}
+
+- RECIPE DATA is wrong \u2014 the JSON the tool sent doesn't fit the developer's (correct) schema. Examples of the *kind* of problem (not an exhaustive list): a _ref points at an alias that does not exist among the valid targets listed below, a field holds a value the backend rejects, a required field is missing or an unknown field was sent, or a value has the wrong type. These are fixable by regenerating the data \u2014 the developer's code is fine.
+- IMPLEMENTATION is wrong \u2014 the developer's own handler/factory code is broken. Examples of the *kind* of problem: the factory for this entity is not registered, the handler references a column or table that does not exist (even though the recipe never mentioned it), the insert/delete logic has a bug, or the server threw an unhandled exception. No change to the test data can fix this; the developer must edit code.
+
+## How to decide
+
+Ask: "Would sending DIFFERENT, corrected test data \u2014 still matching the intended schema \u2014 plausibly make this request succeed?"
+- If yes \u2192 **recipe**.
+- If the data shown below looks valid and the error points at the server's own logic, a missing factory, or a column/table the recipe never referenced \u2192 **implementation**.
+- If you genuinely cannot tell from the evidence \u2192 **unclear**. Prefer "unclear" over a confident guess; a wrong confident answer is worse than admitting uncertainty.
+
+Cross-check the error against the actual data below before deciding \u2014 e.g. only call a _ref invalid if its target really is absent from the valid targets list.
+
+## Evidence
+
+${phaseLine}
+${statusLine}
+
+Entity: "${args.entityName}"
+
+Valid _ref targets (aliases declared by already-created parent entities):
+${args.validRefAliases?.trim() || "(none \u2014 this is a root entity with no parents to reference)"}
+
+What the entity audit recorded about how "${args.entityName}" is created:
+${args.entityAudit?.trim() || "(not available)"}
+
+Test data sent:
+${JSON.stringify(args.recipe, null, 2)}
+
+Error:
+${errorText}`;
+}
+async function classifyFailure(model, args) {
+  try {
+    const result = await generateText2({
+      model,
+      prompt: buildClassifierPrompt(args),
+      output: Output2.object({ schema: classificationSchema })
+    });
+    return result.output;
+  } catch (err) {
+    return { side: "unclear", reason: `Could not auto-triage this error (${formatException(err)}).` };
+  }
+}
+var classificationSchema, PRIMER;
+var init_failure_classifier = __esm({
+  "src/agents/04-recipe-builder/phases/failure-classifier.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_errors();
+    classificationSchema = z16.object({
+      side: z16.enum(["recipe", "implementation", "unclear"]).describe(
+        "recipe = the test data we sent is wrong and regenerating it could fix the failure; implementation = the developer's handler/factory code is wrong and only a code change fixes it; unclear = cannot confidently attribute the failure to either side."
+      ),
+      reason: z16.string().describe("One short, plain-language sentence explaining the verdict for the user. No code, no jargon dumps.")
+    });
+    PRIMER = `## Background \u2014 what you are looking at
+
+The Autonoma SDK lets a developer seed and tear down test data through a single HTTP endpoint on their own backend (the "Environment Factory"). For each database entity the developer registers a *factory* with two functions: a create() that inserts records, and a teardown() that deletes them. Their handler code calls into their app's real service/ORM layer.
+
+A separate tool (not the developer) generates the *recipe*: JSON test data, one array of records per entity. Each record may carry an "_alias" (a unique handle, e.g. "account_1") and "_ref" fields ({ "_ref": "account_1" }) that point at an alias declared by an already-created parent entity. The tool sends this recipe to the endpoint:
+- An **UP** request asks the factory to create the records (calls create()).
+- A **DOWN** request asks the factory to tear them down (calls teardown()).
+
+So a failure has exactly two possible origins, and your only job is to tell them apart:`;
+  }
+});
+
 // src/agents/04-recipe-builder/phases/entity-loop.ts
 import * as p5 from "@clack/prompts";
 import { writeFile as writeFile8, readFile as readFile16 } from "fs/promises";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { tmpdir } from "os";
 import { spawn as spawn2 } from "child_process";
 import { tool as tool14 } from "ai";
-import { z as z15 } from "zod";
+import { z as z17 } 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");
 }
+function summarizeEntityAudit(model) {
+  if (!model) return void 0;
+  const parts = [`independently_created: ${model.independently_created}`];
+  if (model.creation_function) parts.push(`creation function: ${model.creation_function}`);
+  if (model.created_by.length > 0) parts.push(`created by: ${model.created_by.map((c) => c.owner).join(", ")}`);
+  if (model.side_effects?.length) parts.push(`side effects: ${model.side_effects.join(", ")}`);
+  return parts.join("; ");
+}
 async function proposeRecipeData(entityName, entityIndex, totalEntities, model, outputDir, _projectRoot, completedEntities) {
   let result;
   const { logger, onStepFinish } = buildDefaultStepLogger(`propose:${entityName}`, 20);
   const finishTool = tool14({
     description: "Submit the proposed recipe data as a JSON array of records.",
-    inputSchema: z15.object({
-      records: z15.array(z15.record(z15.string(), z15.unknown())).describe("Array of record objects for this entity")
+    inputSchema: z17.object({
+      records: z17.array(z17.record(z17.string(), z17.unknown())).describe("Array of record objects for this entity")
     }),
     execute: async (input) => {
       result = input.records;
@@ -3552,8 +3718,8 @@ async function reviseRecipeData(entityName, entityIndex, totalEntities, current,
   let revised;
   const finishTool = tool14({
     description: "Submit the fixed recipe data.",
-    inputSchema: z15.object({
-      records: z15.array(z15.record(z15.string(), z15.unknown()))
+    inputSchema: z17.object({
+      records: z17.array(z17.record(z17.string(), z17.unknown()))
     }),
     execute: async (input) => {
       revised = input.records;
@@ -3609,8 +3775,8 @@ async function generateInstructions(entityName, entityIndex, totalEntities, isFi
   const { logger, onStepFinish } = buildDefaultStepLogger(`instructions:${entityName}`, 15);
   const finishTool = tool14({
     description: "Submit the implementation instructions.",
-    inputSchema: z15.object({
-      instructions: z15.string().describe("Complete, copy-pasteable implementation instructions")
+    inputSchema: z17.object({
+      instructions: z17.string().describe("Complete, copy-pasteable implementation instructions")
     }),
     execute: async (input) => {
       result = input.instructions;
@@ -3690,7 +3856,7 @@ async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed
     if (p5.isCancel(action)) throw new Error("Recipe review cancelled");
     if (action === "keep") return proposed;
     if (action === "edit") {
-      const tmpPath = join22(tmpdir(), `autonoma-recipe-${entityName}.json`);
+      const tmpPath = join23(tmpdir(), `autonoma-recipe-${entityName}.json`);
       await writeFile8(tmpPath, JSON.stringify(proposed, null, 2), "utf-8");
       const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
       p5.log.info(`Opening ${editor}... Save and close when done.`);
@@ -3727,30 +3893,74 @@ async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed
     }
   }
 }
-async function promptOnFailure(entityName, errorBody) {
+function formatErrorContext(errorBody) {
+  if (errorBody == null) return "";
+  const rendered = typeof errorBody === "string" ? errorBody : JSON.stringify(errorBody);
+  return `
+Server error: ${rendered}`;
+}
+function seedFeedbackFromError(errorContext, reason) {
+  const triage = reason ? ` (Auto-triage: ${reason})` : "";
+  return { feedback: `The request failed \u2014 read the error and fix the recipe data.${triage}${errorContext}` };
+}
+async function promptOnFailure(entityName, errorBody, ctx, phase, httpStatus) {
   notify("Autonoma", `${entityName} \u2014 failed, action needed`);
+  const errorContext = formatErrorContext(errorBody);
+  const budgetLeft = ctx.budget.attempts < MAX_AUTOFIX_ATTEMPTS;
+  const { side, reason } = await classifyFailure(ctx.model, {
+    entityName,
+    phase,
+    httpStatus,
+    error: errorBody,
+    recipe: ctx.recipe,
+    validRefAliases: ctx.validRefAliases,
+    entityAudit: ctx.entityAudit
+  });
+  if (side === "recipe" && budgetLeft) {
+    ctx.budget.attempts++;
+    p5.log.info(
+      `Triaged as a recipe-data issue \u2014 fixing automatically (attempt ${ctx.budget.attempts}/${MAX_AUTOFIX_ATTEMPTS}): ${reason}`
+    );
+    return seedFeedbackFromError(errorContext, reason);
+  }
+  const offerAutofix = side !== "implementation" && budgetLeft;
+  if (side === "implementation") {
+    p5.log.warn(`This looks like a handler/code issue, not the test data: ${reason}`);
+  } else if (side === "recipe" && !budgetLeft) {
+    p5.log.warn(`Autofix ran ${MAX_AUTOFIX_ATTEMPTS}\xD7 without resolving it \u2014 over to you. Latest read: ${reason}`);
+  }
   const action = await p5.select({
     message: "What would you like to do?",
     options: [
       { value: "retry", label: "Yes, retry \u2014 I fixed my handler code", hint: "Send the same request again" },
-      { value: "feedback", label: "Yes, fix the recipe data", hint: "The request data is wrong \u2014 I'll explain what to change" },
+      ...offerAutofix ? [
+        {
+          value: "autofix",
+          label: "Yes, let the agent fix it from the error",
+          hint: "The error explains itself \u2014 hand it to the agent, no typing"
+        }
+      ] : [],
+      { value: "feedback", label: "Yes, fix the recipe data \u2014 I'll explain what's wrong", hint: "The request data is wrong and I'll describe the change" },
       { value: "skip", label: "No, skip this entity", hint: "Move on to the next entity" }
     ]
   });
   if (p5.isCancel(action)) throw new Error("Entity loop cancelled");
   if (action === "skip") return "skip";
   if (action === "retry") return "retry";
+  if (action === "autofix") {
+    ctx.budget.attempts++;
+    return seedFeedbackFromError(errorContext);
+  }
   const fb = await p5.text({
     message: "What's wrong with the recipe data?",
     placeholder: "e.g. Transaction references acc_1 but Account uses account_1 as its alias"
   });
   if (p5.isCancel(fb)) throw new Error("Entity loop cancelled");
-  const errorContext = errorBody ? `
-Server error: ${JSON.stringify(errorBody)}` : "";
   return { feedback: `${fb.trim()}${errorContext}` };
 }
-async function testUpDown(entityName, entityIndex, totalEntities, sdkConfig, recipe) {
+async function testUpDown(entityName, entityIndex, totalEntities, sdkConfig, recipe, grounding) {
   p5.log.info(`Let's verify this factory works. We'll send a test request to create ${entityName}, then check the database.`);
+  const failureCtx = { ...grounding, recipe };
   while (true) {
     const testRunId = `test-${Date.now()}`;
     p5.log.step(`[${entityIndex + 1}/${totalEntities}] Sending UP request...`);
@@ -3760,7 +3970,7 @@ async function testUpDown(entityName, entityIndex, totalEntities, sdkConfig, rec
     } catch (err) {
       p5.log.error(`UP request failed:
 ${formatException(err)}`);
-      const action = await promptOnFailure(entityName, null);
+      const action = await promptOnFailure(entityName, formatException(err), failureCtx, "create");
       if (action === "skip") return "skip";
       if (action === "retry") continue;
       return action;
@@ -3768,7 +3978,7 @@ ${formatException(err)}`);
     if (!upResult.ok) {
       p5.log.error(`UP failed (HTTP ${upResult.status}):`);
       console.log(JSON.stringify(upResult.body, null, 2));
-      const action = await promptOnFailure(entityName, upResult.body);
+      const action = await promptOnFailure(entityName, upResult.body, failureCtx, "create", upResult.status);
       if (action === "skip") return "skip";
       if (action === "retry") continue;
       return action;
@@ -3789,7 +3999,7 @@ ${formatException(err)}`);
       } catch (err) {
         p5.log.error(`DOWN request failed:
 ${formatException(err)}`);
-        const action = await promptOnFailure(entityName, null);
+        const action = await promptOnFailure(entityName, formatException(err), failureCtx, "teardown");
         if (action === "skip") return "skip";
         if (action === "retry") continue;
         return action;
@@ -3797,7 +4007,7 @@ ${formatException(err)}`);
       if (!downResult.ok) {
         p5.log.error(`DOWN failed (HTTP ${downResult.status}):`);
         console.log(JSON.stringify(downResult.body, null, 2));
-        const action = await promptOnFailure(entityName, downResult.body);
+        const action = await promptOnFailure(entityName, downResult.body, failureCtx, "teardown", downResult.status);
         if (action === "skip") return "skip";
         if (action === "retry") continue;
         return action;
@@ -3905,7 +4115,7 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
         state.sharedSecret = secret;
         await saveRecipeState(outputDir, state);
         await writeFile8(
-          join22(outputDir, "autonoma-config.json"),
+          join23(outputDir, "autonoma-config.json"),
           JSON.stringify({ sharedSecret: secret, endpointUrl: state.sdkEndpointUrl }, null, 2),
           "utf-8"
         );
@@ -3916,7 +4126,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: ${join22(outputDir, "autonoma-config.json")}`,
+Saved to: ${join23(outputDir, "autonoma-config.json")}`,
           "Shared secret generated"
         );
         const secretReady = await p5.confirm({
@@ -3938,7 +4148,7 @@ Saved to: ${join22(outputDir, "autonoma-config.json")}`,
         state.sdkEndpointUrl = url.trim() || "http://localhost:3000/api/autonoma";
         await saveRecipeState(outputDir, state);
         await writeFile8(
-          join22(outputDir, "autonoma-config.json"),
+          join23(outputDir, "autonoma-config.json"),
           JSON.stringify({ sharedSecret: state.sharedSecret, endpointUrl: state.sdkEndpointUrl }, null, 2),
           "utf-8"
         );
@@ -3947,10 +4157,17 @@ Saved to: ${join22(outputDir, "autonoma-config.json")}`,
         endpointUrl: state.sdkEndpointUrl,
         sharedSecret: state.sharedSecret
       };
+      const autofixBudget = { attempts: 0 };
+      const grounding = {
+        model,
+        budget: autofixBudget,
+        validRefAliases: summarizeCompletedAliases(state.entities, entityName),
+        entityAudit: summarizeEntityAudit(models.find((m) => m.name === entityName))
+      };
       let testDone = false;
       while (!testDone) {
         const singleRecipe = buildSingleEntityRecipe(entityName, models, state.entityOrder, state.entities);
-        const testResult = await testUpDown(entityName, i, total, sdkConfig, singleRecipe);
+        const testResult = await testUpDown(entityName, i, total, sdkConfig, singleRecipe, grounding);
         if (testResult === "success") {
           state.entities[entityName].status = "tested-down";
           p5.log.success(`[${i + 1}/${total}] ${entityName} \u2014 factory verified`);
@@ -3983,7 +4200,7 @@ Saved to: ${join22(outputDir, "autonoma-config.json")}`,
     await saveRecipeState(outputDir, state);
   }
 }
-var PROPOSAL_PROMPT, INSTRUCTIONS_PROMPT;
+var PROPOSAL_PROMPT, INSTRUCTIONS_PROMPT, MAX_AUTOFIX_ATTEMPTS;
 var init_entity_loop = __esm({
   "src/agents/04-recipe-builder/phases/entity-loop.ts"() {
     "use strict";
@@ -3999,6 +4216,7 @@ var init_entity_loop = __esm({
     init_notify();
     init_recipe();
     init_http_client();
+    init_failure_classifier();
     PROPOSAL_PROMPT = `You are a recipe data designer. Given an entity from the entity audit and the scenario data, produce a JSON array of records for this entity.
 
 Rules:
@@ -4026,19 +4244,20 @@ Include:
 Be specific \u2014 reference actual file paths, function names, and types from the codebase.
 
 When done, call finish with the instructions text.`;
+    MAX_AUTOFIX_ATTEMPTS = 2;
   }
 });
 
 // src/agents/04-recipe-builder/phases/full-validation.ts
 import * as p6 from "@clack/prompts";
 import { tool as tool15 } from "ai";
-import { z as z16 } from "zod";
+import { z as z18 } 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: z16.object({
-      recipe: z16.record(z16.string(), z16.array(z16.record(z16.string(), z16.unknown())))
+    inputSchema: z18.object({
+      recipe: z18.record(z18.string(), z18.array(z18.record(z18.string(), z18.unknown())))
     }),
     execute: async (input) => {
       revised = input.recipe;
@@ -4271,7 +4490,7 @@ __export(recipe_builder_exports, {
   runRecipeBuilder: () => runRecipeBuilder
 });
 import { readFile as readFile17 } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import * as p8 from "@clack/prompts";
 async function runRecipeBuilder(input) {
   const model = getModel(input.modelId);
@@ -4289,7 +4508,7 @@ async function runRecipeBuilder(input) {
     );
     let importanceRank;
     try {
-      const auditMarkdown = await readFile17(join23(input.outputDir, "entity-audit.md"), "utf-8");
+      const auditMarkdown = await readFile17(join24(input.outputDir, "entity-audit.md"), "utf-8");
       importanceRank = await rankEntitiesByImportance(models, auditMarkdown, model);
     } catch {
       importanceRank = void 0;
@@ -4391,22 +4610,22 @@ var init_recipe_builder = __esm({
 });
 
 // src/agents/05-test-generator/rubrics.ts
-import { z as z17 } from "zod";
+import { z as z19 } 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 = z17.object({
-      pass: z17.boolean(),
-      evidence: z17.string().describe("What you checked and found \u2014 cite file paths, line content, or specific strings"),
-      suggestion: z17.string().optional().describe("What the planner agent should fix, if failing")
+    dimensionResultSchema = z19.object({
+      pass: z19.boolean(),
+      evidence: z19.string().describe("What you checked and found \u2014 cite file paths, line content, or specific strings"),
+      suggestion: z19.string().optional().describe("What the planner agent should fix, if failing")
     });
     structuralIntentRubric = {
       name: "structural-intent",
       maxSteps: 8,
       dimensions: ["structuralValidity", "intentQuality", "missionAlignment"],
-      resultSchema: z17.object({
+      resultSchema: z19.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?"
         ),
@@ -4447,7 +4666,7 @@ When done reviewing, call finish with your structured evaluation.`
       name: "flow-completeness",
       maxSteps: 12,
       dimensions: ["actionCompletion", "mutationVerification"],
-      resultSchema: z17.object({
+      resultSchema: z19.object({
         actionCompletion: dimensionResultSchema.describe(
           "Does the test complete a core action and reach an OUTCOME? Not just opening a modal or clicking a tab."
         ),
@@ -4483,7 +4702,7 @@ When done reviewing, call finish with your structured evaluation.`
       name: "ui-text",
       maxSteps: 20,
       dimensions: ["uiTextAuthenticity"],
-      resultSchema: z17.object({
+      resultSchema: z19.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."
         )
@@ -4522,7 +4741,7 @@ When done reviewing, call finish with your structured evaluation.`
       name: "data-accuracy",
       maxSteps: 20,
       dimensions: ["dataAccuracy"],
-      resultSchema: z17.object({
+      resultSchema: z19.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?"
         )
@@ -4638,7 +4857,7 @@ var init_review_pass = __esm({
 
 // src/agents/05-test-generator/review.ts
 import { readFile as readFile18 } from "fs/promises";
-import { join as join24, relative as relative6, basename as basename3 } from "path";
+import { join as join25, relative as relative6, basename as basename3 } from "path";
 import { glob as glob5 } from "glob";
 import "ai";
 async function reviewSingleTest(testContent, testPath, projectRoot, model, scenarioData) {
@@ -4665,14 +4884,14 @@ async function reviewSingleTest(testContent, testPath, projectRoot, model, scena
   return merged;
 }
 async function runConsolidatedReview(outputDir, projectRoot, model) {
-  const testsDir = join24(outputDir, "qa-tests");
+  const testsDir = join25(outputDir, "qa-tests");
   const logger = createStepLogger("review", 5);
   let scenarioData;
   try {
-    scenarioData = await readFile18(join24(outputDir, "scenarios.md"), "utf-8");
+    scenarioData = await readFile18(join25(outputDir, "scenarios.md"), "utf-8");
   } catch {
   }
-  const testFiles = await glob5(join24(testsDir, "**/*.md"));
+  const testFiles = await glob5(join25(testsDir, "**/*.md"));
   const tests = [];
   for (const testPath of testFiles) {
     if (basename3(testPath) === "INDEX.md") continue;
@@ -4755,13 +4974,13 @@ var init_review2 = __esm({
 
 // src/agents/05-test-generator/graph.ts
 import { readFile as readFile19, writeFile as writeFile9 } from "fs/promises";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 async function saveBfsState(outputDir, state) {
-  const path3 = join25(outputDir, STATE_FILE3);
+  const path3 = join26(outputDir, STATE_FILE3);
   await writeFile9(path3, JSON.stringify(state.serialize(), null, 2), "utf-8");
 }
 async function loadBfsState(outputDir) {
-  const path3 = join25(outputDir, STATE_FILE3);
+  const path3 = join26(outputDir, STATE_FILE3);
   try {
     const raw = await readFile19(path3, "utf-8");
     return CoverageState.deserialize(JSON.parse(raw));
@@ -4856,16 +5075,16 @@ var init_graph = __esm({
 
 // src/agents/00b-feature-discovery/index.ts
 import { readFile as readFile20, writeFile as writeFile10 } from "fs/promises";
-import { join as join26 } from "path";
-import { z as z18 } from "zod";
+import { join as join27 } from "path";
+import { z as z20 } from "zod";
 import { tool as tool17 } from "ai";
 async function saveFeatures(outputDir, features) {
   const obj = Object.fromEntries(features);
-  await writeFile10(join26(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile10(join27(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadFeatures(outputDir) {
   try {
-    const raw = await readFile20(join26(outputDir, FEATURES_FILE), "utf-8");
+    const raw = await readFile20(join27(outputDir, FEATURES_FILE), "utf-8");
     const obj = JSON.parse(raw);
     return new Map(Object.entries(obj));
   } catch {
@@ -4899,7 +5118,7 @@ Process every page. Call add_feature for each sub-feature you discover. When don
         add_feature: tool17({
           description: "Add a discovered sub-feature",
           inputSchema: Feature.extend({
-            id: z18.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
+            id: z20.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
           }),
           execute: (featureInput) => {
             const { id, ...rest } = featureInput;
@@ -4913,17 +5132,17 @@ Process every page. Call add_feature for each sub-feature you discover. When don
         }),
         view_features: tool17({
           description: "View all discovered features so far",
-          inputSchema: z18.object({}),
+          inputSchema: z20.object({}),
           execute: () => collector.viewFeatures()
         }),
         view_pages: tool17({
           description: "View the pages list to know what to analyze",
-          inputSchema: z18.object({}),
+          inputSchema: z20.object({}),
           execute: () => pagesDescription
         }),
         finish: tool17({
           description: "Signal that feature discovery is complete",
-          inputSchema: z18.object({ summary: z18.string() }),
+          inputSchema: z20.object({ summary: z20.string() }),
           execute: async (finishInput) => {
             result = {
               success: true,
@@ -4954,13 +5173,13 @@ var init_b_feature_discovery = __esm({
     init_model();
     init_tools();
     FEATURES_FILE = "features.json";
-    Feature = z18.object({
-      name: z18.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
-      type: z18.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
-      parentPagePath: z18.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
-      sourceFiles: z18.array(z18.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
-      interactiveElements: z18.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
-      description: z18.string().min(10).describe("What this sub-feature does")
+    Feature = z20.object({
+      name: z20.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
+      type: z20.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
+      parentPagePath: z20.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
+      sourceFiles: z20.array(z20.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
+      interactiveElements: z20.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
+      description: z20.string().min(10).describe("What this sub-feature does")
     });
     FeatureCollector = class {
       features = /* @__PURE__ */ new Map();
@@ -5041,14 +5260,14 @@ Use kebab-case IDs that indicate the parent page and feature type:
 });
 
 // src/agents/05-test-generator/validation.ts
-import matter3 from "gray-matter";
+import matter4 from "gray-matter";
 function validateTestContent(content) {
   const errors = [];
   if (!/^---\n[\s\S]*?\n---/.test(content)) {
     errors.push("Missing frontmatter");
   } else {
     try {
-      const { data } = matter3(content);
+      const { data } = matter4(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");
       }
@@ -5103,18 +5322,18 @@ var init_validation = __esm({
 
 // src/agents/05-test-generator/tools.ts
 import { mkdir as mkdir3, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname2, join as join27 } from "path";
+import { dirname as dirname3, join as join28 } from "path";
 import { hasToolCall as hasToolCall3, stepCountIs as stepCountIs3, tool as tool18, ToolLoopAgent as ToolLoopAgent3 } from "ai";
-import matter4 from "gray-matter";
-import { z as z19 } from "zod";
+import matter5 from "gray-matter";
+import { z as z21 } from "zod";
 function buildWriteTestTool(state, outputDir) {
   return tool18({
     description: "Write a test file to qa-tests/{folder}/{filename}.md. Validates frontmatter before writing. Returns error if frontmatter is invalid.",
-    inputSchema: z19.object({
-      folder: z19.string().describe("Subfolder name under qa-tests/"),
-      filename: z19.string().describe("File name (e.g. login-valid-credentials.md)"),
-      content: z19.string().describe("Full file content including YAML frontmatter"),
-      nodeId: z19.string().describe("The FeatureNode ID this test belongs to")
+    inputSchema: z21.object({
+      folder: z21.string().describe("Subfolder name under qa-tests/"),
+      filename: z21.string().describe("File name (e.g. login-valid-credentials.md)"),
+      content: z21.string().describe("Full file content including YAML frontmatter"),
+      nodeId: z21.string().describe("The FeatureNode ID this test belongs to")
     }),
     execute: async (input) => {
       const frontmatter = extractFrontmatter(input.content);
@@ -5163,10 +5382,10 @@ function buildWriteTestTool(state, outputDir) {
           };
         }
       }
-      const relPath = join27("qa-tests", input.folder, input.filename);
-      const absPath = join27(outputDir, relPath);
+      const relPath = join28("qa-tests", input.folder, input.filename);
+      const absPath = join28(outputDir, relPath);
       try {
-        await mkdir3(dirname2(absPath), { recursive: true });
+        await mkdir3(dirname3(absPath), { recursive: true });
         await writeFile11(absPath, input.content, "utf-8");
         state.markTested(input.nodeId, [relPath]);
         await saveBfsState(outputDir, state);
@@ -5181,14 +5400,14 @@ function buildWriteTestTool(state, outputDir) {
 function buildCreateFolderTool(outputDir) {
   return tool18({
     description: "Create a folder under qa-tests/ for organizing tests.",
-    inputSchema: z19.object({
-      folder: z19.string().describe("Folder name (kebab-case)")
+    inputSchema: z21.object({
+      folder: z21.string().describe("Folder name (kebab-case)")
     }),
     execute: async (input) => {
-      const absPath = join27(outputDir, "qa-tests", input.folder);
+      const absPath = join28(outputDir, "qa-tests", input.folder);
       try {
         await mkdir3(absPath, { recursive: true });
-        return { path: join27("qa-tests", input.folder) };
+        return { path: join28("qa-tests", input.folder) };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { error: `Failed to create folder: ${message}` };
@@ -5199,7 +5418,7 @@ function buildCreateFolderTool(outputDir) {
 function buildNextNodeTool(state, outputDir) {
   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: z19.object({}),
+    inputSchema: z21.object({}),
     execute: async () => {
       const next = state.nextNode();
       await saveBfsState(outputDir, state);
@@ -5228,7 +5447,7 @@ function buildNextNodeTool(state, outputDir) {
 function buildGetProgressTool(state) {
   return tool18({
     description: "Check how many nodes have been tested vs how many remain.",
-    inputSchema: z19.object({}),
+    inputSchema: z21.object({}),
     execute: async () => {
       const stats = state.summary();
       const nodes = [...state.nodes.values()].map((n) => ({
@@ -5244,12 +5463,12 @@ function buildGetProgressTool(state) {
 function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
   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: z19.object({
-      instruction: z19.string().describe("What to research \u2014 be specific about files and what to look for")
+    inputSchema: z21.object({
+      instruction: z21.string().describe("What to research \u2014 be specific about files and what to look for")
     }),
     execute: async (input) => {
-      const resultSchema2 = z19.object({
-        findings: z19.string().describe("Summary of what was found")
+      const resultSchema2 = z21.object({
+        findings: z21.string().describe("Summary of what was found")
       });
       let result;
       const subagent = new ToolLoopAgent3({
@@ -5287,7 +5506,7 @@ function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
 }
 function extractFrontmatter(content) {
   try {
-    const { data } = matter4(content);
+    const { data } = matter5(content);
     return data && Object.keys(data).length > 0 ? data : null;
   } catch {
     return null;
@@ -5301,14 +5520,14 @@ var init_tools2 = __esm({
     init_tools();
     init_graph();
     init_validation();
-    testFrontmatterSchema = z19.object({
-      title: z19.string().min(1),
-      description: z19.string().min(1),
-      intent: z19.string().min(30, "Intent must be at least 30 characters \u2014 describe the BEHAVIOR being tested, not the steps"),
-      criticality: z19.enum(["critical", "high", "mid", "low"]),
-      scenario: z19.string().min(1),
-      flow: z19.string().min(1),
-      verification: z19.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 = z21.object({
+      title: z21.string().min(1),
+      description: z21.string().min(1),
+      intent: z21.string().min(30, "Intent must be at least 30 characters \u2014 describe the BEHAVIOR being tested, not the steps"),
+      criticality: z21.enum(["critical", "high", "mid", "low"]),
+      scenario: z21.string().min(1),
+      flow: z21.string().min(1),
+      verification: z21.string().min(20, "Verification must describe WHERE to navigate and WHAT to assert at the source of truth \u2014 not UI acknowledgments like toasts")
     });
   }
 });
@@ -5705,9 +5924,9 @@ __export(test_generator_exports, {
   runTestGenerator: () => runTestGenerator
 });
 import { mkdir as mkdir4, readFile as readFile21, rmdir, unlink, writeFile as writeFile12 } from "fs/promises";
-import { basename as basename4, join as join28 } from "path";
+import { basename as basename4, join as join29 } from "path";
 import { tool as tool19 } from "ai";
-import { z as z20 } from "zod";
+import { z as z22 } from "zod";
 import { glob as glob6 } from "glob";
 async function preseedQueue(state, projectRoot, pages, features) {
   let seeded = 0;
@@ -5757,8 +5976,8 @@ async function runTestGenerator(input) {
   let result;
   const finishTool = tool19({
     description: "Call when the BFS queue is empty and all routes have been explored.",
-    inputSchema: z20.object({
-      summary: z20.string().describe("Coverage summary")
+    inputSchema: z22.object({
+      summary: z22.string().describe("Coverage summary")
     }),
     execute: async (finishInput) => {
       const stats = state.summary();
@@ -5788,7 +6007,7 @@ async function runTestGenerator(input) {
   let kbContext = "";
   try {
     const autonomaMd = await readFile21(
-      join28(input.outputDir, "AUTONOMA.md"),
+      join29(input.outputDir, "AUTONOMA.md"),
       "utf-8"
     );
     kbContext += `
@@ -5800,7 +6019,7 @@ ${autonomaMd}
   }
   try {
     const scenariosMd = await readFile21(
-      join28(input.outputDir, "scenarios.md"),
+      join29(input.outputDir, "scenarios.md"),
       "utf-8"
     );
     kbContext += `
@@ -5996,7 +6215,7 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
       console.log(`  Fix pass complete`);
     }
     const allTestFiles = await glob6(
-      join28(input.outputDir, "qa-tests", "**/*.md")
+      join29(input.outputDir, "qa-tests", "**/*.md")
     );
     let markedInvalid = 0;
     for (const testPath of allTestFiles) {
@@ -6005,9 +6224,9 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
       const content = await readFile21(testPath, "utf-8");
       const validation = validateTestContent(content);
       if (!validation.valid) {
-        const invalidDir = join28(input.outputDir, "qa-tests", "_invalid");
+        const invalidDir = join29(input.outputDir, "qa-tests", "_invalid");
         await mkdir4(invalidDir, { recursive: true });
-        const dest = join28(invalidDir, basename4(testPath));
+        const dest = join29(invalidDir, basename4(testPath));
         const annotated = `<!-- VALIDATION ERRORS: ${validation.errors.join("; ")} -->
 ${content}`;
         await writeFile12(dest, annotated, "utf-8");
@@ -6020,7 +6239,7 @@ ${content}`;
         `  ${markedInvalid} tests still invalid after review cycles \u2014 moved to _invalid/`
       );
     }
-    const dirs = await glob6(join28(input.outputDir, "qa-tests", "**/"), {
+    const dirs = await glob6(join29(input.outputDir, "qa-tests", "**/"), {
       dot: false
     });
     for (const dir of dirs.sort((a, b) => b.length - a.length)) {
@@ -6112,7 +6331,7 @@ async function generateIndex(outputDir, state) {
   for (const paths of state.testsWritten.values()) {
     for (const p10 of paths) {
       try {
-        const content2 = await readFile21(join28(outputDir, p10), "utf-8");
+        const content2 = await readFile21(join29(outputDir, p10), "utf-8");
         const critMatch = content2.match(/criticality:\s*(\w+)/);
         const critVal = critMatch?.[1] ?? "";
         if (critCounts.has(critVal))
@@ -6163,22 +6382,22 @@ ${folders.map((f) => `| ${f.name} | ${f.test_count} |`).join("\n")}
 
 ${[...testsByFolder.entries()].flatMap(([_folder, tests]) => tests.map((t) => `- \`${t}\``)).join("\n")}
 `;
-  await writeFile12(join28(outputDir, "qa-tests", "INDEX.md"), content, "utf-8");
+  await writeFile12(join29(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 readFile21(join28(outputDir, "AUTONOMA.md"), "utf-8");
+    autonomaMd = await readFile21(join29(outputDir, "AUTONOMA.md"), "utf-8");
   } catch {
   }
   try {
-    scenariosMd = await readFile21(join28(outputDir, "scenarios.md"), "utf-8");
+    scenariosMd = await readFile21(join29(outputDir, "scenarios.md"), "utf-8");
   } catch {
   }
   if (!autonomaMd) return 0;
-  const existingTests = await glob6(join28(outputDir, "qa-tests", "**/*.md"));
+  const existingTests = await glob6(join29(outputDir, "qa-tests", "**/*.md"));
   const existingTitles = [];
   for (const t of existingTests) {
     if (basename4(t) === "INDEX.md") continue;
@@ -6227,7 +6446,7 @@ Write 5-8 journey tests using the write_test tool with folder "journeys". Then c
   let journeyResult;
   const journeyFinish = tool19({
     description: "Signal journey generation is complete.",
-    inputSchema: z20.object({ summary: z20.string() }),
+    inputSchema: z22.object({ summary: z22.string() }),
     execute: async (finishInput) => {
       journeyResult = {
         success: true,
@@ -6289,7 +6508,7 @@ var init_test_generator = __esm({
 init_esm_shims();
 import * as p9 from "@clack/prompts";
 import { readFile as readFile22, writeFile as writeFile13 } from "fs/promises";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 
 // src/config.ts
 init_esm_shims();
@@ -6501,7 +6720,7 @@ init_notify();
 // src/core/upload.ts
 init_esm_shims();
 import { readFile as readFile3 } from "fs/promises";
-import { basename, join as join7, relative } from "path";
+import { basename, join as join8, relative } from "path";
 import * as p from "@clack/prompts";
 import { glob } from "glob";
 
@@ -6509,7 +6728,7 @@ import { glob } from "glob";
 init_esm_shims();
 import { execFile as execFile2 } from "child_process";
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile2);
 var GIT_INFO_FILE = ".git-info.json";
@@ -6533,11 +6752,11 @@ async function readGitInfo(projectRoot) {
   };
 }
 async function saveGitInfo(outputDir, info) {
-  await writeFile2(join6(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
+  await writeFile2(join7(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
 }
 async function loadGitInfo(outputDir) {
   try {
-    const raw = await readFile2(join6(outputDir, GIT_INFO_FILE), "utf-8");
+    const raw = await readFile2(join7(outputDir, GIT_INFO_FILE), "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed != null && "sha" in parsed && typeof parsed.sha === "string") {
       const branch = "branch" in parsed && typeof parsed.branch === "string" ? parsed.branch : void 0;
@@ -6556,7 +6775,7 @@ async function readArtifacts(outputDir) {
   const files = [];
   for (const name of ARTIFACT_FILES) {
     try {
-      const content = await readFile3(join7(outputDir, name), "utf-8");
+      const content = await readFile3(join8(outputDir, name), "utf-8");
       files.push({ name, content });
     } catch {
     }
@@ -6564,13 +6783,13 @@ async function readArtifacts(outputDir) {
   return files;
 }
 async function readTestCases(outputDir) {
-  const testsDir = join7(outputDir, "qa-tests");
+  const testsDir = join8(outputDir, "qa-tests");
   const matches = await glob("**/*.md", { cwd: testsDir, nodir: true });
   const files = [];
   for (const match of matches) {
     const name = basename(match);
     if (name === "INDEX.md") continue;
-    const content = await readFile3(join7(testsDir, match), "utf-8");
+    const content = await readFile3(join8(testsDir, match), "utf-8");
     const folderPath = relative(".", match).split("/").slice(0, -1).join("/");
     files.push({ name, content, folder: folderPath.length > 0 ? folderPath : void 0 });
   }
@@ -6630,7 +6849,7 @@ async function uploadArtifacts(config, outputDir) {
 // src/core/state.ts
 init_esm_shims();
 import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var STATE_FILE = ".pipeline-state.json";
 function initialState() {
   return {
@@ -6645,7 +6864,7 @@ function initialState() {
   };
 }
 async function loadState(outputDir) {
-  const path3 = join8(outputDir, STATE_FILE);
+  const path3 = join9(outputDir, STATE_FILE);
   try {
     const raw = await readFile4(path3, "utf-8");
     return JSON.parse(raw);
@@ -6654,7 +6873,7 @@ async function loadState(outputDir) {
   }
 }
 async function saveState(outputDir, state) {
-  const path3 = join8(outputDir, STATE_FILE);
+  const path3 = join9(outputDir, STATE_FILE);
   await writeFile3(path3, JSON.stringify(state, null, 2), "utf-8");
 }
 async function markStep(outputDir, state, step, status) {
@@ -6675,11 +6894,11 @@ process.setSourceMapsEnabled(true);
 var PAGES_FILE = "pages.json";
 async function savePages(outputDir, pages) {
   const obj = Object.fromEntries(pages);
-  await writeFile13(join29(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile13(join30(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadPages(outputDir) {
   try {
-    const raw = await readFile22(join29(outputDir, PAGES_FILE), "utf-8");
+    const raw = await readFile22(join30(outputDir, PAGES_FILE), "utf-8");
     const obj = JSON.parse(raw);
     return new Map(Object.entries(obj));
   } catch {
@@ -6833,6 +7052,7 @@ async function runStep(step, outputDir, state, config, projectContext, nonIntera
       p9.log.success(`Completed: ${label}`);
     }
   } catch (err) {
+    if (isUserCancellation(err)) throw err;
     state = await markStep(outputDir, state, step, "failed");
     const known = describeKnownError(err);
     if (known) {
@@ -7111,7 +7331,7 @@ Continue?`
       }
     }
   } catch (err) {
-    if (err instanceof Error && (err.message.includes("cancelled") || err.message.includes("Cancelled"))) {
+    if (isUserCancellation(err)) {
       p9.log.warn("Your progress is saved. Run again with --resume to continue from where you left off.");
       return;
     }
@@ -7137,6 +7357,10 @@ Continue?`
   p9.outro("Done");
 }
 main().then(() => flushAnalytics()).catch(async (err) => {
+  if (isUserCancellation(err)) {
+    await flushAnalytics();
+    process.exit(0);
+  }
   const known = describeKnownError(err);
   if (known) {
     console.error(`\x1B[31m${known.title}\x1B[0m`);