@autonoma-ai/planner 0.1.19 → 0.1.20

package/dist/index.js

@@ -199,7 +199,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({
@@ -288,7 +288,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 +492,151 @@ var init_notify = __esm({
   }
 });
 
+// src/core/project-map.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { join as join8 } from "path";
+import { z as z2 } from "zod";
+async function saveProjectMap(outputDir, map) {
+  await writeFile3(join8(outputDir, PROJECT_MAP_FILE), JSON.stringify(map, null, 2), "utf-8");
+}
+async function loadProjectMap(outputDir) {
+  const path3 = join8(outputDir, PROJECT_MAP_FILE);
+  try {
+    const raw = await readFile3(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 +911,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 readFile6 } from "fs/promises";
+import { join as join11, relative as relative2 } from "path";
 import { glob as glob2 } from "glob";
 async function loadGitignorePatterns(projectRoot) {
   const patterns = [
@@ -787,10 +932,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 = join11(projectRoot, match);
     try {
-      const content = await readFile5(fullPath, "utf-8");
-      const prefix = relative2(projectRoot, join10(projectRoot, match, ".."));
+      const content = await readFile6(fullPath, "utf-8");
+      const prefix = relative2(projectRoot, join11(projectRoot, match, ".."));
       const parsed = parseGitignore(content, prefix);
       patterns.push(...parsed);
     } catch (err) {
@@ -853,7 +998,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 +1064,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 +1073,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 +1100,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 +1112,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 +1156,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 +1167,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 join12, 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 +1192,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(join12(dirPath, name));
       withTypes.push({ name, isDir: s.isDirectory() });
     } catch {
       withTypes.push({ name, isDir: false });
@@ -1067,7 +1212,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
     }
     if (entry.isDir) {
       const children = await buildTree(
-        join11(dirPath, entry.name),
+        join12(dirPath, entry.name),
         maxDepth,
         currentDepth + 1,
         isIgnored,
@@ -1105,10 +1250,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 +1265,7 @@ async function buildListDirectoryTool(workingDirectory) {
         };
       }
       seen.add(cacheKey);
-      const targetDir = input.path === "." ? workingDirectory : join11(workingDirectory, input.path);
+      const targetDir = input.path === "." ? workingDirectory : join12(workingDirectory, input.path);
       try {
         const s = await stat(targetDir);
         if (!s.isDirectory()) {
@@ -1152,10 +1297,10 @@ var init_list_directory = __esm({
 });
 
 // src/tools/read-file.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } 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 +1325,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 readFile7(resolved.absolutePath, "utf-8");
     const sliced = sliceLines(content, offset ?? 0, limit ?? MAX_LINES);
     return {
       path: resolved.relativePath,
@@ -1208,10 +1353,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 +1379,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 +1395,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 +1446,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 +1461,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 writeFile5, 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 +1474,7 @@ async function executeWriteFile(outputDirectory, filePath, content) {
   }
   try {
     await mkdir2(dirname2(absolutePath), { recursive: true });
-    await writeFile4(absolutePath, content, "utf-8");
+    await writeFile5(absolutePath, content, "utf-8");
     return { path: relativePath, bytesWritten: content.length };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1348,9 +1493,9 @@ 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")
     });
   }
 });
@@ -1358,16 +1503,21 @@ var init_write_file = __esm({
 // src/tools/ask-user.ts
 import * as p2 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) => {
+      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 p2.text({ message: input.question });
       if (p2.isCancel(answer)) return { answer: "User skipped this question" };
       return { answer };
@@ -1411,6 +1561,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 +1620,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 +1640,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 +1652,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 +1673,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 +1706,13 @@ var init_pages_finder = __esm({
 
 // src/core/review.ts
 import { access } from "fs/promises";
-import { join as join12, isAbsolute } from "path";
+import { join as join13, isAbsolute } from "path";
 import * as p3 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 join13(outputDir, artifact);
 }
 async function detectEditors() {
   if (cachedEditors) return cachedEditors;
@@ -1525,12 +1727,12 @@ 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) => {
@@ -1592,7 +1794,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 = join13(options.outputDir, f);
       try {
         await access(fullPath);
         result.artifacts.push(f);
@@ -1681,13 +1883,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 readFile8 } from "fs/promises";
+import { join as join14 } 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 readFile8(join14(outputDir, "AUTONOMA.md"), "utf-8");
   } catch {
     return [];
   }
@@ -1752,12 +1954,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 +2102,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 readFile9 } from "fs/promises";
+import { join as join15, 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 +2122,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 +2161,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 +2171,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 +2212,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 +2224,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 = join15(input.outputDir, "AUTONOMA.md");
+  const autonomaExists = await readFile9(autonomaPath, "utf-8").then(() => true).catch((err) => {
     debugLog("AUTONOMA.md not found while checking step completion", { err });
     return false;
   });
@@ -2029,6 +2243,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 +2266,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 +2287,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 +2297,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 +2312,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 +2345,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 readFile10 } from "fs/promises";
+import { join as join16 } 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 readFile10(join16(outputDir, "entity-audit.md"), "utf-8");
   try {
     const parsed = frontmatterSchema.safeParse(matter2(raw).data);
     if (parsed.success && parsed.data.models.length > 0) {
@@ -2282,22 +2517,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 +2599,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 +2742,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 readFile11, writeFile as writeFile6 } from "fs/promises";
+import { join as join17 } 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 +2766,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 +2786,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 +2835,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 +2874,7 @@ async function findPrismaSchema(projectRoot) {
   return candidates[0] ?? void 0;
 }
 async function extractPrismaModels(schemaPath) {
-  const content = await readFile10(schemaPath, "utf-8");
+  const content = await readFile11(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 +2897,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 +2931,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 +2961,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 = join17(input.outputDir, "entity-audit.md");
+    await writeFile6(auditPath, tracker.generateAuditMarkdown(), "utf-8");
     return auditPath;
   };
   const canonicalPath = await writeCanonicalAudit();
@@ -2761,9 +2999,9 @@ When done with changes, call finish again.`;
     }
   });
   if (!reviewed) {
-    const auditPath = join16(input.outputDir, "entity-audit.md");
+    const auditPath = join17(input.outputDir, "entity-audit.md");
     try {
-      await readFile10(auditPath, "utf-8");
+      await readFile11(auditPath, "utf-8");
       return {
         success: true,
         artifacts: ["entity-audit.md"],
@@ -2779,7 +3017,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 +3032,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 +3143,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 readFile12 } from "fs/promises";
+import { join as join18 } from "path";
 async function parseEntityNames(outputDir) {
   try {
-    const content = await readFile11(join17(outputDir, "entity-audit.md"), "utf-8");
+    const content = await readFile12(join18(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 +3220,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 readFile13 } from "fs/promises";
+import { join as join19 } 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 readFile13(join19(outputDir, "scenarios.md"), "utf-8");
   } catch {
     return { scenarioNames: [], entityTypes: [] };
   }
@@ -3068,22 +3307,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 readFile14 } from "fs/promises";
+import { join as join20 } 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 readFile14(join20(outputDir, "scenarios.md"), "utf-8");
       } catch {
         return { error: "Cannot finish: scenarios.md not found. Write it first." };
       }
@@ -3118,7 +3357,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 +3422,9 @@ When done with changes, call finish again.`;
     }
   });
   if (!reviewed) {
-    const scenariosPath = join19(input.outputDir, "scenarios.md");
+    const scenariosPath = join20(input.outputDir, "scenarios.md");
     try {
-      await readFile13(scenariosPath, "utf-8");
+      await readFile14(scenariosPath, "utf-8");
       return {
         success: true,
         artifacts: ["scenarios.md"],
@@ -3243,7 +3485,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 +3573,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 join21 } from "path";
 function detectPackageManager(projectRoot) {
-  if (existsSync2(join20(projectRoot, "bun.lock")) || existsSync2(join20(projectRoot, "bun.lockb"))) return "bun";
-  if (existsSync2(join20(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync2(join20(projectRoot, "yarn.lock"))) return "yarn";
+  if (existsSync2(join21(projectRoot, "bun.lock")) || existsSync2(join21(projectRoot, "bun.lockb"))) return "bun";
+  if (existsSync2(join21(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join21(projectRoot, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function installCommand(pm, ...packages) {
@@ -3614,8 +3856,8 @@ 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";
+import { readFile as readFile15, writeFile as writeFile7 } from "fs/promises";
+import { join as join22 } from "path";
 function collectRefs2(value, out) {
   if (Array.isArray(value)) {
     for (const v of value) collectRefs2(v, out);
@@ -3688,7 +3930,7 @@ function buildSubmittableRecipe(create, description) {
   };
 }
 async function saveRecipe(outputDir, recipe) {
-  await writeFile6(join21(outputDir, RECIPE_FILE), JSON.stringify(recipe, null, 2), "utf-8");
+  await writeFile7(join22(outputDir, RECIPE_FILE), JSON.stringify(recipe, null, 2), "utf-8");
 }
 var RECIPE_FILE;
 var init_recipe = __esm({
@@ -3701,8 +3943,8 @@ var init_recipe = __esm({
 });
 
 // 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 +3966,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 +3974,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 +4046,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 +4106,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 +4125,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 { join as join24 } from "path";
 import * as p4 from "@clack/prompts";
-import { tool as tool13 } from "ai";
+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 +4146,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 +4192,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;
@@ -4011,10 +4253,10 @@ Read scenarios.md and entity-audit.md to understand the correct aliases and sche
 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;
@@ -4096,23 +4338,23 @@ async function reviewRecipeData(entityName, entityIndex, totalEntities, proposed
     if (p4.isCancel(action)) throw new Error("Recipe review cancelled");
     if (action === "keep") return proposed;
     if (action === "edit") {
-      const tmpPath = 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) => {
+      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(
             `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 });
@@ -4404,8 +4646,8 @@ 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"
         );
@@ -4416,7 +4658,7 @@ Add this to your server's .env file and restart it.
 This is a 64-character hex key used for HMAC-SHA256 request signing.
 The same value must be set in both your server and the Autonoma dashboard.
 
-Saved to: ${join23(outputDir, "autonoma-config.json")}`,
+Saved to: ${join24(outputDir, "autonoma-config.json")}`,
           "Shared secret generated"
         );
         const secretReady = await p4.confirm({
@@ -4437,8 +4679,8 @@ Saved to: ${join23(outputDir, "autonoma-config.json")}`,
         if (p4.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"
         );
@@ -4554,14 +4796,14 @@ 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 { 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;
@@ -4816,18 +5058,18 @@ var init_submit = __esm({
 
 // 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 +5080,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 +5136,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 +5147,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 +5162,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 +5177,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;
@@ -5031,21 +5273,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 +5461,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 +5524,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 +5554,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 +5649,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 +5683,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 +5705,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 +5739,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 +5748,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 +5785,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 +5837,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 +5937,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 +6373,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 +6395,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 +6444,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 +6460,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 +6478,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 +6507,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 +6523,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 +6542,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 +6584,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 +6604,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 +6655,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 +6687,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 +6696,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 +6750,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 +6866,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 +6887,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 +6979,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 +7024,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 +7088,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 +7102,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,8 +7179,8 @@ function ensureSupportedNode() {
 ensureSupportedNode();
 
 // src/index.ts
-import { readFile as readFile22, writeFile as writeFile13 } from "fs/promises";
-import { join as join30 } from "path";
+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
@@ -7018,6 +7260,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 +7336,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);
@@ -7169,15 +7457,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 readFile4, writeFile as writeFile4 } from "fs/promises";
+import { join as join9 } 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 +7492,19 @@ function initialState() {
   };
 }
 async function loadState(outputDir) {
-  const path3 = join8(outputDir, STATE_FILE);
+  const path3 = join9(outputDir, STATE_FILE);
   try {
-    const raw = await readFile3(path3, "utf-8");
-    const parsed = JSON.parse(raw);
-    return parsed;
-  } catch {
+    const raw = await readFile4(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 = join9(outputDir, STATE_FILE);
+  await writeFile4(path3, JSON.stringify(state, null, 2), "utf-8");
 }
 async function markStep(outputDir, state, step, status) {
   const updated = {
@@ -7210,15 +7515,23 @@ 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 { readFile as readFile5 } from "fs/promises";
+import { basename, join as join10, relative } from "path";
 import * as p from "@clack/prompts";
 import { glob } from "glob";
 var ARTIFACT_FILES = ["AUTONOMA.md", "scenarios.md", "entity-audit.md"];
@@ -7226,7 +7539,7 @@ 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 readFile5(join10(outputDir, name), "utf-8");
       files.push({ name, content });
     } catch (err) {
       debugLog(`Artifact ${name} not on disk; skipping upload`, { err });
@@ -7235,13 +7548,13 @@ async function readArtifacts(outputDir) {
   return files;
 }
 async function readTestCases(outputDir) {
-  const testsDir = join9(outputDir, "qa-tests");
+  const testsDir = join10(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 readFile5(join10(testsDir, match), "utf-8");
     const folderPath = relative(".", match).split("/").slice(0, -1).join("/");
     files.push({ name, content, folder: folderPath.length > 0 ? folderPath : void 0 });
   }
@@ -7303,11 +7616,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 +7649,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 +7661,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 +7670,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 +7678,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 +7719,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 +7783,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 +7805,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 +7959,7 @@ async function gatherProjectContext() {
   };
 }
 async function main() {
+  installTerminationDiagnostics();
   const args = parseArgs(process.argv.slice(2));
   const command = process.argv[2];
   if (command === "status") {
@@ -7591,7 +7977,7 @@ async function main() {
   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("");
@@ -7602,19 +7988,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 +8097,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 {