@autonoma-ai/planner 0.1.19 → 0.1.21

package/dist/index.js

@@ -23,6 +23,202 @@ var init_esm_shims = __esm({
   }
 });
 
+// src/core/to-record.ts
+function toRecord(value) {
+  if (typeof value !== "object" || value === null) return {};
+  const record = {};
+  for (const [key, entry] of Object.entries(value)) {
+    record[key] = entry;
+  }
+  return record;
+}
+var init_to_record = __esm({
+  "src/core/to-record.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/agents/04-recipe-builder/recipe.ts
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+function collectRefs(value, out) {
+  if (Array.isArray(value)) {
+    for (const v of value) collectRefs(v, out);
+  } else if (value !== null && typeof value === "object") {
+    const obj = toRecord(value);
+    if (typeof obj._ref === "string") out.add(obj._ref);
+    for (const v of Object.values(obj)) collectRefs(v, out);
+  }
+}
+function buildSingleEntityRecipe(entityName, models, entityOrder, allEntities) {
+  const modelMap = new Map(models.map((m) => [m.name, m]));
+  const aliasOwner = /* @__PURE__ */ new Map();
+  for (const [name, entity] of Object.entries(allEntities)) {
+    for (const rec of entity?.recipeData ?? []) {
+      if (typeof rec._alias === "string") aliasOwner.set(rec._alias, name);
+    }
+  }
+  const recipe = {};
+  const done = /* @__PURE__ */ new Set();
+  const onStack = /* @__PURE__ */ new Set();
+  function include(name) {
+    if (done.has(name) || onStack.has(name)) return;
+    onStack.add(name);
+    const records = allEntities[name]?.recipeData ?? [];
+    for (const dep of modelMap.get(name)?.created_by ?? []) {
+      if (entityOrder.includes(dep.owner)) include(dep.owner);
+    }
+    const refs = /* @__PURE__ */ new Set();
+    collectRefs(records, refs);
+    for (const alias of refs) {
+      const owner = aliasOwner.get(alias);
+      if (owner && owner !== name) include(owner);
+    }
+    onStack.delete(name);
+    done.add(name);
+    if (records.length > 0) recipe[name] = records;
+  }
+  include(entityName);
+  return recipe;
+}
+function buildFullRecipe(entityOrder, allEntities) {
+  const recipe = {};
+  for (const name of entityOrder) {
+    const entity = allEntities[name];
+    if (entity?.recipeData && entity.recipeData.length > 0) {
+      recipe[name] = entity.recipeData;
+    }
+  }
+  return recipe;
+}
+function buildSubmittableRecipe(create, description) {
+  return {
+    version: 1,
+    source: {
+      discoverPath: "discover.json",
+      scenariosPath: "scenarios.md"
+    },
+    validationMode: "endpoint-lifecycle",
+    recipes: [
+      {
+        name: "standard",
+        description,
+        create,
+        validation: {
+          status: "validated",
+          method: "endpoint-up-down"
+        }
+      }
+    ]
+  };
+}
+async function saveRecipe(outputDir, recipe) {
+  await writeFile(join(outputDir, RECIPE_FILE), JSON.stringify(recipe, null, 2), "utf-8");
+}
+async function loadRecipe(outputDir) {
+  try {
+    const raw = await readFile(join(outputDir, RECIPE_FILE), "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+var RECIPE_FILE;
+var init_recipe = __esm({
+  "src/agents/04-recipe-builder/recipe.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_to_record();
+    RECIPE_FILE = "recipe.json";
+  }
+});
+
+// src/agents/04-recipe-builder/phases/submit.ts
+import * as p from "@clack/prompts";
+async function runSubmit(state, outputDir, autonomaApiUrl, autonomaApiToken, autonomaGenerationId) {
+  const fullCreate = buildFullRecipe(state.entityOrder, state.entities);
+  const recipe = buildSubmittableRecipe(fullCreate, "Standard test scenario with realistic data");
+  await saveRecipe(outputDir, recipe);
+  p.log.success(`Recipe saved to ${RECIPE_FILE2}`);
+  const uploaded = await submitRecipe(recipe, {
+    apiUrl: autonomaApiUrl,
+    apiToken: autonomaApiToken,
+    generationId: autonomaGenerationId
+  });
+  return { recipePath: RECIPE_FILE2, uploaded };
+}
+async function uploadRecipeFromDisk(outputDir, creds) {
+  const recipe = await loadRecipe(outputDir);
+  if (recipe == null) {
+    p.log.error(
+      `No ${RECIPE_FILE2} found in ${outputDir}. Run the planner's recipe step first to generate it, then retry.`
+    );
+    return false;
+  }
+  return submitRecipe(recipe, creds);
+}
+async function submitRecipe(recipe, creds) {
+  const { apiUrl, apiToken, generationId } = creds;
+  if (!apiUrl || !apiToken || !generationId) {
+    p.log.info(
+      "Autonoma API credentials not configured - recipe saved locally, not uploaded. Set AUTONOMA_API_URL, AUTONOMA_API_TOKEN and AUTONOMA_GENERATION_ID, then run `" + UPLOAD_COMMAND + "`."
+    );
+    return false;
+  }
+  const url = `${apiUrl.replace(/\/+$/, "")}/v1/setup/setups/${generationId}/scenario-recipe-versions`;
+  p.log.step("Submitting recipe to Autonoma...");
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiToken}`
+      },
+      body: JSON.stringify(recipe)
+    });
+  } catch (err) {
+    p.log.error(`Recipe submission failed (network error): ${err instanceof Error ? err.message : String(err)}`);
+    printRecipeForRecovery(recipe);
+    return false;
+  }
+  if (res.ok) {
+    p.log.success(`Recipe submitted successfully (HTTP ${res.status})`);
+    return true;
+  }
+  const text6 = await res.text();
+  p.log.error(`Recipe submission failed (HTTP ${res.status}): ${text6}`);
+  printRecipeForRecovery(recipe);
+  return false;
+}
+function printRecipeForRecovery(recipe) {
+  console.log(
+    [
+      "",
+      "\u2500".repeat(72),
+      "RECIPE NOT UPLOADED - copy the JSON below into a recipe.json and re-upload with:",
+      `  ${UPLOAD_COMMAND}`,
+      "(with the same AUTONOMA_API_URL / AUTONOMA_API_TOKEN / AUTONOMA_GENERATION_ID env vars set)",
+      "\u2500".repeat(72),
+      JSON.stringify(recipe, null, 2),
+      "\u2500".repeat(72),
+      ""
+    ].join("\n")
+  );
+}
+var RECIPE_FILE2, UPLOAD_COMMAND;
+var init_submit = __esm({
+  "src/agents/04-recipe-builder/phases/submit.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_recipe();
+    RECIPE_FILE2 = "recipe.json";
+    UPLOAD_COMMAND = "npx @autonoma-ai/planner@latest upload";
+  }
+});
+
 // src/env.ts
 import { createEnv } from "@t3-oss/env-core";
 import { z } from "zod";
@@ -82,14 +278,14 @@ var init_debug = __esm({
 
 // src/core/version.ts
 import { readFileSync as readFileSync3 } from "fs";
-import { dirname, join as join3 } from "path";
+import { dirname, join as join4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 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(join3(here, rel), "utf-8"));
+        const pkg = JSON.parse(readFileSync3(join4(here, rel), "utf-8"));
         if (pkg?.name === PACKAGE_NAME && typeof pkg.version === "string") {
           return pkg.version;
         }
@@ -114,7 +310,7 @@ var init_version = __esm({
 import { randomUUID } from "crypto";
 import { readFileSync as readFileSync4, writeFileSync, mkdirSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function resolveKey() {
   return (readEnv().AUTONOMA_POSTHOG_KEY ?? POSTHOG_PUBLIC_KEY).trim();
 }
@@ -199,7 +395,7 @@ function trackError(error, properties = {}, handled = true) {
 }
 async function flushAnalytics(timeoutMs = 1500) {
   if (pending.size === 0) return;
-  await Promise.race([Promise.allSettled([...pending]), new Promise((resolve5) => setTimeout(resolve5, timeoutMs))]);
+  await Promise.race([Promise.allSettled([...pending]), new Promise((resolve6) => setTimeout(resolve6, timeoutMs))]);
 }
 var AUTONOMA_HOME2, DEVICE_ID_PATH, POSTHOG_PUBLIC_KEY, DEFAULT_HOST, RUN_ID, cachedDeviceId, enabled, pending;
 var init_analytics = __esm({
@@ -209,8 +405,8 @@ var init_analytics = __esm({
     init_env();
     init_debug();
     init_version();
-    AUTONOMA_HOME2 = join4(homedir2(), ".autonoma");
-    DEVICE_ID_PATH = join4(AUTONOMA_HOME2, ".device-id");
+    AUTONOMA_HOME2 = join5(homedir2(), ".autonoma");
+    DEVICE_ID_PATH = join5(AUTONOMA_HOME2, ".device-id");
     POSTHOG_PUBLIC_KEY = "phc_mUOwUj62r8vyiisFPvXLC3G5RftETIBMnKNSHqTBdka";
     DEFAULT_HOST = "https://us.i.posthog.com";
     RUN_ID = randomUUID();
@@ -242,14 +438,14 @@ var init_colors = __esm({
 });
 
 // src/core/context.ts
-import { readFile, writeFile } from "fs/promises";
-import { join as join5 } from "path";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join6 } from "path";
 async function saveContext(outputDir, ctx) {
-  await writeFile(join5(outputDir, CONTEXT_FILE), JSON.stringify(ctx, null, 2), "utf-8");
+  await writeFile2(join6(outputDir, CONTEXT_FILE), JSON.stringify(ctx, null, 2), "utf-8");
 }
 async function loadContext(outputDir) {
   try {
-    const raw = await readFile(join5(outputDir, CONTEXT_FILE), "utf-8");
+    const raw = await readFile2(join6(outputDir, CONTEXT_FILE), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch {
@@ -288,7 +484,7 @@ var init_context = __esm({
 // src/core/errors.ts
 import { APICallError, RetryError, LoadAPIKeyError, InvalidPromptError, NoSuchModelError } from "ai";
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function isUserCancellation(err) {
   return err instanceof Error && /\bcancell?ed\b/i.test(err.message);
@@ -492,6 +688,151 @@ var init_notify = __esm({
   }
 });
 
+// src/core/project-map.ts
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { join as join9 } from "path";
+import { z as z2 } from "zod";
+async function saveProjectMap(outputDir, map) {
+  await writeFile4(join9(outputDir, PROJECT_MAP_FILE), JSON.stringify(map, null, 2), "utf-8");
+}
+async function loadProjectMap(outputDir) {
+  const path3 = join9(outputDir, PROJECT_MAP_FILE);
+  try {
+    const raw = await readFile4(path3, "utf-8");
+    const parsed = ProjectMapSchema.safeParse(JSON.parse(raw));
+    if (parsed.success) return parsed.data;
+    debugLog("project-map.json failed schema validation, ignoring it", { path: path3, issues: parsed.error.issues });
+    return void 0;
+  } catch (err) {
+    const isMissingFile = err instanceof Error && "code" in err && err.code === "ENOENT";
+    if (!isMissingFile) debugLog("Failed to read project-map.json, ignoring it", { path: path3, err });
+    return void 0;
+  }
+}
+function renderProjectMap(map) {
+  const section = (title, rows, fmt) => {
+    if (rows.length === 0) return `${title}: (none)`;
+    return `${title}:
+` + rows.map((r) => `  - ${fmt(r)}`).join("\n");
+  };
+  return [
+    section("Frontend(s)", map.frontends, (f) => {
+      const deps = f.dependsOn.length > 0 ? `  needs: ${f.dependsOn.join(", ")}` : "";
+      return `${f.path}  [${f.framework}]${deps}  - ${f.why}`;
+    }),
+    section("Backend(s)", map.backends, (b) => {
+      const dl = b.dataLayer != null ? `  data: ${b.dataLayer.kind}${b.dataLayer.schemaPath != null ? ` @ ${b.dataLayer.schemaPath}` : ""}` : "";
+      return `${b.path}  [${b.language}/${b.framework}]${dl}  - ${b.why}`;
+    }),
+    section("Ignoring", map.ignore, (i) => `${i.path}  - ${i.why}`)
+  ].join("\n\n");
+}
+function formatFrontendScope(map) {
+  if (map.frontends.length === 0) return void 0;
+  const fronts = map.frontends.map((f) => f.path).join(", ");
+  const ignore = map.ignore.map((i) => i.path);
+  const ignoreLine = ignore.length > 0 ? ` Do NOT spend time in these irrelevant directories: ${ignore.join(", ")}.` : "";
+  return `The project has already been mapped. The frontend surface to focus on is: ${fronts}. Confine your exploration to that surface.${ignoreLine}`;
+}
+function relatedPath(a, b) {
+  return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
+}
+function matchMapPath(requested, candidates) {
+  if (candidates.includes(requested)) return requested;
+  return candidates.find((c) => relatedPath(c, requested));
+}
+function matchBackend(requested, backends) {
+  const byPath = backends.find((b) => relatedPath(b.path, requested));
+  if (byPath != null) return byPath.path;
+  const bySchema = backends.find(
+    (b) => b.dataLayer?.schemaPath != null && relatedPath(b.dataLayer.schemaPath, requested)
+  );
+  return bySchema?.path;
+}
+function resolveSelection(map, requested) {
+  const frontendPaths = map.frontends.map((f) => f.path);
+  return {
+    frontend: matchMapPath(requested.frontend, frontendPaths) ?? requested.frontend,
+    backends: requested.backends.map((b) => matchBackend(b, map.backends) ?? b)
+  };
+}
+function defaultBackendsFor(map, frontendPath) {
+  const declared = map.frontends.find((f) => f.path === frontendPath)?.dependsOn ?? [];
+  const resolved = declared.map((dep) => matchBackend(dep, map.backends)).filter((p10) => p10 != null);
+  return [...new Set(resolved)];
+}
+function pickDefaultSelection(map) {
+  if (map.frontends.length !== 1) return void 0;
+  const [only] = map.frontends;
+  if (only == null) return void 0;
+  return { frontend: only.path, backends: defaultBackendsFor(map, only.path) };
+}
+function applySelection(map, selection) {
+  const frontend = map.frontends.find((f) => f.path === selection.frontend);
+  if (frontend == null) {
+    const options = map.frontends.map((f) => f.path).join(", ") || "(none)";
+    throw new Error(`Selected frontend "${selection.frontend}" is not in the map. Candidates: ${options}`);
+  }
+  const chosenBackends = map.backends.filter((b) => selection.backends.includes(b.path));
+  const missing = selection.backends.filter((p10) => !map.backends.some((b) => b.path === p10));
+  if (missing.length > 0) {
+    const options = map.backends.map((b) => b.path).join(", ") || "(none)";
+    throw new Error(`Selected backend(s) not in the map: ${missing.join(", ")}. Candidates: ${options}`);
+  }
+  const droppedFrontends = map.frontends.filter((f) => f.path !== selection.frontend).map((f) => ({ path: f.path, why: "Another frontend in the monorepo; not the app under test." }));
+  const droppedBackends = map.backends.filter((b) => !selection.backends.includes(b.path)).map((b) => ({ path: b.path, why: "Backend not required by the selected frontend." }));
+  return {
+    frontends: [frontend],
+    backends: chosenBackends,
+    ignore: [...map.ignore, ...droppedFrontends, ...droppedBackends]
+  };
+}
+function formatBackendScope(map) {
+  if (map.backends.length === 0) return void 0;
+  const backs = map.backends.map((b) => b.dataLayer?.schemaPath != null ? `${b.path} (models @ ${b.dataLayer.schemaPath})` : b.path).join(", ");
+  const ignore = map.ignore.map((i) => i.path);
+  const ignoreLine = ignore.length > 0 ? ` Ignore these irrelevant directories: ${ignore.join(", ")}.` : "";
+  return `The project has already been mapped. The backend(s)/data layer(s) that own the models to seed are: ${backs}. Scope your data-model work to those backend(s).${ignoreLine}`;
+}
+var FrontendEntry, BackendEntry, IgnoreEntry, ProjectMapSchema, PROJECT_MAP_FILE;
+var init_project_map = __esm({
+  "src/core/project-map.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_debug();
+    FrontendEntry = z2.object({
+      path: z2.string().min(1).describe("Repo-relative path to the frontend app/directory (the UI surface)."),
+      framework: z2.string().describe("Detected UI framework/stack, or 'unknown' if not obvious (e.g. next, react, vue, svelte)."),
+      dependsOn: z2.array(z2.string()).describe(
+        "Repo-relative paths (each matching a backend in this map) that THIS frontend needs in order to function - the API/service(s) it calls and the data layer(s) that own the records it renders. These are pre-selected when the user picks this frontend, so only list backends this frontend actually depends on. Empty if it needs none."
+      ),
+      why: z2.string().min(1).describe("One line: the evidence that made you classify this as a frontend.")
+    });
+    BackendEntry = z2.object({
+      path: z2.string().min(1).describe("Repo-relative path to the backend/API/service or the package that owns the data layer."),
+      language: z2.string().describe("Primary language, or 'unknown' (e.g. typescript, python, go, rust)."),
+      framework: z2.string().describe("Web/service framework or ORM stack, or 'unknown' (e.g. express, hono, fastapi, rails)."),
+      dataLayer: z2.object({
+        kind: z2.string().describe("How models are defined (e.g. prisma, drizzle, sqlalchemy, typeorm, raw-sql, unknown)."),
+        schemaPath: z2.string().optional().describe("Repo-relative path to the schema/models definition, if found.")
+      }).optional().describe("Where this backend's database models live. Omit if this backend owns no data layer."),
+      why: z2.string().min(1).describe("One line: the evidence that made you classify this as a backend.")
+    });
+    IgnoreEntry = z2.object({
+      path: z2.string().min(1).describe("Repo-relative path to a directory that is NOT relevant to testing this app."),
+      why: z2.string().min(1).describe("One line: why it is irrelevant (e.g. docs site, infra, tooling, examples, unrelated app).")
+    });
+    ProjectMapSchema = z2.object({
+      frontends: z2.array(FrontendEntry).describe("The UI surface(s) whose pages/flows get tested. Usually 1; may be more."),
+      backends: z2.array(BackendEntry).describe(
+        "The API/service(s) and data layer(s) that own the models we seed. May be 0 (frontend-only), 1, or many."
+      ),
+      ignore: z2.array(IgnoreEntry).describe("Directories judged irrelevant to this app's tests, so later steps skip them.")
+    });
+    PROJECT_MAP_FILE = "project-map.json";
+  }
+});
+
 // src/core/display.ts
 function formatArgs(input, keys) {
   const parts = [];
@@ -766,8 +1107,8 @@ var init_agent = __esm({
 });
 
 // src/core/gitignore.ts
-import { readFile as readFile5 } from "fs/promises";
-import { join as join10, relative as relative2 } from "path";
+import { readFile as readFile7 } from "fs/promises";
+import { join as join12, relative as relative2 } from "path";
 import { glob as glob2 } from "glob";
 async function loadGitignorePatterns(projectRoot) {
   const patterns = [
@@ -787,10 +1128,10 @@ async function loadGitignorePatterns(projectRoot) {
   ];
   const matches = await glob2("**/.gitignore", { cwd: projectRoot, dot: true });
   for (const match of matches) {
-    const fullPath = join10(projectRoot, match);
+    const fullPath = join12(projectRoot, match);
     try {
-      const content = await readFile5(fullPath, "utf-8");
-      const prefix = relative2(projectRoot, join10(projectRoot, match, ".."));
+      const content = await readFile7(fullPath, "utf-8");
+      const prefix = relative2(projectRoot, join12(projectRoot, match, ".."));
       const parsed = parseGitignore(content, prefix);
       patterns.push(...parsed);
     } catch (err) {
@@ -853,7 +1194,7 @@ var init_exec_error = __esm({
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { tool } from "ai";
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 function validateCommand(command, allowed) {
   const trimmed = command.trim();
   if (trimmed.length === 0) return "Empty command";
@@ -919,8 +1260,8 @@ var init_bash = __esm({
     DEFAULT_ALLOWED = /* @__PURE__ */ new Set(["git", "wc", "sort", "head", "tail", "cat", "ls", "find", "diff", "echo"]);
     TIMEOUT_MS = 3e4;
     MAX_OUTPUT_BYTES = 1024 * 512;
-    inputSchema = z2.object({
-      command: z2.string().describe("Shell command to execute")
+    inputSchema = z4.object({
+      command: z4.string().describe("Shell command to execute")
     });
   }
 });
@@ -928,7 +1269,7 @@ var init_bash = __esm({
 // src/tools/glob.ts
 import { tool as tool2 } from "ai";
 import { glob as glob3 } from "glob";
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 async function executeGlob(pattern, cwd, ignorePatterns = DEFAULT_IGNORE) {
   try {
     const matches = await glob3(pattern, {
@@ -955,9 +1296,9 @@ var init_glob = __esm({
   "src/tools/glob.ts"() {
     "use strict";
     init_esm_shims();
-    inputSchema2 = z3.object({
-      pattern: z3.string().describe("Glob pattern to match files (e.g. '**/*.ts', 'src/**/*.py')"),
-      cwd: z3.string().optional().describe("Directory to search in. Defaults to working directory.")
+    inputSchema2 = z5.object({
+      pattern: z5.string().describe("Glob pattern to match files (e.g. '**/*.ts', 'src/**/*.py')"),
+      cwd: z5.string().optional().describe("Directory to search in. Defaults to working directory.")
     });
     DEFAULT_IGNORE = ["**/node_modules/**", "**/dist/**", "**/.git/**"];
   }
@@ -967,7 +1308,7 @@ var init_glob = __esm({
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify3 } from "util";
 import { tool as tool3 } from "ai";
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 function buildGrepTool(workingDirectory) {
   return tool3({
     description: "Search file contents with ripgrep. Returns matching lines with file paths and line numbers.",
@@ -1011,10 +1352,10 @@ var init_grep = __esm({
     init_esm_shims();
     init_exec_error();
     execFileAsync3 = promisify3(execFile4);
-    inputSchema3 = z4.object({
-      pattern: z4.string().describe("Regex pattern to search for in file contents"),
-      glob: z4.string().optional().describe("Glob to filter files (e.g. '*.ts')"),
-      path: z4.string().optional().describe("File or directory to search in")
+    inputSchema3 = z6.object({
+      pattern: z6.string().describe("Regex pattern to search for in file contents"),
+      glob: z6.string().optional().describe("Glob to filter files (e.g. '*.ts')"),
+      path: z6.string().optional().describe("File or directory to search in")
     });
   }
 });
@@ -1022,10 +1363,10 @@ var init_grep = __esm({
 // src/tools/list-directory.ts
 import { readdir } from "fs/promises";
 import { stat } from "fs/promises";
-import { join as join11, relative as relative3 } from "path";
+import { join as join13, relative as relative3 } from "path";
 import { tool as tool4 } from "ai";
 import { minimatch } from "minimatch";
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 function buildMatcher(patterns) {
   const positive = patterns.filter((p10) => !p10.startsWith("!"));
   const negative = patterns.filter((p10) => p10.startsWith("!")).map((p10) => p10.slice(1));
@@ -1047,7 +1388,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
   const withTypes = [];
   for (const name of rawEntries) {
     try {
-      const s = await stat(join11(dirPath, name));
+      const s = await stat(join13(dirPath, name));
       withTypes.push({ name, isDir: s.isDirectory() });
     } catch {
       withTypes.push({ name, isDir: false });
@@ -1067,7 +1408,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
     }
     if (entry.isDir) {
       const children = await buildTree(
-        join11(dirPath, entry.name),
+        join13(dirPath, entry.name),
         maxDepth,
         currentDepth + 1,
         isIgnored,
@@ -1105,10 +1446,10 @@ async function buildListDirectoryTool(workingDirectory) {
   const isIgnored = buildMatcher(patterns);
   return tool4({
     description: "List directory structure as a tree. Use this for an overview of the project layout. Start at the root (path='.') with depth 3, then increase depth or narrow path if needed. Do NOT call this on every subdirectory - use glob to find specific files instead. Returns cached result if the same path+depth was already requested.",
-    inputSchema: z5.object({
-      path: z5.string().default(".").describe("Directory path relative to project root. Defaults to root."),
-      depth: z5.number().min(1).max(15).default(10).describe("Max depth to traverse (1-15). Default 10."),
-      gitignore: z5.boolean().describe(
+    inputSchema: z7.object({
+      path: z7.string().default(".").describe("Directory path relative to project root. Defaults to root."),
+      depth: z7.number().min(1).max(15).default(10).describe("Max depth to traverse (1-15). Default 10."),
+      gitignore: z7.boolean().describe(
         "Whether to respect the gitignore or to ignore it. true will respect it. false will ignore it. Default true"
       ).default(true)
     }),
@@ -1120,7 +1461,7 @@ async function buildListDirectoryTool(workingDirectory) {
         };
       }
       seen.add(cacheKey);
-      const targetDir = input.path === "." ? workingDirectory : join11(workingDirectory, input.path);
+      const targetDir = input.path === "." ? workingDirectory : join13(workingDirectory, input.path);
       try {
         const s = await stat(targetDir);
         if (!s.isDirectory()) {
@@ -1152,10 +1493,10 @@ var init_list_directory = __esm({
 });
 
 // src/tools/read-file.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { relative as relative4, resolve as resolve2 } from "path";
 import { tool as tool5 } from "ai";
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 function resolveSandboxedPath(workingDirectory, filePath) {
   const absolutePath = resolve2(workingDirectory, filePath);
   const relativePath = relative4(workingDirectory, absolutePath);
@@ -1180,7 +1521,7 @@ async function executeReadFile(workingDirectory, filePath, offset, limit) {
   const resolved = resolveSandboxedPath(workingDirectory, filePath);
   if ("error" in resolved) return resolved;
   try {
-    const content = await readFile6(resolved.absolutePath, "utf-8");
+    const content = await readFile8(resolved.absolutePath, "utf-8");
     const sliced = sliceLines(content, offset ?? 0, limit ?? MAX_LINES);
     return {
       path: resolved.relativePath,
@@ -1208,10 +1549,10 @@ var init_read_file = __esm({
     "use strict";
     init_esm_shims();
     MAX_LINES = 2e3;
-    inputSchema4 = z6.object({
-      filePath: z6.string().describe("Path to the file (absolute or relative to working directory)"),
-      offset: z6.number().int().min(0).optional().describe("Line number to start reading from (0-based)"),
-      limit: z6.number().int().min(1).optional().describe("Maximum number of lines to read")
+    inputSchema4 = z8.object({
+      filePath: z8.string().describe("Path to the file (absolute or relative to working directory)"),
+      offset: z8.number().int().min(0).optional().describe("Line number to start reading from (0-based)"),
+      limit: z8.number().int().min(1).optional().describe("Maximum number of lines to read")
     });
   }
 });
@@ -1234,10 +1575,10 @@ var init_pick_string = __esm({
 
 // src/tools/subagent.ts
 import { ToolLoopAgent as ToolLoopAgent2, hasToolCall as hasToolCall2, stepCountIs as stepCountIs2, tool as tool6 } from "ai";
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 function buildSubagentTools(workingDirectory, onFileRead) {
   const baseReadFile = buildReadFileTool(workingDirectory);
-  const readFile23 = onFileRead ? tool6({
+  const readFile24 = onFileRead ? tool6({
     description: baseReadFile.description,
     inputSchema: baseReadFile.inputSchema,
     execute: async (input, options) => {
@@ -1250,7 +1591,7 @@ function buildSubagentTools(workingDirectory, onFileRead) {
     bash: buildBashTool(workingDirectory),
     glob: buildGlobTool(workingDirectory),
     grep: buildGrepTool(workingDirectory),
-    read_file: readFile23
+    read_file: readFile24
   };
 }
 function buildSubagentTool(model, workingDirectory, onHeartbeat, onFileRead) {
@@ -1301,11 +1642,11 @@ var init_subagent = __esm({
     init_glob();
     init_grep();
     init_read_file();
-    inputSchema5 = z7.object({
-      instruction: z7.string().describe("Focused task for the subagent. Be specific about files and patterns to investigate.")
+    inputSchema5 = z9.object({
+      instruction: z9.string().describe("Focused task for the subagent. Be specific about files and patterns to investigate.")
     });
-    resultSchema = z7.object({
-      findings: z7.string().describe("Summary of what was found")
+    resultSchema = z9.object({
+      findings: z9.string().describe("Summary of what was found")
     });
     SYSTEM_PROMPT = `You are a code research assistant. You have tools to explore a codebase: bash (shell commands, mainly git), glob (find files), grep (search content), and read_file (read files).
 
@@ -1316,10 +1657,10 @@ 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 { writeFile as writeFile6, mkdir as mkdir2 } from "fs/promises";
 import { dirname as dirname2, relative as relative5, resolve as resolve3 } from "path";
 import { tool as tool7 } from "ai";
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 async function executeWriteFile(outputDirectory, filePath, content) {
   const cleaned = filePath.replace(/^autonoma\//, "");
   const absolutePath = resolve3(outputDirectory, cleaned);
@@ -1329,7 +1670,7 @@ async function executeWriteFile(outputDirectory, filePath, content) {
   }
   try {
     await mkdir2(dirname2(absolutePath), { recursive: true });
-    await writeFile4(absolutePath, content, "utf-8");
+    await writeFile6(absolutePath, content, "utf-8");
     return { path: relativePath, bytesWritten: content.length };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1348,28 +1689,33 @@ var init_write_file = __esm({
   "src/tools/write-file.ts"() {
     "use strict";
     init_esm_shims();
-    inputSchema6 = z8.object({
-      filePath: z8.string().describe("Path to write (absolute or relative to output directory)"),
-      content: z8.string().describe("File content to write")
+    inputSchema6 = z10.object({
+      filePath: z10.string().describe("Path to write (absolute or relative to output directory)"),
+      content: z10.string().describe("File content to write")
     });
   }
 });
 
 // src/tools/ask-user.ts
-import * as p2 from "@clack/prompts";
+import * as p3 from "@clack/prompts";
 import { tool as tool8 } from "ai";
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 function buildAskUserTool() {
   return tool8({
     description: "Ask the user a question ONLY when the answer is truly unknowable from the codebase. Valid reasons: untyped JSON/JSONB field schemas, business rules not in code, config values not in source. NEVER ask about: field names (read the schema), field types (read the ORM model), enum values (read the code), relationships (read foreign keys), numeric values (read the seed data or defaults). If you can find it by reading a file, DO NOT ask - read the file instead.",
-    inputSchema: z9.object({
-      question: z9.string().describe(
+    inputSchema: z11.object({
+      question: z11.string().describe(
         "A clear, plain-language question. State exactly what you need to know and why you can't find it in code. BAD: 'What are the decimal values for checking_balance?' - GOOD: 'Your Account model has a metadata JSON column with no type definition. What fields go inside it?'"
       )
     }),
     execute: async (input) => {
-      const answer = await p2.text({ message: input.question });
-      if (p2.isCancel(answer)) return { answer: "User skipped this question" };
+      if (!process.stdin.isTTY) {
+        return {
+          answer: "No interactive user is available (non-interactive run). Do not ask again - infer the answer by reading the relevant model/schema/service files in the codebase and proceed with your best judgment."
+        };
+      }
+      const answer = await p3.text({ message: input.question });
+      if (p3.isCancel(answer)) return { answer: "User skipped this question" };
       return { answer };
     }
   });
@@ -1411,6 +1757,58 @@ var init_tools = __esm({
   }
 });
 
+// src/agents/00-project-mapper/index.ts
+var project_mapper_exports = {};
+__export(project_mapper_exports, {
+  runProjectMapper: () => runProjectMapper
+});
+import { tool as tool9 } from "ai";
+async function runProjectMapper(input) {
+  const model = getModel(input.modelId);
+  const { logger, onStepFinish } = buildDefaultStepLogger("project-map", MAX_STEPS);
+  let captured;
+  const prompt = `Map the codebase rooted at ${input.projectRoot}.
+
+Explore the layout and dependency manifests, then enumerate EVERY candidate frontend and EVERY candidate backend/data-layer, and for each frontend record the backends it depends on. List everything genuinely irrelevant under ignore. Do not prune to a single app - a human picks the one to test afterward. Then call set_project_map and finish.`;
+  const agentConfig = {
+    id: "project-mapper",
+    systemPrompt: SYSTEM_PROMPT2,
+    model,
+    maxSteps: MAX_STEPS,
+    tools: async (heartbeat) => {
+      const tools = await buildCodebaseTools(model, input.projectRoot, input.outputDir, heartbeat);
+      return {
+        ...tools,
+        set_project_map: tool9({
+          description: "Record the final project map: the frontend app(s), the backend(s)/data layer(s), and the directories to ignore. Call this once you are confident in the partition, then call finish.",
+          inputSchema: ProjectMapSchema,
+          execute: (map) => {
+            captured = map;
+            return `Recorded: ${map.frontends.length} frontend(s), ${map.backends.length} backend(s), ${map.ignore.length} ignored. Now call finish.`;
+          }
+        })
+      };
+    },
+    onStepFinish
+  };
+  await runAgent(agentConfig, prompt, () => captured);
+  logger.summary();
+  return captured;
+}
+var MAX_STEPS, SYSTEM_PROMPT2;
+var init_project_mapper = __esm({
+  "src/agents/00-project-mapper/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_agent();
+    init_model();
+    init_project_map();
+    init_tools();
+    MAX_STEPS = 60;
+    SYSTEM_PROMPT2 = "You map a codebase into three groups so the rest of the test-planning pipeline knows exactly what to look at and what to skip: FRONTENDS (the UI surfaces whose pages and flows could be tested), BACKENDS (the API/service and the data layer that owns the database models we would seed test data into), and IGNORE (everything irrelevant to testing this product).\n\nYou are a DISCOVERY step, not a decision step. The pipeline tests ONE frontend at a time, but YOU do not choose which - a human (or the agent driving you) picks afterward from what you found. So enumerate EVERY candidate frontend and EVERY candidate backend you can justify; do not prune down to a single app. Pruning happens at selection, using the dependency edges you record.\n\nDiscover the structure - never assume it. Read package/dependency manifests, config files, and the directory layout, then reason from evidence:\n- A FRONTEND renders a user interface (pages/routes/views, a UI framework or bundler, browser entry points).\n- A BACKEND serves an API and/or owns the data layer (a database schema, ORM models, migrations, server routes).\n- IGNORE is the rest: infra, build tooling, examples, generated code, and packages that are neither a UI nor a service/data-layer.\n\nFor EACH frontend, record `dependsOn`: the repo-relative paths (each must be one of the backends you list) that that frontend actually needs in order to work - the API/service(s) it calls and the data layer(s) that own the records it renders. Infer these from evidence: the frontend's dependency manifest, the API clients/SDKs it imports, GraphQL/REST endpoints or gateway URLs it points at, and shared data-layer packages it reads. When the user selects that frontend, its `dependsOn` backends are pre-checked, so be accurate: list the backends it truly needs, not every backend in the repo.\n\nHandle every shape without special-casing any framework:\n- A single fullstack app can be BOTH a frontend and a backend at the SAME path - list that path under both, and put its own path in its `dependsOn`.\n- A monorepo can hold many apps and packages - list every genuine frontend and backend; only truly irrelevant directories go in IGNORE.\n- There may be MANY backends (a main API, separate services, a shared data-layer package, a gateway plus the services behind it) - list each one, and wire each frontend's `dependsOn` to just the ones it uses.\n- The data layer a frontend uses may live in a sibling/shared package OUTSIDE the frontend's own folder - record that package as a backend, point its dataLayer.schemaPath at the schema, and include it in the frontend's `dependsOn`.\n- A codebase may ship only one half. If you find frontends but NO backend/data layer (or vice versa), still record what you found and leave the other group empty - the caller will ask the user to supply the missing half.\n\nBe thorough and evidence-based. When you have enumerated the candidates and their dependency edges, call set_project_map, then call finish. Keep each `why` to a single concrete sentence citing what you saw.";
+  }
+});
+
 // src/agents/00-pages-finder/index.ts
 var pages_finder_exports = {};
 __export(pages_finder_exports, {
@@ -1418,8 +1816,8 @@ __export(pages_finder_exports, {
 });
 import { existsSync } from "fs";
 import * as path2 from "path";
-import { tool as tool9 } from "ai";
-import { z as z10 } from "zod";
+import { tool as tool10 } from "ai";
+import { z as z12 } from "zod";
 async function runPageFinder(input) {
   const model = getModel(input.modelId);
   const pageCollector = new PageCollector();
@@ -1438,7 +1836,7 @@ ${input.extraMessage}`;
       const tools = await buildCodebaseTools(model, input.projectRoot, input.outputDir, heartbeat);
       return {
         ...tools,
-        add_page: tool9({
+        add_page: tool10({
           description: "use this tool to add a page that you found",
           inputSchema: Page,
           execute: (input2) => {
@@ -1450,9 +1848,9 @@ ${input.extraMessage}`;
             return `page ${JSON.stringify(input2)} added`;
           }
         }),
-        view_pages: tool9({
+        view_pages: tool10({
           description: "use this tool to view all the pages that you already added",
-          inputSchema: z10.object(),
+          inputSchema: z12.object(),
           execute: () => pageCollector.viewPages()
         })
       };
@@ -1471,10 +1869,10 @@ var init_pages_finder = __esm({
     init_agent();
     init_model();
     init_tools();
-    Page = z10.object({
-      route: z10.string().min(1),
-      path: z10.string().min(1),
-      description: z10.string().min(10)
+    Page = z12.object({
+      route: z12.string().min(1),
+      path: z12.string().min(1),
+      description: z12.string().min(10)
     });
     PageCollector = class {
       // the key is the path
@@ -1504,13 +1902,13 @@ var init_pages_finder = __esm({
 
 // src/core/review.ts
 import { access } from "fs/promises";
-import { join as join12, isAbsolute } from "path";
-import * as p3 from "@clack/prompts";
+import { join as join14, isAbsolute } from "path";
+import * as p4 from "@clack/prompts";
 import spawn from "cross-spawn";
 import which from "which";
 function resolvePath(artifact, outputDir) {
   if (isAbsolute(artifact)) return artifact;
-  return join12(outputDir, artifact);
+  return join14(outputDir, artifact);
 }
 async function detectEditors() {
   if (cachedEditors) return cachedEditors;
@@ -1525,16 +1923,16 @@ async function detectEditors() {
 async function launchEditor(editor, files) {
   const args = editor.args(files);
   const isTerminalEditor = TERMINAL_EDITORS.has(editor.command);
-  await new Promise((resolve5) => {
+  await new Promise((resolve6) => {
     let settled = false;
     const settle = () => {
       if (settled) return;
       settled = true;
-      resolve5();
+      resolve6();
     };
     const proc = spawn(editor.command, args, { stdio: "inherit" });
     proc.on("error", (err) => {
-      p3.log.warn(`Couldn't open ${editor.label} (${err.message}). Review the files manually:`);
+      p4.log.warn(`Couldn't open ${editor.label} (${err.message}). Review the files manually:`);
       for (const f of files) console.log(`    ${CYAN}${f}${RESET3}`);
       settle();
     });
@@ -1548,17 +1946,17 @@ async function launchEditor(editor, files) {
 async function openInEditor(files) {
   const editors = await detectEditors();
   if (editors.length === 0) {
-    p3.log.warn("No editors found. Review the files manually:");
+    p4.log.warn("No editors found. Review the files manually:");
     for (const f of files) console.log(`    ${CYAN}${f}${RESET3}`);
     return;
   }
   if (preferredEditor) {
     const editor2 = editors.find((e) => e.command === preferredEditor);
     if (editor2) {
-      const open = await p3.confirm({
+      const open = await p4.confirm({
         message: `Open in ${editor2.label}?`
       });
-      if (!p3.isCancel(open) && open) {
+      if (!p4.isCancel(open) && open) {
         await launchEditor(editor2, files);
       }
       return;
@@ -1568,20 +1966,20 @@ async function openInEditor(files) {
     value: e.command,
     label: e.label
   }));
-  const selected = await p3.select({
+  const selected = await p4.select({
     message: "Open output files for review?",
     options: [...options, { value: "skip", label: "No, skip - I'll review later" }]
   });
-  if (p3.isCancel(selected) || selected === "skip") return;
+  if (p4.isCancel(selected) || selected === "skip") return;
   const editor = editors.find((e) => e.command === selected);
-  const remember = await p3.select({
+  const remember = await p4.select({
     message: `Use ${editor.label} for all future reviews?`,
     options: [
       { value: "always", label: `Yes, always use ${editor.label}` },
       { value: "ask", label: "No, ask me each time" }
     ]
   });
-  if (!p3.isCancel(remember) && remember === "always") {
+  if (!p4.isCancel(remember) && remember === "always") {
     preferredEditor = editor.command;
   }
   await launchEditor(editor, files);
@@ -1592,7 +1990,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 = join12(options.outputDir, f);
+      const fullPath = join14(options.outputDir, f);
       try {
         await access(fullPath);
         result.artifacts.push(f);
@@ -1622,7 +2020,7 @@ async function showResults(result, options) {
     }
   }
   if (options.reviewGuidance) {
-    p3.note(options.reviewGuidance, "What to check");
+    p4.note(options.reviewGuidance, "What to check");
   }
   const showPreview = options.showPreview !== false;
   if (showPreview && resolvedPaths.length > 0 && !options.nonInteractive) {
@@ -1635,21 +2033,21 @@ async function reviewLoop(result, options) {
   await showResults(result, options);
   if (options.nonInteractive) return result;
   while (true) {
-    const input = await p3.text({
+    const input = await p4.text({
       message: "Review the output. Press Enter to approve, or type feedback for the agent.",
       placeholder: "Looks good (Enter to approve)",
       defaultValue: ""
     });
-    if (p3.isCancel(input)) {
-      p3.log.warn("Cancelled.");
+    if (p4.isCancel(input)) {
+      p4.log.warn("Cancelled.");
       return result;
     }
     const feedback = input.trim();
     if (feedback === "") {
-      p3.log.success("Approved - moving on.");
+      p4.log.success("Approved - moving on.");
       return result;
     }
-    p3.log.info(`Sending feedback to ${options.agentId}...`);
+    p4.log.info(`Sending feedback to ${options.agentId}...`);
     console.log("");
     const revised = await options.onFeedback(feedback);
     if (revised) {
@@ -1681,13 +2079,13 @@ var init_review = __esm({
 });
 
 // src/agents/01-kb-generator/flows.ts
-import { readFile as readFile7 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join15 } from "path";
 import matter from "gray-matter";
 async function parseCoreFlows(outputDir) {
   let raw;
   try {
-    raw = await readFile7(join13(outputDir, "AUTONOMA.md"), "utf-8");
+    raw = await readFile9(join15(outputDir, "AUTONOMA.md"), "utf-8");
   } catch {
     return [];
   }
@@ -1752,12 +2150,12 @@ var init_flows = __esm({
 });
 
 // src/agents/01-kb-generator/prompt.ts
-var SYSTEM_PROMPT2;
+var SYSTEM_PROMPT3;
 var init_prompt = __esm({
   "src/agents/01-kb-generator/prompt.ts"() {
     "use strict";
     init_esm_shims();
-    SYSTEM_PROMPT2 = `You are a knowledge base generator for E2E test planning. You analyze a frontend codebase and produce a structured guide to EVERY page, flow, and interaction. You must be EXHAUSTIVE - missing a page means missing test coverage.
+    SYSTEM_PROMPT3 = `You are a knowledge base generator for E2E test planning. You analyze a frontend codebase and produce a structured guide to EVERY page, flow, and interaction. You must be EXHAUSTIVE - missing a page means missing test coverage.
 
 ## Your output
 
@@ -1900,15 +2298,15 @@ var kb_generator_exports = {};
 __export(kb_generator_exports, {
   runKBGenerator: () => runKBGenerator
 });
-import { readFile as readFile8 } from "fs/promises";
-import { join as join14 } from "path";
-import { tool as tool10 } from "ai";
-import { z as z11 } from "zod";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join16, resolve as resolve5 } from "path";
+import { tool as tool11 } from "ai";
+import { z as z13 } from "zod";
 function buildRegisterPagesTool(tracker) {
-  return tool10({
+  return tool11({
     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.",
-    inputSchema: z11.object({
-      pages: z11.array(z11.string()).describe("All page file paths found by glob")
+    inputSchema: z13.object({
+      pages: z13.array(z13.string()).describe("All page file paths found by glob")
     }),
     execute: async (input) => {
       tracker.register(input.pages);
@@ -1920,25 +2318,33 @@ function buildRegisterPagesTool(tracker) {
   });
 }
 function buildPageCoverageTool(tracker) {
-  return tool10({
+  return tool11({
     description: "Check how many registered pages you've read vs how many remain.",
-    inputSchema: z11.object({}),
+    inputSchema: z13.object({}),
     execute: async () => tracker.coverage()
   });
 }
+function requiredReads(total) {
+  if (total <= FULL_COVERAGE_MAX_ROUTES) return total;
+  return Math.ceil(total * LARGE_APP_COVERAGE_FLOOR);
+}
 function buildFinishTool(tracker, onFinish) {
-  return tool10({
-    description: "Call when you have finished generating the knowledge base. BLOCKED if there are unread pages - call page_coverage first to check.",
-    inputSchema: z11.object({
-      summary: z11.string().describe("Summary of what was generated"),
-      artifacts: z11.array(z11.string()).describe("List of files written")
+  return tool11({
+    description: "Call when you have finished generating the knowledge base. BLOCKED until you have read enough of the registered routes (every route on a small app; a strong majority on a large one) - call page_coverage first to check how many remain.",
+    inputSchema: z13.object({
+      summary: z13.string().describe("Summary of what was generated"),
+      artifacts: z13.array(z13.string()).describe("List of files written")
     }),
     execute: async (input) => {
       const cov = tracker.coverage();
-      if (cov.unread.length > 0) {
+      const required = requiredReads(cov.total);
+      if (cov.read < required) {
+        const preview = cov.unread.slice(0, 40).join("\n");
+        const more = cov.unread.length > 40 ? `
+...and ${cov.unread.length - 40} more` : "";
         return {
-          error: `Cannot finish: ${cov.unread.length}/${cov.total} pages not yet read. Read these files first:
-${cov.unread.join("\n")}`
+          error: `Cannot finish: only ${cov.read}/${cov.total} routes read - read at least ${required - cov.read} more (target ${required} of ${cov.total}). Start with:
+${preview}${more}`
         };
       }
       onFinish({
@@ -1951,7 +2357,7 @@ ${cov.unread.join("\n")}`
   });
 }
 function buildTrackedReadTool(tracker, baseTool) {
-  return tool10({
+  return tool11({
     description: baseTool.description,
     inputSchema: baseTool.inputSchema,
     execute: async (input, options) => {
@@ -1961,13 +2367,36 @@ function buildTrackedReadTool(tracker, baseTool) {
     }
   });
 }
+function buildKbAgentConfig(tracker, model, input, onStepFinish, setResult) {
+  return {
+    id: "kb-generator",
+    systemPrompt: SYSTEM_PROMPT3,
+    model,
+    maxSteps: 150,
+    tools: async (heartbeat) => {
+      const onFileRead = (path3) => tracker.markRead(path3);
+      const tools = await buildCodebaseTools(model, input.projectRoot, input.outputDir, heartbeat, onFileRead);
+      return {
+        ...tools,
+        read_file: buildTrackedReadTool(tracker, tools.read_file),
+        register_pages: buildRegisterPagesTool(tracker),
+        page_coverage: buildPageCoverageTool(tracker),
+        finish: buildFinishTool(tracker, setResult)
+      };
+    },
+    onStepFinish
+  };
+}
 async function runKBGenerator(input) {
   const model = getModel(input.modelId);
   let result;
-  const tracker = new PageTracker();
+  const setResult = (r) => {
+    result = r;
+  };
   const { logger, onStepFinish } = buildDefaultStepLogger("kb", 150);
   const contextBlock = (input.projectContext ? "\n" + formatContext(input.projectContext) + "\n" : "") + formatRetryGuidance(input.retryGuidance);
   const pages = input.projectContext?.pages;
+  const tracker = new PageTracker(input.projectRoot);
   if (pages?.length) {
     tracker.register(pages.map((p10) => p10.path));
   }
@@ -1979,7 +2408,7 @@ Pages have already been discovered (${pages.length} routes pre-registered). You
 2. Read EVERY registered page file with read_file - the system tracks this
 3. Write AUTONOMA.md progressively as you go (update it after each major area)
 4. Call page_coverage to verify you've read all pages
-5. Call finish - it will REJECT if pages are unread
+5. Call finish - it will REJECT if you have not read enough of the registered routes
 
 Output files:
 1. AUTONOMA.md - with YAML frontmatter (app_name, app_description, core_flows, feature_count)` : `Analyze the codebase at the working directory and generate a complete knowledge base.
@@ -1991,34 +2420,15 @@ MANDATORY PROCESS:
 4. Read EVERY registered page file with read_file - the system tracks this
 5. Write AUTONOMA.md progressively as you go (update it after each major area)
 6. Call page_coverage to verify you've read all pages
-7. Call finish - it will REJECT if pages are unread
+7. Call finish - it will REJECT if you have not read enough of the registered routes
 
 Output files:
 1. AUTONOMA.md - with YAML frontmatter (app_name, app_description, core_flows, feature_count)`;
-  const agentConfig = {
-    id: "kb-generator",
-    systemPrompt: SYSTEM_PROMPT2,
-    model,
-    maxSteps: 150,
-    tools: async (heartbeat) => {
-      const onFileRead = (path3) => tracker.markRead(path3);
-      const tools = await buildCodebaseTools(model, input.projectRoot, input.outputDir, heartbeat, onFileRead);
-      return {
-        ...tools,
-        read_file: buildTrackedReadTool(tracker, tools.read_file),
-        register_pages: buildRegisterPagesTool(tracker),
-        page_coverage: buildPageCoverageTool(tracker),
-        finish: buildFinishTool(tracker, (r) => {
-          result = r;
-        })
-      };
-    },
-    onStepFinish
-  };
+  const agentConfig = buildKbAgentConfig(tracker, model, input, onStepFinish, setResult);
   await runAgent(agentConfig, prompt, () => result);
   logger.summary();
-  const autonomaPath = join14(input.outputDir, "AUTONOMA.md");
-  const autonomaExists = await readFile8(autonomaPath, "utf-8").then(() => true).catch((err) => {
+  const autonomaPath = join16(input.outputDir, "AUTONOMA.md");
+  const autonomaExists = await readFile10(autonomaPath, "utf-8").then(() => true).catch((err) => {
     debugLog("AUTONOMA.md not found while checking step completion", { err });
     return false;
   });
@@ -2029,6 +2439,13 @@ Output files:
       summary: "Knowledge base generated."
     };
   }
+  const finalTracker = new PageTracker(input.projectRoot);
+  if (pages?.length) {
+    const paths = pages.map((p10) => p10.path);
+    finalTracker.register(paths);
+    for (const path3 of paths) finalTracker.markRead(path3);
+  }
+  const finalConfig = buildKbAgentConfig(finalTracker, model, input, onStepFinish, setResult);
   const declaredCriticalFlows = input.projectContext?.criticalFlows?.trim();
   if (result?.success && declaredCriticalFlows) {
     const beforeSelfReview = result;
@@ -2045,7 +2462,7 @@ Read your AUTONOMA.md output. For EACH critical flow the user named:
 If any declared critical flow is missing, mismatched, or left core: false, FIX AUTONOMA.md now - 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);
+    await runAgent(finalConfig, selfReviewPrompt, () => result);
     if (!result) result = beforeSelfReview;
   }
   const reviewed = await reviewLoop(result, {
@@ -2066,7 +2483,7 @@ When AUTONOMA.md correctly reflects every declared critical flow, call finish.`;
 Read your previous output file (AUTONOMA.md) from the output directory to see what you produced.
 Adjust based on the feedback. You can read source files again if needed.
 Call page_coverage to see current state. When done with changes, call finish again.`;
-      await runAgent(agentConfig, feedbackPrompt, () => result);
+      await runAgent(finalConfig, feedbackPrompt, () => result);
       return result;
     }
   });
@@ -2076,7 +2493,7 @@ Call page_coverage to see current state. When done with changes, call finish aga
     summary: "KB generator agent stopped without producing AUTONOMA.md"
   };
 }
-var PageTracker;
+var PageTracker, FULL_COVERAGE_MAX_ROUTES, LARGE_APP_COVERAGE_FLOOR;
 var init_kb_generator = __esm({
   "src/agents/01-kb-generator/index.ts"() {
     "use strict";
@@ -2091,14 +2508,26 @@ var init_kb_generator = __esm({
     init_flows();
     init_prompt();
     PageTracker = class {
+      // Registered pages (from pages.json) are absolute paths, but the agent reads them
+      // with paths relative to the working directory. Canonicalize both to an absolute
+      // path against projectRoot so coverage matches regardless of how each side spelled
+      // it - otherwise the finish gate never clears and the agent nudges out re-reading.
+      constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+      }
+      projectRoot;
       registered = /* @__PURE__ */ new Set();
       read = /* @__PURE__ */ new Set();
+      normalize(filePath) {
+        return resolve5(this.projectRoot, filePath);
+      }
       register(pages) {
-        for (const p10 of pages) this.registered.add(p10);
+        for (const p10 of pages) this.registered.add(this.normalize(p10));
       }
       markRead(filePath) {
-        if (this.registered.has(filePath)) {
-          this.read.add(filePath);
+        const normalized = this.normalize(filePath);
+        if (this.registered.has(normalized)) {
+          this.read.add(normalized);
         }
       }
       unread() {
@@ -2112,16 +2541,18 @@ var init_kb_generator = __esm({
         };
       }
     };
+    FULL_COVERAGE_MAX_ROUTES = 40;
+    LARGE_APP_COVERAGE_FLOOR = 0.5;
   }
 });
 
 // src/agents/04-recipe-builder/entity-order.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join17 } from "path";
 import matter2 from "gray-matter";
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 async function parseEntityAudit(outputDir) {
-  const raw = await readFile9(join15(outputDir, "entity-audit.md"), "utf-8");
+  const raw = await readFile11(join17(outputDir, "entity-audit.md"), "utf-8");
   try {
     const parsed = frontmatterSchema.safeParse(matter2(raw).data);
     if (parsed.success && parsed.data.models.length > 0) {
@@ -2282,22 +2713,22 @@ var init_entity_order = __esm({
   "src/agents/04-recipe-builder/entity-order.ts"() {
     "use strict";
     init_esm_shims();
-    createdBySchema = z12.object({
-      owner: z12.string(),
-      via: z12.string().optional(),
-      why: z12.string().optional()
+    createdBySchema = z14.object({
+      owner: z14.string(),
+      via: z14.string().optional(),
+      why: z14.string().optional()
     });
-    auditedModelSchema = z12.object({
-      name: z12.string(),
-      independently_created: z12.coerce.boolean().default(false),
-      creation_file: z12.string().optional(),
-      creation_function: z12.string().optional(),
-      side_effects: z12.array(z12.string()).optional(),
+    auditedModelSchema = z14.object({
+      name: z14.string(),
+      independently_created: z14.coerce.boolean().default(false),
+      creation_file: z14.string().optional(),
+      creation_function: z14.string().optional(),
+      side_effects: z14.array(z14.string()).optional(),
       // Tolerate a stray `created_by:` with no entries (parsed as null by YAML).
-      created_by: z12.array(createdBySchema).nullish().transform((v) => v ?? [])
+      created_by: z14.array(createdBySchema).nullish().transform((v) => v ?? [])
     });
-    frontmatterSchema = z12.object({
-      models: z12.array(auditedModelSchema).nullish().transform((v) => v ?? [])
+    frontmatterSchema = z14.object({
+      models: z14.array(auditedModelSchema).nullish().transform((v) => v ?? [])
     });
   }
 });
@@ -2364,12 +2795,12 @@ var init_audit_table = __esm({
 });
 
 // src/agents/02-entity-audit/prompt.ts
-var SYSTEM_PROMPT3;
+var SYSTEM_PROMPT4;
 var init_prompt2 = __esm({
   "src/agents/02-entity-audit/prompt.ts"() {
     "use strict";
     init_esm_shims();
-    SYSTEM_PROMPT3 = `You audit a codebase to discover EVERY database model and every way each is created. You must find ALL models - missing one means the test data layer has a gap. This audit drives factory generation and scenario planning.
+    SYSTEM_PROMPT4 = `You audit a codebase to discover EVERY database model and every way each is created. You must find ALL models - missing one means the test data layer has a gap. This audit drives factory generation and scenario planning.
 
 ## The two orthogonal questions
 
@@ -2507,17 +2938,17 @@ var entity_audit_exports = {};
 __export(entity_audit_exports, {
   runEntityAudit: () => runEntityAudit
 });
-import { readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
-import { join as join16 } from "path";
-import { tool as tool11 } from "ai";
+import { readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
+import { join as join18 } from "path";
+import { tool as tool12 } from "ai";
 import { glob as glob4 } from "glob";
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 function buildRegisterModelsTool(tracker) {
-  return tool11({
+  return tool12({
     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: z13.object({
-      models: z13.array(z13.string()).describe("All model/table names found by grep"),
-      framework: z13.string().describe("Database framework detected (e.g. 'sqlalchemy', 'prisma', 'drizzle')")
+    inputSchema: z15.object({
+      models: z15.array(z15.string()).describe("All model/table names found by grep"),
+      framework: z15.string().describe("Database framework detected (e.g. 'sqlalchemy', 'prisma', 'drizzle')")
     }),
     execute: async (input) => {
       tracker.register(input.models);
@@ -2531,9 +2962,9 @@ function buildRegisterModelsTool(tracker) {
   });
 }
 function buildNextModelTool(tracker) {
-  return tool11({
+  return tool12({
     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: z13.object({}),
+    inputSchema: z15.object({}),
     execute: async () => {
       const next = tracker.nextModel();
       if (!next) {
@@ -2551,19 +2982,19 @@ function buildNextModelTool(tracker) {
   });
 }
 function buildMarkModelAuditedTool(tracker) {
-  return tool11({
+  return tool12({
     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: z13.object({
-      model: z13.string().describe("Model name"),
-      independently_created: z13.boolean(),
-      creation_file: z13.string().optional().describe("File containing the creation function"),
-      creation_function: z13.string().optional().describe("Function/method name (e.g. 'UserService.create' or 'create_user')"),
-      side_effects: z13.array(z13.string()).optional().describe("Side effects of creation (e.g. 'creates default Settings row', 'hashes password')"),
-      created_by: z13.array(
-        z13.object({
-          owner: z13.string().describe("Owner model name"),
-          via: z13.string().optional().describe("Function that creates this model (e.g. 'OrganizationService.create')"),
-          why: z13.string().optional().describe("One sentence explaining why this model is created as a side effect")
+    inputSchema: z15.object({
+      model: z15.string().describe("Model name"),
+      independently_created: z15.boolean(),
+      creation_file: z15.string().optional().describe("File containing the creation function"),
+      creation_function: z15.string().optional().describe("Function/method name (e.g. 'UserService.create' or 'create_user')"),
+      side_effects: z15.array(z15.string()).optional().describe("Side effects of creation (e.g. 'creates default Settings row', 'hashes password')"),
+      created_by: z15.array(
+        z15.object({
+          owner: z15.string().describe("Owner model name"),
+          via: z15.string().optional().describe("Function that creates this model (e.g. 'OrganizationService.create')"),
+          why: z15.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")
     }),
@@ -2600,18 +3031,18 @@ function buildMarkModelAuditedTool(tracker) {
   });
 }
 function buildModelCoverageTool(tracker) {
-  return tool11({
+  return tool12({
     description: "Check how many registered models you've audited vs how many remain.",
-    inputSchema: z13.object({}),
+    inputSchema: z15.object({}),
     execute: async () => tracker.coverage()
   });
 }
 function buildFinishTool2(tracker, onFinish) {
-  return tool11({
+  return tool12({
     description: "Call when entity audit is complete. BLOCKED if there are unaudited models - call model_coverage first to check.",
-    inputSchema: z13.object({
-      summary: z13.string().describe("Summary of the audit"),
-      artifacts: z13.array(z13.string()).describe("Files written")
+    inputSchema: z15.object({
+      summary: z15.string().describe("Summary of the audit"),
+      artifacts: z15.array(z15.string()).describe("Files written")
     }),
     execute: async (input) => {
       const cov = tracker.coverage();
@@ -2639,7 +3070,7 @@ async function findPrismaSchema(projectRoot) {
   return candidates[0] ?? void 0;
 }
 async function extractPrismaModels(schemaPath) {
-  const content = await readFile10(schemaPath, "utf-8");
+  const content = await readFile12(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) {
@@ -2662,8 +3093,11 @@ async function runEntityAudit(input) {
     tracker.initQueue();
     preRegisteredCount = detection.models.length;
   }
-  const { logger, onStepFinish } = buildDefaultStepLogger("entity-audit", 200);
-  const contextBlock = (input.projectContext ? "\n" + formatContext(input.projectContext) + "\n" : "") + formatRetryGuidance(input.retryGuidance);
+  const { logger, onStepFinish } = buildDefaultStepLogger("entity-audit", MAX_STEPS2);
+  const scopeBlock = input.scopeHint != null ? `
+${input.scopeHint}
+` : "";
+  const contextBlock = (input.projectContext ? "\n" + formatContext(input.projectContext) + "\n" : "") + scopeBlock + formatRetryGuidance(input.retryGuidance);
   const preRegBlock = preRegisteredCount > 0 ? `
 ## Pre-registered models (${preRegisteredCount} found via ${detection.framework} schema at ${detection.schemaFile})
 
@@ -2693,9 +3127,9 @@ After every 10 mark_model_audited calls, use write_file to update entity-audit.m
 write_file already targets the output directory - use just the filename.`;
   const agentConfig = {
     id: "entity-audit",
-    systemPrompt: SYSTEM_PROMPT3,
+    systemPrompt: SYSTEM_PROMPT4,
     model,
-    maxSteps: 200,
+    maxSteps: MAX_STEPS2,
     tools: async (heartbeat) => {
       const tools = await buildCodebaseTools(model, input.projectRoot, input.outputDir, heartbeat);
       return {
@@ -2723,8 +3157,8 @@ ${formatException(err)}`);
   logger.summary();
   const writeCanonicalAudit = async () => {
     if (tracker.auditedModels.size === 0) return void 0;
-    const auditPath = join16(input.outputDir, "entity-audit.md");
-    await writeFile5(auditPath, tracker.generateAuditMarkdown(), "utf-8");
+    const auditPath = join18(input.outputDir, "entity-audit.md");
+    await writeFile7(auditPath, tracker.generateAuditMarkdown(), "utf-8");
     return auditPath;
   };
   const canonicalPath = await writeCanonicalAudit();
@@ -2761,9 +3195,9 @@ When done with changes, call finish again.`;
     }
   });
   if (!reviewed) {
-    const auditPath = join16(input.outputDir, "entity-audit.md");
+    const auditPath = join18(input.outputDir, "entity-audit.md");
     try {
-      await readFile10(auditPath, "utf-8");
+      await readFile12(auditPath, "utf-8");
       return {
         success: true,
         artifacts: ["entity-audit.md"],
@@ -2779,7 +3213,7 @@ When done with changes, call finish again.`;
     summary: agentError ? `Entity audit failed: ${agentError}` : "Entity audit agent stopped without producing entity-audit.md"
   };
 }
-var ModelTracker;
+var MAX_STEPS2, ModelTracker;
 var init_entity_audit = __esm({
   "src/agents/02-entity-audit/index.ts"() {
     "use strict";
@@ -2794,6 +3228,7 @@ var init_entity_audit = __esm({
     init_ask_user();
     init_audit_table();
     init_prompt2();
+    MAX_STEPS2 = 400;
     ModelTracker = class {
       registered = /* @__PURE__ */ new Set();
       auditedModels = /* @__PURE__ */ new Map();
@@ -2904,11 +3339,11 @@ ${duals.length > 0 ? duals.map((m) => `- **${m.name}** - standalone: ${m.creatio
 });
 
 // src/core/parse-entity-audit.ts
-import { readFile as readFile11 } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join19 } from "path";
 async function parseEntityNames(outputDir) {
   try {
-    const content = await readFile11(join17(outputDir, "entity-audit.md"), "utf-8");
+    const content = await readFile13(join19(outputDir, "entity-audit.md"), "utf-8");
     const names = [];
     for (const line of content.split("\n")) {
       const match = line.match(/^\s+-\s+name:\s+(.+)$/);
@@ -2981,13 +3416,13 @@ values; the recipe builder generates the exact records from what you write.`;
 });
 
 // src/agents/03-scenario-recipe/scenario-table.ts
-import { readFile as readFile12 } from "fs/promises";
-import { join as join18 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join20 } from "path";
 import matter3 from "gray-matter";
 async function parseScenario(outputDir) {
   let raw;
   try {
-    raw = await readFile12(join18(outputDir, "scenarios.md"), "utf-8");
+    raw = await readFile14(join20(outputDir, "scenarios.md"), "utf-8");
   } catch {
     return { scenarioNames: [], entityTypes: [] };
   }
@@ -3068,22 +3503,22 @@ __export(scenario_recipe_exports, {
   feedbackToScenario: () => feedbackToScenario,
   runScenarioRecipe: () => runScenarioRecipe
 });
-import { readFile as readFile13 } from "fs/promises";
-import { join as join19 } from "path";
-import { tool as tool12 } from "ai";
-import { z as z14 } from "zod";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join21 } from "path";
+import { tool as tool13 } from "ai";
+import { z as z16 } from "zod";
 function buildFinishTool3(requiredEntities, outputDir, onFinish) {
-  return tool12({
+  return tool13({
     description: "Call when scenario design is complete and scenarios.md is written. BLOCKED if any required entities are missing from the scenario.",
-    inputSchema: z14.object({
-      summary: z14.string().describe("Summary of the scenario"),
-      entityCount: z14.number().describe("Number of entity types in the scenario"),
-      artifacts: z14.array(z14.string()).describe("Files written")
+    inputSchema: z16.object({
+      summary: z16.string().describe("Summary of the scenario"),
+      entityCount: z16.number().describe("Number of entity types in the scenario"),
+      artifacts: z16.array(z16.string()).describe("Files written")
     }),
     execute: async (input) => {
       let content;
       try {
-        content = await readFile13(join19(outputDir, "scenarios.md"), "utf-8");
+        content = await readFile15(join21(outputDir, "scenarios.md"), "utf-8");
       } catch {
         return { error: "Cannot finish: scenarios.md not found. Write it first." };
       }
@@ -3118,7 +3553,10 @@ async function runScenarioRecipe(input) {
   const model = getModel(input.modelId);
   let result;
   const { logger, onStepFinish } = buildDefaultStepLogger("scenario", 40);
-  const contextBlock = (input.projectContext ? "\n" + formatContext(input.projectContext) + "\n" : "") + formatRetryGuidance(input.retryGuidance);
+  const scopeBlock = input.scopeHint != null ? `
+${input.scopeHint}
+` : "";
+  const contextBlock = (input.projectContext ? "\n" + formatContext(input.projectContext) + "\n" : "") + scopeBlock + formatRetryGuidance(input.retryGuidance);
   const requiredEntities = await parseEntityNames(input.outputDir);
   const entityListBlock = requiredEntities.length > 0 ? `
 ## Required entities (${requiredEntities.length} total - ALL must appear in the scenario)
@@ -3180,9 +3618,9 @@ When done with changes, call finish again.`;
     }
   });
   if (!reviewed) {
-    const scenariosPath = join19(input.outputDir, "scenarios.md");
+    const scenariosPath = join21(input.outputDir, "scenarios.md");
     try {
-      await readFile13(scenariosPath, "utf-8");
+      await readFile15(scenariosPath, "utf-8");
       return {
         success: true,
         artifacts: ["scenarios.md"],
@@ -3243,7 +3681,7 @@ var init_scenario_recipe = __esm({
 
 // src/agents/04-recipe-builder/entity-relevance.ts
 import { Output, generateText } from "ai";
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 async function callRanker(model, prompt) {
   const result = await generateText({
     model,
@@ -3331,19 +3769,19 @@ var init_entity_relevance = __esm({
     init_esm_shims();
     init_errors();
     init_model();
-    rankedSchema = z15.object({
-      ranked: z15.array(z15.string()).describe("Every entity name, ordered most-important first.")
+    rankedSchema = z17.object({
+      ranked: z17.array(z17.string()).describe("Every entity name, ordered most-important first.")
     });
   }
 });
 
 // src/core/detect-pkg-manager.ts
 import { existsSync as existsSync2 } from "fs";
-import { join as join20 } from "path";
+import { join as join22 } 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(join22(projectRoot, "bun.lock")) || existsSync2(join22(projectRoot, "bun.lockb"))) return "bun";
+  if (existsSync2(join22(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join22(projectRoot, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function installCommand(pm, ...packages) {
@@ -3404,33 +3842,17 @@ var init_highlight = __esm({
       title: "\x1B[36m",
       literal: "\x1B[35m",
       attr: "",
-      params: "",
-      function: "\x1B[36m",
-      property: "",
-      punctuation: "\x1B[2m",
-      operator: "",
-      variable: "",
-      subst: "\x1B[36m",
-      "template-variable": "\x1B[36m",
-      meta: "\x1B[2m",
-      regexp: "\x1B[31m"
-    };
-  }
-});
-
-// src/core/to-record.ts
-function toRecord(value) {
-  if (typeof value !== "object" || value === null) return {};
-  const record = {};
-  for (const [key, entry] of Object.entries(value)) {
-    record[key] = entry;
-  }
-  return record;
-}
-var init_to_record = __esm({
-  "src/core/to-record.ts"() {
-    "use strict";
-    init_esm_shims();
+      params: "",
+      function: "\x1B[36m",
+      property: "",
+      punctuation: "\x1B[2m",
+      operator: "",
+      variable: "",
+      subst: "\x1B[36m",
+      "template-variable": "\x1B[36m",
+      meta: "\x1B[2m",
+      regexp: "\x1B[31m"
+    };
   }
 });
 
@@ -3569,7 +3991,7 @@ function validateRecipeAgainstSchema(recipe, schema) {
         }
       }
       const refs = /* @__PURE__ */ new Set();
-      collectRefs(record, refs);
+      collectRefs2(record, refs);
       for (const alias of refs) {
         if (!declaredAliases.has(alias)) {
           problems.push({
@@ -3583,16 +4005,16 @@ function validateRecipeAgainstSchema(recipe, schema) {
   }
   return problems;
 }
-function collectRefs(value, out) {
+function collectRefs2(value, out) {
   if (Array.isArray(value)) {
-    for (const v of value) collectRefs(v, out);
+    for (const v of value) collectRefs2(v, out);
   } else if (value !== null && typeof value === "object") {
     const obj = toRecord(value);
     if (typeof obj._ref === "string") {
       out.add(obj._ref);
       return;
     }
-    for (const v of Object.values(obj)) collectRefs(v, out);
+    for (const v of Object.values(obj)) collectRefs2(v, out);
   }
 }
 function formatValidationProblems(problems) {
@@ -3613,96 +4035,9 @@ var init_discover_schema = __esm({
   }
 });
 
-// src/agents/04-recipe-builder/recipe.ts
-import { readFile as readFile14, writeFile as writeFile6 } from "fs/promises";
-import { join as join21 } from "path";
-function collectRefs2(value, out) {
-  if (Array.isArray(value)) {
-    for (const v of value) collectRefs2(v, out);
-  } else if (value !== null && typeof value === "object") {
-    const obj = toRecord(value);
-    if (typeof obj._ref === "string") out.add(obj._ref);
-    for (const v of Object.values(obj)) collectRefs2(v, out);
-  }
-}
-function buildSingleEntityRecipe(entityName, models, entityOrder, allEntities) {
-  const modelMap = new Map(models.map((m) => [m.name, m]));
-  const aliasOwner = /* @__PURE__ */ new Map();
-  for (const [name, entity] of Object.entries(allEntities)) {
-    for (const rec of entity?.recipeData ?? []) {
-      if (typeof rec._alias === "string") aliasOwner.set(rec._alias, name);
-    }
-  }
-  const recipe = {};
-  const done = /* @__PURE__ */ new Set();
-  const onStack = /* @__PURE__ */ new Set();
-  function include(name) {
-    if (done.has(name) || onStack.has(name)) return;
-    onStack.add(name);
-    const records = allEntities[name]?.recipeData ?? [];
-    for (const dep of modelMap.get(name)?.created_by ?? []) {
-      if (entityOrder.includes(dep.owner)) include(dep.owner);
-    }
-    const refs = /* @__PURE__ */ new Set();
-    collectRefs2(records, refs);
-    for (const alias of refs) {
-      const owner = aliasOwner.get(alias);
-      if (owner && owner !== name) include(owner);
-    }
-    onStack.delete(name);
-    done.add(name);
-    if (records.length > 0) recipe[name] = records;
-  }
-  include(entityName);
-  return recipe;
-}
-function buildFullRecipe(entityOrder, allEntities) {
-  const recipe = {};
-  for (const name of entityOrder) {
-    const entity = allEntities[name];
-    if (entity?.recipeData && entity.recipeData.length > 0) {
-      recipe[name] = entity.recipeData;
-    }
-  }
-  return recipe;
-}
-function buildSubmittableRecipe(create, description) {
-  return {
-    version: 1,
-    source: {
-      discoverPath: "discover.json",
-      scenariosPath: "scenarios.md"
-    },
-    validationMode: "endpoint-lifecycle",
-    recipes: [
-      {
-        name: "standard",
-        description,
-        create,
-        validation: {
-          status: "validated",
-          method: "endpoint-up-down"
-        }
-      }
-    ]
-  };
-}
-async function saveRecipe(outputDir, recipe) {
-  await writeFile6(join21(outputDir, RECIPE_FILE), JSON.stringify(recipe, null, 2), "utf-8");
-}
-var RECIPE_FILE;
-var init_recipe = __esm({
-  "src/agents/04-recipe-builder/recipe.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_to_record();
-    RECIPE_FILE = "recipe.json";
-  }
-});
-
 // src/agents/04-recipe-builder/state.ts
-import { readFile as readFile15, writeFile as writeFile7 } from "fs/promises";
-import { join as join22 } from "path";
+import { readFile as readFile16, writeFile as writeFile8 } from "fs/promises";
+import { join as join23 } from "path";
 function adapterKey(a) {
   return `${a.language}:${a.framework}`;
 }
@@ -3724,7 +4059,7 @@ function initialRecipeState() {
 }
 async function loadRecipeState(outputDir) {
   try {
-    const raw = await readFile15(join22(outputDir, STATE_FILE2), "utf-8");
+    const raw = await readFile16(join23(outputDir, STATE_FILE2), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch {
@@ -3732,7 +4067,7 @@ async function loadRecipeState(outputDir) {
   }
 }
 async function saveRecipeState(outputDir, state) {
-  await writeFile7(join22(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
+  await writeFile8(join23(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
 }
 var ALL_ADAPTERS, ADAPTER_HINTS, STATE_FILE2;
 var init_state = __esm({
@@ -3804,7 +4139,7 @@ var init_state = __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";
+import { z as z18 } 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 - the factory tried to insert the recipe records.`;
@@ -3864,11 +4199,11 @@ var init_failure_classifier = __esm({
     init_esm_shims();
     init_errors();
     init_model();
-    classificationSchema = z16.object({
-      side: z16.enum(["recipe", "implementation", "unclear"]).describe(
+    classificationSchema = z18.object({
+      side: z18.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.")
+      reason: z18.string().describe("One short, plain-language sentence explaining the verdict for the user. No code, no jargon dumps.")
     });
     PRIMER = `## Background - what you are looking at
 
@@ -3883,13 +4218,13 @@ So a failure has exactly two possible origins, and your only job is to tell them
 });
 
 // src/agents/04-recipe-builder/phases/entity-loop.ts
-import { writeFile as writeFile8, readFile as readFile16 } from "fs/promises";
+import { writeFile as writeFile9, readFile as readFile17 } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join23 } from "path";
-import * as p4 from "@clack/prompts";
-import { tool as tool13 } from "ai";
+import { join as join24 } from "path";
+import * as p5 from "@clack/prompts";
+import { tool as tool14 } from "ai";
 import spawn2 from "cross-spawn";
-import { z as z17 } from "zod";
+import { z as z19 } 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");
 }
@@ -3904,10 +4239,10 @@ function summarizeEntityAudit(model) {
 async function proposeRecipeData(entityName, entityIndex, totalEntities, model, outputDir, _projectRoot, completedEntities, schemaSpec) {
   let result;
   const { logger, onStepFinish } = buildDefaultStepLogger(`propose:${entityName}`, 20);
-  const finishTool = tool13({
+  const finishTool = tool14({
     description: "Submit the proposed recipe data as a JSON array of records.",
-    inputSchema: z17.object({
-      records: z17.array(z17.record(z17.string(), z17.unknown())).describe("Array of record objects for this entity")
+    inputSchema: z19.object({
+      records: z19.array(z19.record(z19.string(), z19.unknown())).describe("Array of record objects for this entity")
     }),
     execute: async (input) => {
       result = input.records;
@@ -3950,10 +4285,10 @@ Call finish with the JSON array of records.`;
 }
 async function reviseRecipeData(entityName, entityIndex, totalEntities, current, feedback, model, outputDir, completedEntities, schemaSpec) {
   let revised;
-  const finishTool = tool13({
+  const finishTool = tool14({
     description: "Submit the fixed recipe data.",
-    inputSchema: z17.object({
-      records: z17.array(z17.record(z17.string(), z17.unknown()))
+    inputSchema: z19.object({
+      records: z19.array(z19.record(z19.string(), z19.unknown()))
     }),
     execute: async (input) => {
       revised = input.records;
@@ -4002,19 +4337,19 @@ Read scenarios.md and entity-audit.md to understand the correct aliases and sche
   );
   logger.summary();
   if (revised) {
-    p4.note(JSON.stringify(revised, null, 2), `Fixed data for ${entityName}`, { format: codeNoteFormat });
+    p5.note(JSON.stringify(revised, null, 2), `Fixed data for ${entityName}`, { format: codeNoteFormat });
     return revised;
   }
-  p4.log.warn("Could not auto-fix. Returning original data.");
+  p5.log.warn("Could not auto-fix. Returning original data.");
   return current;
 }
 async function generateInstructions(entityName, entityIndex, totalEntities, isFirst, techStack, auditModel, recipeData, model, projectRoot, outputDir) {
   let result;
   const { logger, onStepFinish } = buildDefaultStepLogger(`instructions:${entityName}`, 15);
-  const finishTool = tool13({
+  const finishTool = tool14({
     description: "Submit the implementation instructions.",
-    inputSchema: z17.object({
-      instructions: z17.string().describe("Complete, copy-pasteable implementation instructions")
+    inputSchema: z19.object({
+      instructions: z19.string().describe("Complete, copy-pasteable implementation instructions")
     }),
     execute: async (input) => {
       result = input.instructions;
@@ -4072,20 +4407,20 @@ Read the creation file from the project to understand the existing service/funct
   return result ?? "No instructions generated. Check the entity audit for creation_file and creation_function.";
 }
 async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed, model, outputDir, completedEntities, schemaSpec) {
-  p4.log.info(
+  p5.log.info(
     `Legend for recipe fields:
   _alias - Internal ID used to reference this record from other entities (e.g., { "_ref": "org_1" })
   _ref   - Reference to a record created by a parent entity's _alias
   All other fields are the actual data that will be inserted into your database.`
   );
-  p4.note(JSON.stringify(proposed, null, 2), `Proposed data for ${entityName} (${proposed.length} records)`, {
+  p5.note(JSON.stringify(proposed, null, 2), `Proposed data for ${entityName} (${proposed.length} records)`, {
     format: codeNoteFormat
   });
-  p4.log.info(
+  p5.log.info(
     "Review checklist:\n  - Do field values match your real data patterns?\n  - Are _ref references pointing to correct parent aliases?\n  - Are enum fields varied across records (not all the same value)?\n  - Are there enough records for your test scenarios?"
   );
   while (true) {
-    const action = await p4.select({
+    const action = await p5.select({
       message: `[${entityIndex + 1}/${totalEntities}] ${entityName} - does this data look right?`,
       options: [
         { value: "keep", label: "Yes, keep" },
@@ -4093,40 +4428,40 @@ async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed
         { value: "edit", label: "No, edit manually" }
       ]
     });
-    if (p4.isCancel(action)) throw new Error("Recipe review cancelled");
+    if (p5.isCancel(action)) throw new Error("Recipe review cancelled");
     if (action === "keep") return proposed;
     if (action === "edit") {
-      const tmpPath = join23(tmpdir(), `autonoma-recipe-${entityName}.json`);
-      await writeFile8(tmpPath, JSON.stringify(proposed, null, 2), "utf-8");
+      const tmpPath = join24(tmpdir(), `autonoma-recipe-${entityName}.json`);
+      await writeFile9(tmpPath, JSON.stringify(proposed, null, 2), "utf-8");
       const env = readEnv();
       const editor = env.EDITOR ?? env.VISUAL ?? "vi";
-      p4.log.info(`Opening ${editor}... Save and close when done.`);
-      const launched = await new Promise((resolve5) => {
+      p5.log.info(`Opening ${editor}... Save and close when done.`);
+      const launched = await new Promise((resolve6) => {
         const proc = spawn2(editor, [tmpPath], { stdio: "inherit" });
-        proc.on("close", () => resolve5(true));
+        proc.on("close", () => resolve6(true));
         proc.on("error", (err) => {
-          p4.log.error(
+          p5.log.error(
             `Couldn't open ${editor} (${err.message}). Edit this file manually, then choose "edit" again: ${tmpPath}`
           );
-          resolve5(false);
+          resolve6(false);
         });
       });
       if (!launched) continue;
-      const edited = await readFile16(tmpPath, "utf-8");
+      const edited = await readFile17(tmpPath, "utf-8");
       try {
         proposed = JSON.parse(edited);
-        p4.note(JSON.stringify(proposed, null, 2), `Updated data for ${entityName}`, { format: codeNoteFormat });
+        p5.note(JSON.stringify(proposed, null, 2), `Updated data for ${entityName}`, { format: codeNoteFormat });
       } catch (err) {
-        p4.log.error(`Invalid JSON: ${err instanceof Error ? err.message : String(err)}. Try again.`);
+        p5.log.error(`Invalid JSON: ${err instanceof Error ? err.message : String(err)}. Try again.`);
       }
       continue;
     }
     if (action === "chat") {
-      const feedback = await p4.text({
+      const feedback = await p5.text({
         message: "What should be changed?",
         placeholder: "e.g., add more records, change field values, fix references..."
       });
-      if (p4.isCancel(feedback) || !feedback.trim()) continue;
+      if (p5.isCancel(feedback) || !feedback.trim()) continue;
       proposed = await reviseRecipeData(
         entityName,
         entityIndex,
@@ -4166,14 +4501,14 @@ async function promptOnFailure(entityName, errorBody, ctx, phase, httpStatus) {
   });
   if (ctx.budget.attempts < MAX_AUTOFIX_ATTEMPTS) {
     ctx.budget.attempts++;
-    p4.log.info(`Triage: ${reason}`);
-    p4.log.info(
+    p5.log.info(`Triage: ${reason}`);
+    p5.log.info(
       `Handing the failure to the agent to fix from the error (attempt ${ctx.budget.attempts}/${MAX_AUTOFIX_ATTEMPTS})...`
     );
     return seedFeedbackFromError(errorContext, reason);
   }
-  p4.log.warn(`The agent tried ${MAX_AUTOFIX_ATTEMPTS}\xD7 without resolving it. Latest triage: ${reason}`);
-  const action = await p4.select({
+  p5.log.warn(`The agent tried ${MAX_AUTOFIX_ATTEMPTS}\xD7 without resolving it. Latest triage: ${reason}`);
+  const action = await p5.select({
     message: "What would you like to do?",
     options: [
       { value: "retry", label: "Yes, retry - I fixed my handler code", hint: "Send the same request again" },
@@ -4190,22 +4525,22 @@ async function promptOnFailure(entityName, errorBody, ctx, phase, httpStatus) {
       { value: "skip", label: "No, skip this entity", hint: "Move on to the next entity" }
     ]
   });
-  if (p4.isCancel(action)) throw new Error("Entity loop cancelled");
+  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, reason);
   }
-  const fb = await p4.text({
+  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 (p4.isCancel(fb)) throw new Error("Entity loop cancelled");
+  if (p5.isCancel(fb)) throw new Error("Entity loop cancelled");
   return { feedback: `${fb.trim()}${errorContext}` };
 }
 async function testUpDown(entityName, entityIndex, totalEntities, sdkConfig, recipe, grounding, discoverSchema) {
-  p4.log.info(
+  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 };
@@ -4215,7 +4550,7 @@ async function testUpDown(entityName, entityIndex, totalEntities, sdkConfig, rec
       if (problems.length > 0) {
         const errorBody = `Recipe failed local schema validation against /discover (not sent to the server):
 ${formatValidationProblems(problems)}`;
-        p4.log.error(errorBody);
+        p5.log.error(errorBody);
         const action = await promptOnFailure(entityName, errorBody, failureCtx, "create");
         if (action === "skip") return "skip";
         if (action === "retry") continue;
@@ -4223,12 +4558,12 @@ ${formatValidationProblems(problems)}`;
       }
     }
     const testRunId = `test-${Date.now()}`;
-    p4.log.step(`[${entityIndex + 1}/${totalEntities}] Sending UP request...`);
+    p5.log.step(`[${entityIndex + 1}/${totalEntities}] Sending UP request...`);
     let upResult;
     try {
       upResult = await up(sdkConfig, recipe, testRunId);
     } catch (err) {
-      p4.log.error(`UP request failed:
+      p5.log.error(`UP request failed:
 ${formatException(err)}`);
       const action = await promptOnFailure(entityName, formatException(err), failureCtx, "create");
       if (action === "skip") return "skip";
@@ -4236,29 +4571,29 @@ ${formatException(err)}`);
       return action;
     }
     if (!upResult.ok) {
-      p4.log.error(`UP failed (HTTP ${upResult.status}):`);
+      p5.log.error(`UP failed (HTTP ${upResult.status}):`);
       console.log(JSON.stringify(upResult.body, null, 2));
       const action = await promptOnFailure(entityName, upResult.body, failureCtx, "create", upResult.status);
       if (action === "skip") return "skip";
       if (action === "retry") continue;
       return action;
     }
-    p4.log.success(`UP succeeded!`);
+    p5.log.success(`UP succeeded!`);
     console.log(JSON.stringify(upResult.body, null, 2));
     const refsTokenValue = toRecord(upResult.body).refsToken;
     const refsToken = typeof refsTokenValue === "string" ? refsTokenValue : void 0;
     if (!refsToken) {
-      p4.log.error("No refsToken in UP response - cannot test DOWN.");
+      p5.log.error("No refsToken in UP response - cannot test DOWN.");
       return "skip";
     }
-    p4.log.info("Now let's verify teardown works - leftover test data would pollute your database.");
+    p5.log.info("Now let's verify teardown works - leftover test data would pollute your database.");
     while (true) {
-      p4.log.step(`[${entityIndex + 1}/${totalEntities}] Sending DOWN request...`);
+      p5.log.step(`[${entityIndex + 1}/${totalEntities}] Sending DOWN request...`);
       let downResult;
       try {
         downResult = await down(sdkConfig, refsToken);
       } catch (err) {
-        p4.log.error(`DOWN request failed:
+        p5.log.error(`DOWN request failed:
 ${formatException(err)}`);
         const action = await promptOnFailure(entityName, formatException(err), failureCtx, "teardown");
         if (action === "skip") return "skip";
@@ -4266,7 +4601,7 @@ ${formatException(err)}`);
         return action;
       }
       if (!downResult.ok) {
-        p4.log.error(`DOWN failed (HTTP ${downResult.status}):`);
+        p5.log.error(`DOWN failed (HTTP ${downResult.status}):`);
         console.log(JSON.stringify(downResult.body, null, 2));
         const action = await promptOnFailure(
           entityName,
@@ -4279,7 +4614,7 @@ ${formatException(err)}`);
         if (action === "retry") continue;
         return action;
       }
-      p4.log.success("DOWN succeeded!");
+      p5.log.success("DOWN succeeded!");
       return "success";
     }
   }
@@ -4296,7 +4631,7 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
     if (!schema) return {};
     return { schema, spec: renderModelSchema(schema, name) ?? void 0 };
   }
-  p4.log.info(
+  p5.log.info(
     `We're going to set up your test data factories one entity at a time. Each factory teaches the Autonoma SDK how to create and tear down a specific type of record in YOUR database, using YOUR existing service functions.
 
   We'll test each one live before moving on - this way if something breaks, you'll know exactly which entity caused it. Let's start with the root entities (no dependencies), then work through the dependents.`
@@ -4305,7 +4640,7 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
     const entityName = state.entityOrder[i];
     const auditModel = modelMap.get(entityName);
     if (!auditModel) {
-      p4.log.warn(`[${i + 1}/${total}] ${entityName} - not found in entity audit, skipping`);
+      p5.log.warn(`[${i + 1}/${total}] ${entityName} - not found in entity audit, skipping`);
       state.entities[entityName] = {
         entityName,
         status: "skipped",
@@ -4317,13 +4652,13 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
     }
     const existing = state.entities[entityName];
     if (existing?.status === "tested-down") {
-      p4.log.info(`[${i + 1}/${total}] ${entityName} - already done, skipping`);
+      p5.log.info(`[${i + 1}/${total}] ${entityName} - already done, skipping`);
       continue;
     }
     const isRoot = auditModel.created_by.length === 0;
     const depInfo = isRoot ? "This is a root entity - no dependencies." : `This depends on: ${auditModel.created_by.map((d) => d.owner).join(", ")}`;
-    p4.log.step(`[${i + 1}/${total}] ${entityName}`);
-    p4.log.info(depInfo);
+    p5.log.step(`[${i + 1}/${total}] ${entityName}`);
+    p5.log.info(depInfo);
     const { spec: recipeSchemaSpec } = await loadLiveSchema(entityName);
     let recipeData = existing?.recipeData;
     if (!recipeData || existing?.status === "pending") {
@@ -4372,28 +4707,28 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
         outputDir
       );
       const DOCS_BASE2 = "https://docs.autonoma.app";
-      p4.log.info(
+      p5.log.info(
         `Next: implement the ${entityName} factory. The block below is a copy-paste guide -
   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)`, {
+      p5.note(instructions, `Implementation guide for ${entityName} (paste into your AI assistant)`, {
         format: codeNoteFormat
       });
-      p4.log.info(`Autonoma SDK docs: ${DOCS_BASE2}/sdk/environment-factory`);
+      p5.log.info(`Autonoma SDK docs: ${DOCS_BASE2}/sdk/environment-factory`);
       if (i === 0) {
-        p4.log.info(
+        p5.log.info(
           "This is your first factory - the guide includes one-time SDK setup. Later entities only need the factory function."
         );
       }
       notify("Autonoma", `${entityName} - implementation ready, waiting for you`);
-      const ready = await p4.confirm({
+      const ready = await p5.confirm({
         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 (p5.isCancel(ready)) throw new Error("Entity loop cancelled");
       if (!ready) {
-        p4.log.info("Take your time implementing. Run again with --resume to continue from here.");
+        p5.log.info("Take your time implementing. Run again with --resume to continue from here.");
         return;
       }
     }
@@ -4404,41 +4739,41 @@ async function runEntityLoop(state, models, model, projectRoot, outputDir, nonIn
         const secret = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
         state.sharedSecret = secret;
         await saveRecipeState(outputDir, state);
-        await writeFile8(
-          join23(outputDir, "autonoma-config.json"),
+        await writeFile9(
+          join24(outputDir, "autonoma-config.json"),
           JSON.stringify({ sharedSecret: secret, endpointUrl: state.sdkEndpointUrl }, null, 2),
           "utf-8"
         );
-        p4.note(
+        p5.note(
           `AUTONOMA_SHARED_SECRET=${secret}
 
 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: ${join23(outputDir, "autonoma-config.json")}`,
+Saved to: ${join24(outputDir, "autonoma-config.json")}`,
           "Shared secret generated"
         );
-        const secretReady = await p4.confirm({
+        const secretReady = await p5.confirm({
           message: "Did you add the secret to your .env and restart the server?"
         });
-        if (p4.isCancel(secretReady)) throw new Error("Entity loop cancelled");
+        if (p5.isCancel(secretReady)) throw new Error("Entity loop cancelled");
         if (!secretReady) {
-          p4.log.info("Add the secret and run again with --resume to continue.");
+          p5.log.info("Add the secret and run again with --resume to continue.");
           return;
         }
       }
       if (!state.sdkEndpointUrl) {
-        const url = await p4.text({
+        const url = await p5.text({
           message: "What's your SDK endpoint URL?",
           placeholder: "http://localhost:3000/api/autonoma",
           defaultValue: "http://localhost:3000/api/autonoma"
         });
-        if (p4.isCancel(url)) throw new Error("Entity loop cancelled");
+        if (p5.isCancel(url)) throw new Error("Entity loop cancelled");
         state.sdkEndpointUrl = url.trim() || "http://localhost:3000/api/autonoma";
         await saveRecipeState(outputDir, state);
-        await writeFile8(
-          join23(outputDir, "autonoma-config.json"),
+        await writeFile9(
+          join24(outputDir, "autonoma-config.json"),
           JSON.stringify({ sharedSecret: state.sharedSecret, endpointUrl: state.sdkEndpointUrl }, null, 2),
           "utf-8"
         );
@@ -4470,15 +4805,15 @@ Saved to: ${join23(outputDir, "autonoma-config.json")}`,
         );
         if (testResult === "success") {
           state.entities[entityName].status = "tested-down";
-          p4.log.success(`[${i + 1}/${total}] ${entityName} - factory verified`);
+          p5.log.success(`[${i + 1}/${total}] ${entityName} - factory verified`);
           testDone = true;
         } else if (testResult === "skip") {
           state.entities[entityName].status = "skipped";
           state.entities[entityName].errorLog.push("UP/DOWN test skipped by user");
-          p4.log.warn(`[${i + 1}/${total}] ${entityName} - skipped, continuing to next entity`);
+          p5.log.warn(`[${i + 1}/${total}] ${entityName} - skipped, continuing to next entity`);
           testDone = true;
         } else {
-          p4.log.info(`Re-generating recipe data for ${entityName} based on your feedback...`);
+          p5.log.info(`Re-generating recipe data for ${entityName} based on your feedback...`);
           const revised = await reviseRecipeData(
             entityName,
             i,
@@ -4553,15 +4888,15 @@ When done, call finish with the instructions text.`;
 });
 
 // src/agents/04-recipe-builder/phases/full-validation.ts
-import * as p5 from "@clack/prompts";
-import { tool as tool14 } from "ai";
-import { z as z18 } from "zod";
+import * as p6 from "@clack/prompts";
+import { tool as tool15 } from "ai";
+import { z as z20 } from "zod";
 async function reviseFullRecipe(current, feedback, model, outputDir, entityOrder, schemaSpec) {
   let revised;
-  const finishTool = tool14({
+  const finishTool = tool15({
     description: "Submit the revised full recipe: an object mapping each entity name to its array of records.",
-    inputSchema: z18.object({
-      recipe: z18.record(z18.string(), z18.array(z18.record(z18.string(), z18.unknown())))
+    inputSchema: z20.object({
+      recipe: z20.record(z20.string(), z20.array(z20.record(z20.string(), z20.unknown())))
     }),
     execute: async (input) => {
       revised = input.recipe;
@@ -4612,35 +4947,35 @@ Revise the recipe to address the feedback, then call finish with the complete up
 }
 async function teardown(sdkConfig, refsToken, successMessage) {
   if (!refsToken) return true;
-  p5.log.step("[Full validation] Tearing down all entities...");
+  p6.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:
+    p6.log.error(`Full DOWN request failed:
 ${formatException(err)}`);
     return false;
   }
   if (!downResult.ok) {
-    p5.log.error(`Full DOWN failed (HTTP ${downResult.status}):`);
+    p6.log.error(`Full DOWN failed (HTTP ${downResult.status}):`);
     console.log(JSON.stringify(downResult.body, null, 2));
     return false;
   }
-  p5.log.success(successMessage);
+  p6.log.success(successMessage);
   return true;
 }
 async function runFullValidation(state, _models, outputDir, model) {
   const total = state.entityOrder.length;
-  p5.log.info(
+  p6.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.`
   );
   if (!state.sdkEndpointUrl) {
-    const url = await p5.text({
+    const url = await p6.text({
       message: "What's your SDK endpoint URL?",
       placeholder: "http://localhost:3000/api/autonoma",
       defaultValue: "http://localhost:3000/api/autonoma"
     });
-    if (p5.isCancel(url)) throw new Error("Cancelled");
+    if (p6.isCancel(url)) throw new Error("Cancelled");
     state.sdkEndpointUrl = url.trim() || "http://localhost:3000/api/autonoma";
     await saveRecipeState(outputDir, state);
   }
@@ -4655,69 +4990,69 @@ async function runFullValidation(state, _models, outputDir, model) {
     if (discoverSchema) {
       const problems = validateRecipeAgainstSchema(fullRecipe, discoverSchema);
       if (problems.length > 0) {
-        p5.log.warn(
+        p6.log.warn(
           `Heads up - the recipe has likely schema problems (from /discover); the full UP may fail:
 ${formatValidationProblems(problems)}`
         );
       }
     }
     const testRunId = `full-${Date.now()}`;
-    p5.log.step(`[Full validation] Creating all ${total} entities...`);
+    p6.log.step(`[Full validation] Creating all ${total} entities...`);
     let upResult;
     try {
       upResult = await up(sdkConfig, fullRecipe, testRunId);
     } catch (err) {
-      p5.log.error(`Full UP request failed:
+      p6.log.error(`Full UP request failed:
 ${formatException(err)}`);
       notify("Autonoma", "Full validation UP failed, action needed");
-      const action = await p5.select({
+      const action = await p6.select({
         message: "What would you like to do?",
         options: [
           { value: "retry", label: "Yes, retry - I fixed it", hint: "Send the request again" },
           { value: "skip", label: "No, skip full validation", hint: "Continue to test generation" }
         ]
       });
-      if (p5.isCancel(action)) throw new Error("Cancelled");
+      if (p6.isCancel(action)) throw new Error("Cancelled");
       if (action === "skip") return false;
       continue;
     }
     if (!upResult.ok) {
-      p5.log.error(`Full UP failed (HTTP ${upResult.status}):`);
+      p6.log.error(`Full UP failed (HTTP ${upResult.status}):`);
       console.log(JSON.stringify(upResult.body, null, 2));
       notify("Autonoma", "Full validation UP failed, action needed");
-      const action = await p5.select({
+      const action = await p6.select({
         message: "What would you like to do?",
         options: [
           { value: "retry", label: "Yes, retry - I fixed it", hint: "Send the request again" },
           { value: "skip", label: "No, skip full validation", hint: "Continue to test generation" }
         ]
       });
-      if (p5.isCancel(action)) throw new Error("Cancelled");
+      if (p6.isCancel(action)) throw new Error("Cancelled");
       if (action === "skip") return false;
       continue;
     }
-    p5.log.success("Full UP succeeded!");
+    p6.log.success("Full UP succeeded!");
     const body = toRecord(upResult.body);
     const refsToken = typeof body.refsToken === "string" ? body.refsToken : void 0;
     const auth = body.auth != null && typeof body.auth === "object" ? toRecord(body.auth) : void 0;
     if (auth && Object.keys(auth).length > 0) {
       const authJson = JSON.stringify(auth, null, 2);
       const looksPlaceholder = authJson.includes("test-token") || authJson.includes("placeholder") || authJson.includes("todo");
-      p5.note(
+      p6.note(
         authJson + "\n\nThese are the credentials your auth callback returns.\nThe test runner will use them to authenticate as the test user when executing tests." + (looksPlaceholder ? "\n\n\u26A0 This looks like a placeholder. Update your auth callback to return real credentials\n(a valid JWT, session cookie, or email/password) so the test runner can actually log in." : ""),
         "Auth credentials"
       );
     } else {
-      p5.log.warn(
+      p6.log.warn(
         "No auth credentials returned. Your createHandler's auth callback must return credentials the test runner can use to log in (cookies, headers, or email/password). Without it, tests can't authenticate."
       );
     }
-    p5.log.info("Browse the app and check if the test data looks right.");
+    p6.log.info("Browse the app and check if the test data looks right.");
     notify("Autonoma", "Full validation succeeded - review the app");
-    const looksGood = await p5.confirm({
+    const looksGood = await p6.confirm({
       message: "Does the app look right with the test data?"
     });
-    if (p5.isCancel(looksGood)) throw new Error("Cancelled");
+    if (p6.isCancel(looksGood)) throw new Error("Cancelled");
     const torndown = await teardown(
       sdkConfig,
       refsToken,
@@ -4725,15 +5060,15 @@ ${formatException(err)}`);
     );
     if (!torndown) return false;
     if (looksGood) return true;
-    const feedback = await p5.text({
+    const feedback = await p6.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.");
+    if (p6.isCancel(feedback) || !feedback.trim()) {
+      p6.log.info("No feedback given. You can edit recipe.json manually and re-run with --resume.");
       return false;
     }
-    p5.log.info("Revising the full recipe based on your feedback...");
+    p6.log.info("Revising the full recipe based on your feedback...");
     const revised = await reviseFullRecipe(
       fullRecipe,
       feedback.trim(),
@@ -4743,7 +5078,7 @@ ${formatException(err)}`);
       fullSchemaSpec
     );
     if (!revised) {
-      p5.log.warn("Couldn't revise automatically. Edit recipe.json manually and re-run with --resume.");
+      p6.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)) {
@@ -4753,7 +5088,7 @@ ${formatException(err)}`);
     }
     await saveRecipeState(outputDir, state);
     fullRecipe = buildFullRecipe(state.entityOrder, state.entities);
-    p5.note(JSON.stringify(fullRecipe, null, 2), "Revised recipe - re-running full validation", {
+    p6.note(JSON.stringify(fullRecipe, null, 2), "Revised recipe - re-running full validation", {
       format: codeNoteFormat
     });
   }
@@ -4775,59 +5110,20 @@ var init_full_validation = __esm({
   }
 });
 
-// src/agents/04-recipe-builder/phases/submit.ts
-import * as p6 from "@clack/prompts";
-async function runSubmit(state, outputDir, autonomaApiUrl, autonomaApiToken, autonomaGenerationId) {
-  const fullCreate = buildFullRecipe(state.entityOrder, state.entities);
-  const recipe = buildSubmittableRecipe(fullCreate, "Standard test scenario with realistic data");
-  await saveRecipe(outputDir, recipe);
-  p6.log.success("Recipe saved to recipe.json");
-  if (!autonomaApiUrl || !autonomaApiToken || !autonomaGenerationId) {
-    p6.log.info(
-      "Autonoma API credentials not configured - recipe saved locally. Submit manually or configure AUTONOMA_API_URL, AUTONOMA_API_TOKEN, AUTONOMA_GENERATION_ID."
-    );
-    return "recipe.json";
-  }
-  const url = `${autonomaApiUrl}/v1/setup/setups/${autonomaGenerationId}/scenario-recipe-versions`;
-  p6.log.step("Submitting recipe to Autonoma...");
-  const res = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${autonomaApiToken}`
-    },
-    body: JSON.stringify(recipe)
-  });
-  if (res.ok) {
-    p6.log.success(`Recipe submitted successfully (HTTP ${res.status})`);
-  } else {
-    const text6 = await res.text();
-    p6.log.error(`Recipe submission failed (HTTP ${res.status}): ${text6}`);
-  }
-  return "recipe.json";
-}
-var init_submit = __esm({
-  "src/agents/04-recipe-builder/phases/submit.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_recipe();
-  }
-});
-
 // src/agents/04-recipe-builder/phases/tech-detect.ts
 import * as p7 from "@clack/prompts";
-import { tool as tool15 } from "ai";
-import { z as z19 } from "zod";
+import { tool as tool16 } from "ai";
+import { z as z21 } from "zod";
 async function detectTechStack(projectRoot, modelId, nonInteractive) {
   const model = getModel(modelId);
   const ignorePatterns = await loadGitignorePatterns(projectRoot);
   let detected;
   const { logger, onStepFinish } = buildDefaultStepLogger("tech-detect", 10);
-  const finishTool = tool15({
+  const finishTool = tool16({
     description: "Report the detected backend technology stack.",
-    inputSchema: z19.object({
-      language: z19.string().describe("Programming language: typescript, python, go, ruby, java, php, rust, elixir"),
-      framework: z19.string().describe(
+    inputSchema: z21.object({
+      language: z21.string().describe("Programming language: typescript, python, go, ruby, java, php, rust, elixir"),
+      framework: z21.string().describe(
         "Web framework: express, node, hono, web, flask, fastapi, django, gin, rails, rack, spring, laravel, axum, actix, plug"
       )
     }),
@@ -4838,7 +5134,7 @@ async function detectTechStack(projectRoot, modelId, nonInteractive) {
   });
   const agentConfig = {
     id: "tech-detect",
-    systemPrompt: SYSTEM_PROMPT4,
+    systemPrompt: SYSTEM_PROMPT5,
     model,
     maxSteps: 10,
     tools: (_heartbeat) => ({
@@ -4894,7 +5190,7 @@ async function detectTechStack(projectRoot, modelId, nonInteractive) {
   p7.log.success(`Using ${adapterLabel(adapter)} - SDK: ${adapter.sdkPackage}, Adapter: ${adapter.adapterPackage}`);
   return adapter;
 }
-var DOCS_BASE, SYSTEM_PROMPT4;
+var DOCS_BASE, SYSTEM_PROMPT5;
 var init_tech_detect = __esm({
   "src/agents/04-recipe-builder/phases/tech-detect.ts"() {
     "use strict";
@@ -4905,7 +5201,7 @@ var init_tech_detect = __esm({
     init_tools();
     init_state();
     DOCS_BASE = "https://docs.autonoma.app";
-    SYSTEM_PROMPT4 = `You are a backend technology detector. Your job is to identify the programming language and web framework used by a project's backend/API server.
+    SYSTEM_PROMPT5 = `You are a backend technology detector. Your job is to identify the programming language and web framework used by a project's backend/API server.
 
 Explore the project files to detect:
 1. The programming language (check package.json, requirements.txt, go.mod, Gemfile, pom.xml, composer.json, Cargo.toml, mix.exs)
@@ -4920,8 +5216,8 @@ var recipe_builder_exports = {};
 __export(recipe_builder_exports, {
   runRecipeBuilder: () => runRecipeBuilder
 });
-import { readFile as readFile17 } from "fs/promises";
-import { join as join24 } from "path";
+import { readFile as readFile18 } from "fs/promises";
+import { join as join25 } from "path";
 import * as p8 from "@clack/prompts";
 async function runRecipeBuilder(input) {
   const model = getModel(input.modelId);
@@ -4935,7 +5231,7 @@ async function runRecipeBuilder(input) {
     state.techStack = await detectTechStack(input.projectRoot, input.modelId, input.nonInteractive);
     let importanceRank;
     try {
-      const auditMarkdown = await readFile17(join24(input.outputDir, "entity-audit.md"), "utf-8");
+      const auditMarkdown = await readFile18(join25(input.outputDir, "entity-audit.md"), "utf-8");
       importanceRank = await rankEntitiesByImportance(models, auditMarkdown, model);
     } catch {
       importanceRank = void 0;
@@ -4993,13 +5289,21 @@ async function runRecipeBuilder(input) {
   }
   if (state.phase === "submit") {
     const env = readEnv();
-    const recipePath = await runSubmit(
+    const { recipePath, uploaded } = await runSubmit(
       state,
       input.outputDir,
       env.AUTONOMA_API_URL,
       env.AUTONOMA_API_TOKEN,
       env.AUTONOMA_GENERATION_ID
     );
+    const uploadCredentialsPresent = env.AUTONOMA_API_URL != null && env.AUTONOMA_API_TOKEN != null && env.AUTONOMA_GENERATION_ID != null;
+    if (uploadCredentialsPresent && !uploaded) {
+      return {
+        success: false,
+        artifacts: [recipePath],
+        summary: `Recipe was generated but not accepted by Autonoma. The recipe JSON was printed above - re-upload with \`npx @autonoma-ai/planner@latest upload\` (or run again with --resume).`
+      };
+    }
     state.phase = "done";
     await saveRecipeState(input.outputDir, state);
     return {
@@ -5031,21 +5335,21 @@ var init_recipe_builder = __esm({
 });
 
 // src/agents/05-test-generator/rubrics.ts
-import { z as z20 } from "zod";
+import { z as z22 } from "zod";
 function reviewResultSchema(shape) {
-  return z20.object(shape);
+  return z22.object(shape);
 }
 var dimensionResultSchema, reviewResultRecordSchema, structuralIntentRubric, flowCompletenessRubric, uiTextRubric, dataAccuracyRubric, ALL_RUBRICS;
 var init_rubrics = __esm({
   "src/agents/05-test-generator/rubrics.ts"() {
     "use strict";
     init_esm_shims();
-    dimensionResultSchema = z20.object({
-      pass: z20.boolean(),
-      evidence: z20.string().describe("What you checked and found - cite file paths, line content, or specific strings"),
-      suggestion: z20.string().optional().describe("What the planner agent should fix, if failing")
+    dimensionResultSchema = z22.object({
+      pass: z22.boolean(),
+      evidence: z22.string().describe("What you checked and found - cite file paths, line content, or specific strings"),
+      suggestion: z22.string().optional().describe("What the planner agent should fix, if failing")
     });
-    reviewResultRecordSchema = z20.record(z20.string(), dimensionResultSchema);
+    reviewResultRecordSchema = z22.record(z22.string(), dimensionResultSchema);
     structuralIntentRubric = {
       name: "structural-intent",
       maxSteps: 8,
@@ -5219,12 +5523,12 @@ When done reviewing, call finish with your structured evaluation.`
 // src/agents/05-test-generator/review-pass.ts
 import { basename as basename2 } from "path";
 import "ai";
-import { tool as tool16 } from "ai";
+import { tool as tool17 } from "ai";
 async function runReviewPass(testContent, testPath, rubric, projectRoot, model, scenarioData) {
   let result;
   const agentLabel = `review:${rubric.name}:${basename2(testPath)}`;
   const { onStepFinish } = buildDefaultStepLogger(agentLabel, rubric.maxSteps);
-  const finishTool = tool16({
+  const finishTool = tool17({
     description: "Submit your structured review. Every dimension must have evidence from your investigation.",
     inputSchema: rubric.resultSchema,
     execute: async (input) => {
@@ -5282,8 +5586,8 @@ var init_review_pass = __esm({
 });
 
 // src/agents/05-test-generator/review.ts
-import { readFile as readFile18 } from "fs/promises";
-import { join as join25, relative as relative6, basename as basename3 } from "path";
+import { readFile as readFile19 } from "fs/promises";
+import { join as join26, relative as relative6, basename as basename3 } from "path";
 import "ai";
 import { glob as glob5 } from "glob";
 async function reviewSingleTest(testContent, testPath, projectRoot, model, scenarioData) {
@@ -5312,19 +5616,19 @@ async function reviewSingleTest(testContent, testPath, projectRoot, model, scena
   return merged;
 }
 async function runConsolidatedReview(outputDir, projectRoot, model) {
-  const testsDir = join25(outputDir, "qa-tests");
+  const testsDir = join26(outputDir, "qa-tests");
   const logger = createStepLogger("review", 5);
   let scenarioData;
   try {
-    scenarioData = await readFile18(join25(outputDir, "scenarios.md"), "utf-8");
+    scenarioData = await readFile19(join26(outputDir, "scenarios.md"), "utf-8");
   } catch {
   }
-  const testFiles = await glob5(join25(testsDir, "**/*.md"));
+  const testFiles = await glob5(join26(testsDir, "**/*.md"));
   const tests = [];
   for (const testPath of testFiles) {
     if (basename3(testPath) === "INDEX.md") continue;
     if (testPath.includes("/_invalid/")) continue;
-    const content = await readFile18(testPath, "utf-8");
+    const content = await readFile19(testPath, "utf-8");
     const flowMatch = content.match(/^---\n[\s\S]*?flow:\s*["']?([^"'\n]+)["']?\s*\n[\s\S]*?---/m);
     tests.push({
       path: testPath,
@@ -5407,17 +5711,17 @@ var init_review2 = __esm({
 });
 
 // src/agents/00b-feature-discovery/index.ts
-import { readFile as readFile19, writeFile as writeFile9 } from "fs/promises";
-import { join as join26 } from "path";
-import { tool as tool17 } from "ai";
-import { z as z21 } from "zod";
+import { readFile as readFile20, writeFile as writeFile10 } from "fs/promises";
+import { join as join27 } from "path";
+import { tool as tool18 } from "ai";
+import { z as z23 } from "zod";
 async function saveFeatures(outputDir, features) {
   const obj = Object.fromEntries(features);
-  await writeFile9(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 readFile19(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 {
@@ -5441,17 +5745,17 @@ ${pagesDescription}
 Process every page. Call add_feature for each sub-feature you discover. When done, call finish.`;
   const agentConfig = {
     id: "feature-discovery",
-    systemPrompt: SYSTEM_PROMPT5,
+    systemPrompt: SYSTEM_PROMPT6,
     model,
     maxSteps: 300,
     tools: async (heartbeat) => {
       const tools = await buildCodebaseTools(model, input.projectRoot, input.outputDir, heartbeat);
       return {
         ...tools,
-        add_feature: tool17({
+        add_feature: tool18({
           description: "Add a discovered sub-feature",
           inputSchema: Feature.extend({
-            id: z21.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
+            id: z23.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
           }),
           execute: (featureInput) => {
             const { id, ...rest } = featureInput;
@@ -5463,19 +5767,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: tool17({
+        view_features: tool18({
           description: "View all discovered features so far",
-          inputSchema: z21.object({}),
+          inputSchema: z23.object({}),
           execute: () => collector.viewFeatures()
         }),
-        view_pages: tool17({
+        view_pages: tool18({
           description: "View the pages list to know what to analyze",
-          inputSchema: z21.object({}),
+          inputSchema: z23.object({}),
           execute: () => pagesDescription
         }),
-        finish: tool17({
+        finish: tool18({
           description: "Signal that feature discovery is complete",
-          inputSchema: z21.object({ summary: z21.string() }),
+          inputSchema: z23.object({ summary: z23.string() }),
           execute: async (finishInput) => {
             result = {
               success: true,
@@ -5497,7 +5801,7 @@ Process every page. Call add_feature for each sub-feature you discover. When don
   }
   return collector.features;
 }
-var FEATURES_FILE, Feature, FeatureCollector, SYSTEM_PROMPT5;
+var FEATURES_FILE, Feature, FeatureCollector, SYSTEM_PROMPT6;
 var init_b_feature_discovery = __esm({
   "src/agents/00b-feature-discovery/index.ts"() {
     "use strict";
@@ -5506,13 +5810,13 @@ var init_b_feature_discovery = __esm({
     init_model();
     init_tools();
     FEATURES_FILE = "features.json";
-    Feature = z21.object({
-      name: z21.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
-      type: z21.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
-      parentPagePath: z21.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
-      sourceFiles: z21.array(z21.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
-      interactiveElements: z21.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
-      description: z21.string().min(10).describe("What this sub-feature does")
+    Feature = z23.object({
+      name: z23.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
+      type: z23.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
+      parentPagePath: z23.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
+      sourceFiles: z23.array(z23.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
+      interactiveElements: z23.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
+      description: z23.string().min(10).describe("What this sub-feature does")
     });
     FeatureCollector = class {
       features = /* @__PURE__ */ new Map();
@@ -5543,7 +5847,7 @@ ${page}:`);
         return lines.join("\n");
       }
     };
-    SYSTEM_PROMPT5 = `You are a feature discovery agent. Your job is to explore each page's source code and discover all sub-features that deserve their own test coverage.
+    SYSTEM_PROMPT6 = `You are a feature discovery agent. Your job is to explore each page's source code and discover all sub-features that deserve their own test coverage.
 
 You will be given a list of pages. For each page, you must:
 1. Read the page's source file
@@ -5595,16 +5899,16 @@ Use kebab-case IDs that indicate the parent page and feature type:
 });
 
 // src/agents/05-test-generator/graph.ts
-import { readFile as readFile20, writeFile as writeFile10 } from "fs/promises";
-import { join as join27 } from "path";
+import { readFile as readFile21, writeFile as writeFile11 } from "fs/promises";
+import { join as join28 } from "path";
 async function saveBfsState(outputDir, state) {
-  const path3 = join27(outputDir, STATE_FILE3);
-  await writeFile10(path3, JSON.stringify(state.serialize(), null, 2), "utf-8");
+  const path3 = join28(outputDir, STATE_FILE3);
+  await writeFile11(path3, JSON.stringify(state.serialize(), null, 2), "utf-8");
 }
 async function loadBfsState(outputDir) {
-  const path3 = join27(outputDir, STATE_FILE3);
+  const path3 = join28(outputDir, STATE_FILE3);
   try {
-    const raw = await readFile20(path3, "utf-8");
+    const raw = await readFile21(path3, "utf-8");
     return CoverageState.deserialize(JSON.parse(raw));
   } catch {
     return void 0;
@@ -5695,12 +5999,12 @@ var init_graph = __esm({
 });
 
 // src/agents/05-test-generator/prompt.ts
-var SYSTEM_PROMPT6;
+var SYSTEM_PROMPT7;
 var init_prompt4 = __esm({
   "src/agents/05-test-generator/prompt.ts"() {
     "use strict";
     init_esm_shims();
-    SYSTEM_PROMPT6 = `You are an E2E test generator that explores a frontend codebase as a BFS graph. You are ONE long-running agent that maintains all state about what's been explored and what hasn't.
+    SYSTEM_PROMPT7 = `You are an E2E test generator that explores a frontend codebase as a BFS graph. You are ONE long-running agent that maintains all state about what's been explored and what hasn't.
 
 ## Your process
 
@@ -6131,11 +6435,11 @@ var init_validation = __esm({
 });
 
 // src/agents/05-test-generator/tools.ts
-import { mkdir as mkdir3, writeFile as writeFile11 } from "fs/promises";
-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 { mkdir as mkdir3, writeFile as writeFile12 } from "fs/promises";
+import { dirname as dirname3, join as join29 } from "path";
+import { hasToolCall as hasToolCall3, stepCountIs as stepCountIs3, tool as tool19, ToolLoopAgent as ToolLoopAgent3 } from "ai";
 import matter5 from "gray-matter";
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 function findForbiddenPlaceholder(stepsSection) {
   const placeholderPatterns = [
     { pattern: /Dynamic:\s/gi, name: '"Dynamic:" placeholder' },
@@ -6153,13 +6457,13 @@ function findForbiddenPlaceholder(stepsSection) {
   return void 0;
 }
 function buildWriteTestTool(state, outputDir) {
-  return tool18({
+  return tool19({
     description: "Write a test file to qa-tests/{folder}/{filename}.md. Validates frontmatter before writing. Returns error if frontmatter is invalid.",
-    inputSchema: z22.object({
-      folder: z22.string().describe("Subfolder name under qa-tests/"),
-      filename: z22.string().describe("File name (e.g. login-valid-credentials.md)"),
-      content: z22.string().describe("Full file content including YAML frontmatter"),
-      nodeId: z22.string().describe("The FeatureNode ID this test belongs to")
+    inputSchema: z24.object({
+      folder: z24.string().describe("Subfolder name under qa-tests/"),
+      filename: z24.string().describe("File name (e.g. login-valid-credentials.md)"),
+      content: z24.string().describe("Full file content including YAML frontmatter"),
+      nodeId: z24.string().describe("The FeatureNode ID this test belongs to")
     }),
     execute: async (input) => {
       const frontmatter = extractFrontmatter(input.content);
@@ -6202,11 +6506,11 @@ function buildWriteTestTool(state, outputDir) {
           error: `Test steps contain ${placeholder.name}: "${placeholder.match}". Use EXACT values from scenarios.md - not placeholders or examples.`
         };
       }
-      const relPath = join28("qa-tests", input.folder, input.filename);
-      const absPath = join28(outputDir, relPath);
+      const relPath = join29("qa-tests", input.folder, input.filename);
+      const absPath = join29(outputDir, relPath);
       try {
         await mkdir3(dirname3(absPath), { recursive: true });
-        await writeFile11(absPath, input.content, "utf-8");
+        await writeFile12(absPath, input.content, "utf-8");
         state.markTested(input.nodeId, [relPath]);
         await saveBfsState(outputDir, state);
         return { path: relPath, title: parsed.data.title };
@@ -6218,16 +6522,16 @@ function buildWriteTestTool(state, outputDir) {
   });
 }
 function buildCreateFolderTool(outputDir) {
-  return tool18({
+  return tool19({
     description: "Create a folder under qa-tests/ for organizing tests.",
-    inputSchema: z22.object({
-      folder: z22.string().describe("Folder name (kebab-case)")
+    inputSchema: z24.object({
+      folder: z24.string().describe("Folder name (kebab-case)")
     }),
     execute: async (input) => {
-      const absPath = join28(outputDir, "qa-tests", input.folder);
+      const absPath = join29(outputDir, "qa-tests", input.folder);
       try {
         await mkdir3(absPath, { recursive: true });
-        return { path: join28("qa-tests", input.folder) };
+        return { path: join29("qa-tests", input.folder) };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { error: `Failed to create folder: ${message}` };
@@ -6236,9 +6540,9 @@ function buildCreateFolderTool(outputDir) {
   });
 }
 function buildNextNodeTool(state, outputDir) {
-  return tool18({
+  return tool19({
     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: z22.object({}),
+    inputSchema: z24.object({}),
     execute: async () => {
       const next = state.nextNode();
       await saveBfsState(outputDir, state);
@@ -6265,9 +6569,9 @@ function buildNextNodeTool(state, outputDir) {
   });
 }
 function buildGetProgressTool(state) {
-  return tool18({
+  return tool19({
     description: "Check how many nodes have been tested vs how many remain.",
-    inputSchema: z22.object({}),
+    inputSchema: z24.object({}),
     execute: async () => {
       const stats = state.summary();
       const nodes = [...state.nodes.values()].map((n) => ({
@@ -6281,14 +6585,14 @@ function buildGetProgressTool(state) {
   });
 }
 function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
-  return tool18({
+  return tool19({
     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: z22.object({
-      instruction: z22.string().describe("What to research - be specific about files and what to look for")
+    inputSchema: z24.object({
+      instruction: z24.string().describe("What to research - be specific about files and what to look for")
     }),
     execute: async (input) => {
-      const resultSchema2 = z22.object({
-        findings: z22.string().describe("Summary of what was found")
+      const resultSchema2 = z24.object({
+        findings: z24.string().describe("Summary of what was found")
       });
       let result;
       const subagent = new ToolLoopAgent3({
@@ -6300,7 +6604,7 @@ function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
           glob: buildGlobTool(workingDirectory),
           grep: buildGrepTool(workingDirectory),
           read_file: buildReadFileTool(workingDirectory),
-          finish: tool18({
+          finish: tool19({
             description: "Report your findings.",
             inputSchema: resultSchema2,
             execute: async (output) => {
@@ -6342,14 +6646,14 @@ var init_tools2 = __esm({
     init_tools();
     init_graph();
     init_validation();
-    testFrontmatterSchema = z22.object({
-      title: z22.string().min(1),
-      description: z22.string().min(1),
-      intent: z22.string().min(30, "Intent must be at least 30 characters - describe the BEHAVIOR being tested, not the steps"),
-      criticality: z22.enum(["critical", "high", "mid", "low"]),
-      scenario: z22.string().min(1),
-      flow: z22.string().min(1),
-      verification: z22.string().min(
+    testFrontmatterSchema = z24.object({
+      title: z24.string().min(1),
+      description: z24.string().min(1),
+      intent: z24.string().min(30, "Intent must be at least 30 characters - describe the BEHAVIOR being tested, not the steps"),
+      criticality: z24.enum(["critical", "high", "mid", "low"]),
+      scenario: z24.string().min(1),
+      flow: z24.string().min(1),
+      verification: z24.string().min(
         20,
         "Verification must describe WHERE to navigate and WHAT to assert at the source of truth - not UI acknowledgments like toasts"
       )
@@ -6362,10 +6666,10 @@ var test_generator_exports = {};
 __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 join29 } from "path";
-import { tool as tool19 } from "ai";
-import { z as z23 } from "zod";
+import { mkdir as mkdir4, readFile as readFile22, rmdir, unlink, writeFile as writeFile13 } from "fs/promises";
+import { basename as basename4, join as join30 } from "path";
+import { tool as tool20 } from "ai";
+import { z as z25 } from "zod";
 import { glob as glob6 } from "glob";
 async function preseedQueue(state, projectRoot, pages, features) {
   let seeded = 0;
@@ -6413,10 +6717,10 @@ async function runTestGenerator(input) {
   const existingState = await loadBfsState(input.outputDir);
   const state = existingState ?? new CoverageState();
   let result;
-  const finishTool = tool19({
+  const finishTool = tool20({
     description: "Call when the BFS queue is empty and all routes have been explored.",
-    inputSchema: z23.object({
-      summary: z23.string().describe("Coverage summary")
+    inputSchema: z25.object({
+      summary: z25.string().describe("Coverage summary")
     }),
     execute: async (finishInput) => {
       const stats = state.summary();
@@ -6445,7 +6749,7 @@ async function runTestGenerator(input) {
   });
   let kbContext = "";
   try {
-    const autonomaMd = await readFile21(join29(input.outputDir, "AUTONOMA.md"), "utf-8");
+    const autonomaMd = await readFile22(join30(input.outputDir, "AUTONOMA.md"), "utf-8");
     kbContext += `
 ## Knowledge Base (AUTONOMA.md)
 
@@ -6454,7 +6758,7 @@ ${autonomaMd}
   } catch {
   }
   try {
-    const scenariosMd = await readFile21(join29(input.outputDir, "scenarios.md"), "utf-8");
+    const scenariosMd = await readFile22(join30(input.outputDir, "scenarios.md"), "utf-8");
     kbContext += `
 ## Scenarios
 
@@ -6508,7 +6812,7 @@ Do NOT try to finish early. Process EVERY node via next_node until it returns do
   const listDirectoryFn = await buildListDirectoryTool(input.projectRoot);
   const agentConfig = {
     id: "test-generator",
-    systemPrompt: SYSTEM_PROMPT6,
+    systemPrompt: SYSTEM_PROMPT7,
     model,
     maxSteps: CHUNK_STEPS,
     temperature: 0.3,
@@ -6624,20 +6928,20 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
       }
       console.log(`  Fix pass complete`);
     }
-    const allTestFiles = await glob6(join29(input.outputDir, "qa-tests", "**/*.md"));
+    const allTestFiles = await glob6(join30(input.outputDir, "qa-tests", "**/*.md"));
     let markedInvalid = 0;
     for (const testPath of allTestFiles) {
       if (basename4(testPath) === "INDEX.md") continue;
       if (testPath.includes("/_invalid/")) continue;
-      const content = await readFile21(testPath, "utf-8");
+      const content = await readFile22(testPath, "utf-8");
       const validation = validateTestContent(content);
       if (!validation.valid) {
-        const invalidDir = join29(input.outputDir, "qa-tests", "_invalid");
+        const invalidDir = join30(input.outputDir, "qa-tests", "_invalid");
         await mkdir4(invalidDir, { recursive: true });
-        const dest = join29(invalidDir, basename4(testPath));
+        const dest = join30(invalidDir, basename4(testPath));
         const annotated = `<!-- VALIDATION ERRORS: ${validation.errors.join("; ")} -->
 ${content}`;
-        await writeFile12(dest, annotated, "utf-8");
+        await writeFile13(dest, annotated, "utf-8");
         await unlink(testPath);
         markedInvalid++;
       }
@@ -6645,7 +6949,7 @@ ${content}`;
     if (markedInvalid > 0) {
       console.log(`  ${markedInvalid} tests still invalid after review cycles - moved to _invalid/`);
     }
-    const dirs = await glob6(join29(input.outputDir, "qa-tests", "**/"), {
+    const dirs = await glob6(join30(input.outputDir, "qa-tests", "**/"), {
       dot: false
     });
     for (const dir of dirs.sort((a, b) => b.length - a.length)) {
@@ -6737,7 +7041,7 @@ async function generateIndex(outputDir, state) {
   for (const paths of state.testsWritten.values()) {
     for (const p10 of paths) {
       try {
-        const content2 = await readFile21(join29(outputDir, p10), "utf-8");
+        const content2 = await readFile22(join30(outputDir, p10), "utf-8");
         const critMatch = content2.match(/criticality:\s*(\w+)/);
         const critVal = critMatch?.[1] ?? "";
         if (critCounts.has(critVal)) critCounts.set(critVal, (critCounts.get(critVal) ?? 0) + 1);
@@ -6782,28 +7086,28 @@ ${folders.map((f) => `| ${f.name} | ${f.test_count} |`).join("\n")}
 
 ${[...testsByFolder.entries()].flatMap(([_folder, tests]) => tests.map((t) => `- \`${t}\``)).join("\n")}
 `;
-  await writeFile12(join29(outputDir, "qa-tests", "INDEX.md"), content, "utf-8");
+  await writeFile13(join30(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(join29(outputDir, "AUTONOMA.md"), "utf-8");
+    autonomaMd = await readFile22(join30(outputDir, "AUTONOMA.md"), "utf-8");
   } catch (err) {
     debugLog("AUTONOMA.md not present for journey generation", { err });
   }
   try {
-    scenariosMd = await readFile21(join29(outputDir, "scenarios.md"), "utf-8");
+    scenariosMd = await readFile22(join30(outputDir, "scenarios.md"), "utf-8");
   } catch (err) {
     debugLog("scenarios.md not present for journey generation", { err });
   }
   if (!autonomaMd) return 0;
-  const existingTests = await glob6(join29(outputDir, "qa-tests", "**/*.md"));
+  const existingTests = await glob6(join30(outputDir, "qa-tests", "**/*.md"));
   const existingTitles = [];
   for (const t of existingTests) {
     if (basename4(t) === "INDEX.md") continue;
-    const content = await readFile21(t, "utf-8");
+    const content = await readFile22(t, "utf-8");
     const titleMatch = content.match(/title:\s*"([^"]+)"/);
     if (titleMatch) existingTitles.push(titleMatch[1]);
   }
@@ -6846,9 +7150,9 @@ Write 5-8 journey tests using the write_test tool with folder "journeys". Then c
     status: "queued"
   });
   let journeyResult;
-  const journeyFinish = tool19({
+  const journeyFinish = tool20({
     description: "Signal journey generation is complete.",
-    inputSchema: z23.object({ summary: z23.string() }),
+    inputSchema: z25.object({ summary: z25.string() }),
     execute: async (finishInput) => {
       journeyResult = {
         success: true,
@@ -6860,7 +7164,7 @@ Write 5-8 journey tests using the write_test tool with folder "journeys". Then c
   });
   const config = {
     id: "journey-gen",
-    systemPrompt: SYSTEM_PROMPT6,
+    systemPrompt: SYSTEM_PROMPT7,
     model,
     maxSteps: 50,
     temperature: 0.3,
@@ -6937,23 +7241,24 @@ function ensureSupportedNode() {
 ensureSupportedNode();
 
 // src/index.ts
-import { readFile as readFile22, writeFile as writeFile13 } from "fs/promises";
-import { join as join30 } from "path";
+init_submit();
+import { readFile as readFile23, writeFile as writeFile14 } from "fs/promises";
+import { join as join31 } from "path";
 import * as p9 from "@clack/prompts";
 
 // src/config.ts
 init_esm_shims();
 import { readFileSync as readFileSync2 } from "fs";
-import { resolve, join as join2 } from "path";
+import { resolve, join as join3 } from "path";
 
 // src/core/global-env.ts
 init_esm_shims();
 init_env();
 import { readFileSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
-var AUTONOMA_HOME = join(homedir(), ".autonoma");
-var GLOBAL_ENV_PATH = join(AUTONOMA_HOME, ".env");
+import { join as join2 } from "path";
+var AUTONOMA_HOME = join2(homedir(), ".autonoma");
+var GLOBAL_ENV_PATH = join2(AUTONOMA_HOME, ".env");
 function parseEnvContent(content) {
   const out = {};
   for (const line of content.split("\n")) {
@@ -6989,7 +7294,7 @@ init_env();
 function loadProjectEnv(projectRoot) {
   let content;
   try {
-    content = readFileSync2(join2(projectRoot, ".env"), "utf-8");
+    content = readFileSync2(join3(projectRoot, ".env"), "utf-8");
   } catch {
     return;
   }
@@ -7018,6 +7323,8 @@ function loadConfig(args) {
     projectRoot,
     projectSlug,
     modelId: args.model ?? env.OPENROUTER_MODEL,
+    frontend: args.frontend,
+    backends: args.backends,
     databaseUrl: env.DATABASE_URL,
     sdkEndpointUrl: env.SDK_ENDPOINT_URL,
     sharedSecret: env.AUTONOMA_SHARED_SECRET,
@@ -7092,6 +7399,50 @@ function installInterruptHandler(opts) {
     return iface;
   });
 }
+function installTerminationDiagnostics() {
+  const memSnapshot = () => {
+    const m = process.memoryUsage();
+    const mb = (n) => Math.round(n / 1024 / 1024);
+    return `rss=${mb(m.rss)}MB heapUsed=${mb(m.heapUsed)}MB heapTotal=${mb(m.heapTotal)}MB`;
+  };
+  for (const signal of ["SIGTERM", "SIGHUP"]) {
+    const forcedCode = signal === "SIGTERM" ? 143 : 129;
+    process.on(signal, () => {
+      process.stderr.write(`
+[diagnostics] received ${signal} - external termination (${memSnapshot()})
+`);
+      terminateGracefully(forcedCode);
+    });
+  }
+  process.on("uncaughtException", (err) => {
+    const detail = err instanceof Error ? err.stack ?? err.message : String(err);
+    process.stderr.write(`
+[diagnostics] uncaughtException (${memSnapshot()}): ${detail}
+`);
+    restoreTerminal();
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    const detail = reason instanceof Error ? reason.stack ?? reason.message : String(reason);
+    process.stderr.write(`
+[diagnostics] unhandledRejection (${memSnapshot()}): ${detail}
+`);
+    restoreTerminal();
+    process.exit(1);
+  });
+}
+function terminateGracefully(forcedCode) {
+  if (quitting || onExit == null) {
+    restoreTerminal();
+    process.exit(forcedCode);
+  }
+  quitting = true;
+  setTimeout(() => {
+    restoreTerminal();
+    process.exit(forcedCode);
+  }, FORCE_EXIT_MS).unref?.();
+  onExit(forcedCode);
+}
 function restoreTerminal() {
   try {
     if (process.stdin.isTTY) process.stdin.setRawMode(false);
@@ -7108,10 +7459,10 @@ init_model();
 init_esm_shims();
 import { mkdir } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
-var AUTONOMA_HOME3 = join6(homedir3(), ".autonoma");
+import { join as join7 } from "path";
+var AUTONOMA_HOME3 = join7(homedir3(), ".autonoma");
 function getOutputDir(projectSlug) {
-  return join6(AUTONOMA_HOME3, projectSlug);
+  return join7(AUTONOMA_HOME3, projectSlug);
 }
 async function ensureOutputDir(projectSlug) {
   const dir = getOutputDir(projectSlug);
@@ -7125,8 +7476,8 @@ init_env();
 // src/core/git.ts
 init_esm_shims();
 import { execFile } from "child_process";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { join as join7 } from "path";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { join as join8 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var GIT_INFO_FILE = ".git-info.json";
@@ -7150,11 +7501,11 @@ async function readGitInfo(projectRoot) {
   };
 }
 async function saveGitInfo(outputDir, info) {
-  await writeFile2(join7(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
+  await writeFile3(join8(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
 }
 async function loadGitInfo(outputDir) {
   try {
-    const raw = await readFile2(join7(outputDir, GIT_INFO_FILE), "utf-8");
+    const raw = await readFile3(join8(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;
@@ -7169,15 +7520,31 @@ async function loadGitInfo(outputDir) {
 
 // src/index.ts
 init_notify();
+init_project_map();
 
 // src/core/state.ts
 init_esm_shims();
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { join as join8 } from "path";
+init_debug();
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { join as join10 } from "path";
+import { z as z3 } from "zod";
+var StepStatusSchema = z3.enum(["pending", "running", "done", "failed", "paused"]);
+var PipelineStateSchema = z3.object({
+  steps: z3.object({
+    projectMapper: StepStatusSchema.default("done"),
+    pagesFinder: StepStatusSchema.default("done"),
+    kb: StepStatusSchema.default("done"),
+    entityAudit: StepStatusSchema.default("done"),
+    scenarioRecipe: StepStatusSchema.default("done"),
+    recipeBuilder: StepStatusSchema.default("done"),
+    testGenerator: StepStatusSchema.default("done")
+  })
+});
 var STATE_FILE = ".pipeline-state.json";
 function initialState() {
   return {
     steps: {
+      projectMapper: "pending",
       pagesFinder: "pending",
       kb: "pending",
       entityAudit: "pending",
@@ -7188,18 +7555,19 @@ function initialState() {
   };
 }
 async function loadState(outputDir) {
-  const path3 = join8(outputDir, STATE_FILE);
+  const path3 = join10(outputDir, STATE_FILE);
   try {
-    const raw = await readFile3(path3, "utf-8");
-    const parsed = JSON.parse(raw);
-    return parsed;
-  } catch {
+    const raw = await readFile5(path3, "utf-8");
+    return PipelineStateSchema.parse(JSON.parse(raw));
+  } catch (err) {
+    const isMissingFile = err instanceof Error && "code" in err && err.code === "ENOENT";
+    if (!isMissingFile) debugLog("Failed to load pipeline state, starting fresh", { path: path3, err });
     return initialState();
   }
 }
 async function saveState(outputDir, state) {
-  const path3 = join8(outputDir, STATE_FILE);
-  await writeFile3(path3, JSON.stringify(state, null, 2), "utf-8");
+  const path3 = join10(outputDir, STATE_FILE);
+  await writeFile5(path3, JSON.stringify(state, null, 2), "utf-8");
 }
 async function markStep(outputDir, state, step, status) {
   const updated = {
@@ -7210,23 +7578,31 @@ async function markStep(outputDir, state, step, status) {
   return updated;
 }
 function nextPendingStep(state) {
-  const order = ["pagesFinder", "kb", "entityAudit", "scenarioRecipe", "recipeBuilder", "testGenerator"];
+  const order = [
+    "projectMapper",
+    "pagesFinder",
+    "kb",
+    "entityAudit",
+    "scenarioRecipe",
+    "recipeBuilder",
+    "testGenerator"
+  ];
   return order.find((s) => state.steps[s] !== "done") ?? void 0;
 }
 
 // src/core/upload.ts
 init_esm_shims();
 init_debug();
-import { readFile as readFile4 } from "fs/promises";
-import { basename, join as join9, relative } from "path";
-import * as p from "@clack/prompts";
+import { readFile as readFile6 } from "fs/promises";
+import { basename, join as join11, relative } from "path";
+import * as p2 from "@clack/prompts";
 import { glob } from "glob";
 var ARTIFACT_FILES = ["AUTONOMA.md", "scenarios.md", "entity-audit.md"];
 async function readArtifacts(outputDir) {
   const files = [];
   for (const name of ARTIFACT_FILES) {
     try {
-      const content = await readFile4(join9(outputDir, name), "utf-8");
+      const content = await readFile6(join11(outputDir, name), "utf-8");
       files.push({ name, content });
     } catch (err) {
       debugLog(`Artifact ${name} not on disk; skipping upload`, { err });
@@ -7235,13 +7611,13 @@ async function readArtifacts(outputDir) {
   return files;
 }
 async function readTestCases(outputDir) {
-  const testsDir = join9(outputDir, "qa-tests");
+  const testsDir = join11(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 readFile4(join9(testsDir, match), "utf-8");
+    const content = await readFile6(join11(testsDir, match), "utf-8");
     const folderPath = relative(".", match).split("/").slice(0, -1).join("/");
     files.push({ name, content, folder: folderPath.length > 0 ? folderPath : void 0 });
   }
@@ -7278,14 +7654,14 @@ async function patchJson(url, token, body) {
 async function uploadArtifacts(config, outputDir) {
   const { autonomaApiUrl, autonomaApiToken, autonomaGenerationId } = config;
   if (autonomaApiUrl == null || autonomaApiToken == null || autonomaGenerationId == null) {
-    p.log.info(
+    p2.log.info(
       `Autonoma upload credentials not configured - artifacts saved locally only. They live in ${outputDir}.`
     );
     return;
   }
   const baseUrl = autonomaApiUrl.replace(/\/+$/, "");
   const setupUrl = `${baseUrl}/v1/setup/setups/${autonomaGenerationId}`;
-  p.log.step("Uploading artifacts to Autonoma...");
+  p2.log.step("Uploading artifacts to Autonoma...");
   const [testCases, artifacts, gitInfo] = await Promise.all([
     readTestCases(outputDir),
     readArtifacts(outputDir),
@@ -7293,7 +7669,7 @@ async function uploadArtifacts(config, outputDir) {
   ]);
   await postJson(`${setupUrl}/artifacts`, autonomaApiToken, { testCases, artifacts, commitSha: gitInfo?.sha });
   await patchJson(setupUrl, autonomaApiToken, { status: "completed" });
-  p.log.success(
+  p2.log.success(
     `Uploaded ${testCases.length} test case${testCases.length === 1 ? "" : "s"} and ${artifacts.length} artifact${artifacts.length === 1 ? "" : "s"}. Return to your browser to continue onboarding.`
   );
 }
@@ -7303,11 +7679,11 @@ process.setSourceMapsEnabled(true);
 var PAGES_FILE = "pages.json";
 async function savePages(outputDir, pages) {
   const obj = Object.fromEntries(pages);
-  await writeFile13(join30(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile14(join31(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadPages(outputDir) {
   try {
-    const raw = await readFile22(join30(outputDir, PAGES_FILE), "utf-8");
+    const raw = await readFile23(join31(outputDir, PAGES_FILE), "utf-8");
     const obj = JSON.parse(raw);
     return new Map(Object.entries(obj));
   } catch {
@@ -7336,6 +7712,7 @@ function strArg(args, key) {
   return typeof value === "string" ? value : void 0;
 }
 var STEP_LABELS = {
+  projectMapper: "Map your project structure",
   pagesFinder: "Find your pages",
   kb: "Build a knowledge base",
   entityAudit: "Map your data models",
@@ -7347,6 +7724,7 @@ function isStepName(value) {
   return value in STEP_LABELS;
 }
 var STEP_SUMMARIES = {
+  projectMapper: "Identify your frontend(s), backend(s), and which folders to ignore.",
   pagesFinder: "Map every page and route in your app.",
   kb: "Learn your app's features, flows, and UI patterns.",
   entityAudit: "Find what your app stores (users, orgs, ...) and how each one is created.",
@@ -7355,6 +7733,7 @@ var STEP_SUMMARIES = {
   testGenerator: "Write the end-to-end tests, covering every page and feature."
 };
 var STEP_INTROS = {
+  projectMapper: "Looking at how your codebase is laid out - which folder(s) are the frontend, which are the backend/data layer, and which are unrelated - so every later step scans only what matters instead of the whole repo.",
   pagesFinder: "Scanning your codebase to find every page and route, so we know the full surface area that needs test coverage.",
   kb: "Reading those pages to learn your app's features, flows, and UI patterns - the context everything after this builds on.",
   entityAudit: "Finding the things your app stores (users, organizations, orders, ...) and how each one gets created, so we can generate realistic test data for them.",
@@ -7362,6 +7741,32 @@ var STEP_INTROS = {
   recipeBuilder: "Helping you wire up small helpers that create and clean up test data in your own database. We give you a copy-paste guide for each one and test it live against your app running locally - you deploy later, once everything passes.",
   testGenerator: "Writing the actual end-to-end tests, covering every page and feature with depth proportional to its complexity."
 };
+async function resolveScopeSelection(map, config, nonInteractive) {
+  if (config.frontend != null) {
+    const requestedFrontend = resolveSelection(map, { frontend: config.frontend, backends: [] }).frontend;
+    const backends = config.backends ?? defaultBackendsFor(map, requestedFrontend);
+    return resolveSelection(map, { frontend: config.frontend, backends });
+  }
+  if (!nonInteractive) return promptScopeSelection(map);
+  return pickDefaultSelection(map);
+}
+async function promptScopeSelection(map) {
+  const frontend = await p9.select({
+    message: "Which frontend do you want to plan tests for?",
+    options: map.frontends.map((f) => ({ value: f.path, label: `${f.path}  [${f.framework}]`, hint: f.why }))
+  });
+  if (p9.isCancel(frontend)) throw new Error("Cancelled");
+  if (map.backends.length === 0) return { frontend, backends: [] };
+  const needed = defaultBackendsFor(map, frontend);
+  const backends = await p9.multiselect({
+    message: "Which backends does it need? (pre-checked: the ones it depends on)",
+    options: map.backends.map((b) => ({ value: b.path, label: `${b.path}  [${b.framework}]`, hint: b.why })),
+    initialValues: needed,
+    required: false
+  });
+  if (p9.isCancel(backends)) throw new Error("Cancelled");
+  return { frontend, backends };
+}
 async function runStep(step, outputDir, state, config, projectContext, nonInteractive, retryGuidance) {
   const label = STEP_LABELS[step];
   p9.note(STEP_INTROS[step], `Step: ${label}`);
@@ -7377,13 +7782,52 @@ async function runStep(step, outputDir, state, config, projectContext, nonIntera
   try {
     let result;
     switch (step) {
+      case "projectMapper": {
+        const { runProjectMapper: runProjectMapper2 } = await Promise.resolve().then(() => (init_project_mapper(), project_mapper_exports));
+        const map = await runProjectMapper2({
+          projectRoot: config.projectRoot,
+          outputDir,
+          modelId: config.modelId,
+          nonInteractive
+        });
+        if (map == null) {
+          result = { success: false, artifacts: [], summary: "Project mapper did not produce a map." };
+          break;
+        }
+        if (map.frontends.length === 0) {
+          result = {
+            success: false,
+            artifacts: [],
+            summary: "Project mapper found no frontend to test. Point --project at a codebase with a UI."
+          };
+          break;
+        }
+        const selection = await resolveScopeSelection(map, config, nonInteractive);
+        if (selection == null) {
+          await saveProjectMap(outputDir, map);
+          p9.note(renderProjectMap(map), "Project map - candidates (pick one frontend + its backends)");
+          result = {
+            success: false,
+            paused: true,
+            artifacts: [],
+            summary: `Found ${map.frontends.length} candidate frontends. Choose one and its backends, then resume with --frontend <path> --backends <path,path>.`
+          };
+          break;
+        }
+        const scoped = applySelection(map, selection);
+        await saveProjectMap(outputDir, scoped);
+        p9.note(renderProjectMap(scoped), "Project map");
+        break;
+      }
       case "pagesFinder": {
         const { runPageFinder: runPageFinder2 } = await Promise.resolve().then(() => (init_pages_finder(), pages_finder_exports));
+        const projectMap = await loadProjectMap(outputDir);
         const pages = await runPageFinder2({
           projectRoot: config.projectRoot,
           outputDir,
           modelId: config.modelId,
-          nonInteractive
+          nonInteractive,
+          extraMessage: projectMap != null ? formatFrontendScope(projectMap) : void 0
         });
         await savePages(outputDir, pages);
         break;
@@ -7402,18 +7846,21 @@ async function runStep(step, outputDir, state, config, projectContext, nonIntera
       }
       case "entityAudit": {
         const { runEntityAudit: runEntityAudit2 } = await Promise.resolve().then(() => (init_entity_audit(), entity_audit_exports));
+        const auditMap = await loadProjectMap(outputDir);
         result = await runEntityAudit2({
           projectRoot: config.projectRoot,
           outputDir,
           modelId: config.modelId,
           projectContext,
           nonInteractive,
-          retryGuidance
+          retryGuidance,
+          scopeHint: auditMap != null ? formatBackendScope(auditMap) : void 0
         });
         break;
       }
       case "scenarioRecipe": {
         const { runScenarioRecipe: runScenarioRecipe2 } = await Promise.resolve().then(() => (init_scenario_recipe(), scenario_recipe_exports));
+        const recipeMap = await loadProjectMap(outputDir);
         result = await runScenarioRecipe2({
           projectRoot: config.projectRoot,
           outputDir,
@@ -7421,7 +7868,8 @@ async function runStep(step, outputDir, state, config, projectContext, nonIntera
           config,
           projectContext,
           nonInteractive,
-          retryGuidance
+          retryGuidance,
+          scopeHint: recipeMap != null ? formatBackendScope(recipeMap) : void 0
         });
         break;
       }
@@ -7574,6 +8022,7 @@ async function gatherProjectContext() {
   };
 }
 async function main() {
+  installTerminationDiagnostics();
   const args = parseArgs(process.argv.slice(2));
   const command = process.argv[2];
   if (command === "status") {
@@ -7588,12 +8037,28 @@ async function main() {
     await showStatus(outputDir2);
     return;
   }
+  if (command === "upload") {
+    const config2 = loadConfig({
+      project: strArg(args, "project"),
+      slug: strArg(args, "slug")
+    });
+    const outputDir2 = await ensureOutputDir(config2.projectSlug);
+    const recipeUploaded = await uploadRecipeFromDisk(outputDir2, {
+      apiUrl: config2.autonomaApiUrl,
+      apiToken: config2.autonomaApiToken,
+      generationId: config2.autonomaGenerationId
+    });
+    await uploadArtifacts(config2, outputDir2);
+    await flushAnalytics();
+    process.exit(recipeUploaded ? 0 : 1);
+  }
   if (command === "help" || args.help) {
     console.log("Usage:");
     console.log(
-      "  test-planner [run] [--project <path>] [--model <id>] [--step <name>] [--resume] [--non-interactive]"
+      "  test-planner [run] [--project <path>] [--frontend <path>] [--backends <path,path>] [--model <id>] [--step <name>] [--resume] [--non-interactive]"
     );
     console.log("  test-planner status [--project <path>]");
+    console.log("  test-planner upload [--project <path>]   # re-upload already-generated recipe + artifacts");
     console.log("");
     console.log("`run` is the default command; it may be omitted.");
     return;
@@ -7602,19 +8067,25 @@ async function main() {
   p9.intro("Let's generate your test suite");
   const resumeCommand = `autonoma-planner --resume` + (args.project ? ` --project ${args.project}` : "");
   installInterruptHandler({
-    onExit: () => {
+    // exitCode defaults to 0 for a user-initiated Ctrl+C (progress saved, a clean stop);
+    // an external SIGTERM/SIGHUP passes the conventional 143/129 so the flushed exit still
+    // carries the signal code a reaper/CI reads, not a 0 that looks like normal completion.
+    onExit: (exitCode = 0) => {
       track("cli_run_exited");
       restoreTerminal();
       console.log("");
       p9.log.warn(`Your progress is saved. To resume, run:
   ${resumeCommand}`);
-      void flushAnalytics().finally(() => process.exit(0));
+      void flushAnalytics().finally(() => process.exit(exitCode));
     }
   });
+  const backendsArg = strArg(args, "backends");
   const config = loadConfig({
     project: strArg(args, "project"),
     model: strArg(args, "model"),
-    slug: strArg(args, "slug")
+    slug: strArg(args, "slug"),
+    frontend: strArg(args, "frontend"),
+    backends: backendsArg != null ? backendsArg.split(",").map((s) => s.trim()).filter((s) => s.length > 0) : void 0
   });
   if (!ensureAutonomaAuth()) {
     return;
@@ -7705,12 +8176,20 @@ or reveal hidden files (macOS: Cmd+Shift+. ) to see it.`,
     p9.outro("Done");
     return;
   }
-  const startStep = isResuming ? nextPendingStep(state) : "pagesFinder";
+  const startStep = isResuming ? nextPendingStep(state) : "projectMapper";
   if (!startStep) {
     p9.log.success("All steps complete.");
     return;
   }
-  const steps = ["pagesFinder", "kb", "entityAudit", "scenarioRecipe", "recipeBuilder", "testGenerator"];
+  const steps = [
+    "projectMapper",
+    "pagesFinder",
+    "kb",
+    "entityAudit",
+    "scenarioRecipe",
+    "recipeBuilder",
+    "testGenerator"
+  ];
   const startIdx = steps.indexOf(startStep);
   p9.note(steps.map((s, idx) => `${idx + 1}. ${STEP_LABELS[s]} - ${STEP_SUMMARIES[s]}`).join("\n"), "Here's the plan");
   try {