@autonoma-ai/planner 0.1.4-canary.b42e322 → 0.1.4

package/dist/index.js

@@ -134,7 +134,7 @@ function toolCallSummary(name, input) {
     }
   }
 }
-function createStepLogger(agentId, maxSteps) {
+function createStepLogger(agentId, _maxSteps) {
   const stats = {
     filesRead: 0,
     filesWritten: 0
@@ -158,26 +158,25 @@ function createStepLogger(agentId, maxSteps) {
     console.log(message);
   }
   function log9(info) {
-    const stepPrefix = `[${agentId}] ${info.stepNumber + 1}/${maxSteps}`;
     for (const tc of info.toolCalls) {
       const summary2 = toolCallSummary(tc.name, tc.input);
       switch (tc.name) {
         case "read_file":
         case "read_output":
           stats.filesRead++;
-          writeSpinner(`${stepPrefix} \u2014 reading ${summary2}`);
+          writeSpinner(`reading ${summary2}`);
           break;
         case "glob":
-          writeSpinner(`${stepPrefix} \u2014 glob ${summary2}`);
+          writeSpinner(`glob ${summary2}`);
           break;
         case "grep":
-          writeSpinner(`${stepPrefix} \u2014 grep ${summary2}`);
+          writeSpinner(`grep ${summary2}`);
           break;
         case "list_directory":
-          writeSpinner(`${stepPrefix} \u2014 listing ${summary2}`);
+          writeSpinner(`listing ${summary2}`);
           break;
         case "bash":
-          writeSpinner(`${stepPrefix} \u2014 bash: ${summary2}`);
+          writeSpinner(`bash: ${summary2}`);
           break;
         case "write_file": {
           stats.filesWritten++;
@@ -197,7 +196,7 @@ function createStepLogger(agentId, maxSteps) {
           writePermanent(`  ${CYAN}\u2295 subagent: ${summary2}${RESET2}`);
           break;
         default:
-          writeSpinner(`${stepPrefix} \u2014 ${tc.name}${summary2 ? " " + summary2 : ""}`);
+          writeSpinner(`${tc.name}${summary2 ? " " + summary2 : ""}`);
       }
     }
     for (const te of info.toolErrors) {
@@ -800,7 +799,7 @@ import {
 import { z as z6 } from "zod";
 function buildSubagentTools(workingDirectory, onFileRead) {
   const baseReadFile = buildReadFileTool(workingDirectory);
-  const readFile22 = onFileRead ? tool6({
+  const readFile23 = onFileRead ? tool6({
     description: baseReadFile.description,
     inputSchema: baseReadFile.inputSchema,
     execute: async (input, options) => {
@@ -813,7 +812,7 @@ function buildSubagentTools(workingDirectory, onFileRead) {
     bash: buildBashTool(workingDirectory),
     glob: buildGlobTool(workingDirectory),
     grep: buildGrepTool(workingDirectory),
-    read_file: readFile22
+    read_file: readFile23
   };
 }
 function buildSubagentTool(model, workingDirectory, onHeartbeat, onFileRead) {
@@ -984,7 +983,7 @@ async function runPageFinder(input) {
   const model = getModel(input.modelId);
   let result;
   const pageCollector = new PageCollector();
-  const { logger, onStepFinish } = buildDefaultStepLogger("kb", 150);
+  const { logger, onStepFinish } = buildDefaultStepLogger("pages", 150);
   let prompt = `You need to run the search on this directory ${input.projectRoot}.`;
   if (input.extraMessage != null) {
     prompt += `
@@ -1783,7 +1782,9 @@ async function parseEntityAudit(outputDir) {
   }
   return models;
 }
-function resolveEntityOrder(models) {
+function resolveEntityOrder(models, importanceRank) {
+  const rankOf = (name) => importanceRank?.get(name) ?? Number.MAX_SAFE_INTEGER;
+  const compare = (a, b) => rankOf(a) - rankOf(b) || a.localeCompare(b);
   const factoryModels = models.filter((m) => m.independently_created);
   const nameSet = new Set(factoryModels.map((m) => m.name));
   const inDegree = /* @__PURE__ */ new Map();
@@ -1804,7 +1805,7 @@ function resolveEntityOrder(models) {
   for (const [name, deg] of inDegree) {
     if (deg === 0) queue.push(name);
   }
-  queue.sort();
+  queue.sort(compare);
   const result = [];
   while (queue.length > 0) {
     const name = queue.shift();
@@ -1814,7 +1815,7 @@ function resolveEntityOrder(models) {
       inDegree.set(dep, newDeg);
       if (newDeg === 0) {
         queue.push(dep);
-        queue.sort();
+        queue.sort(compare);
       }
     }
   }
@@ -2847,10 +2848,98 @@ var init_state = __esm({
   }
 });
 
+// src/agents/04-recipe-builder/entity-relevance.ts
+import { Output, generateText } from "ai";
+import { z as z13 } from "zod";
+async function callRanker(model, prompt) {
+  const result = await generateText({
+    model,
+    prompt,
+    output: Output.object({ schema: rankedSchema })
+  });
+  return result.output.ranked;
+}
+function reconcileRanking(canonicalInOrder, aiRanked) {
+  const canonical = new Set(canonicalInOrder);
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  const invented = [];
+  const duplicates = [];
+  for (const name of aiRanked) {
+    if (!canonical.has(name)) {
+      invented.push(name);
+      continue;
+    }
+    if (seen.has(name)) {
+      duplicates.push(name);
+      continue;
+    }
+    seen.add(name);
+    order.push(name);
+  }
+  const missing = canonicalInOrder.filter((name) => !seen.has(name));
+  order.push(...missing);
+  return { order, missing, invented, duplicates };
+}
+function buildPrompt(auditMarkdown, feedback) {
+  return `You are ranking the database entities of an application by how foundational they are, so a user can configure them starting from the ones they understand best.
+
+Rank from MOST important to LEAST important:
+- HIGH: entities that many others depend on, and entities representing the primary concepts of the domain \u2014 the accounts, users, workspaces/tenants, and core business objects a developer would name first when describing the product.
+- LOW: peripheral entities \u2014 feature-specific records, integration/audit/logging details, join tables, and narrow or client-specific tables a developer would not have top of mind.
+
+Use the audit below as your only source of truth. The "created_by" relationships and how often an entity owns/spawns others are strong signals of importance.
+
+Return EVERY entity name from the audit, each exactly once, ordered most-important first. Use the names exactly as written in the audit. Do not invent, rename, merge, or omit any entity.${feedback ? `
+
+${feedback}` : ""}
+
+--- ENTITY AUDIT ---
+${auditMarkdown}`;
+}
+async function rankEntitiesByImportance(models, auditMarkdown, model) {
+  const canonical = models.map((m) => m.name);
+  if (canonical.length === 0) return /* @__PURE__ */ new Map();
+  const acceptableMissing = Math.floor(canonical.length / 2);
+  try {
+    let reconciled = reconcileRanking(canonical, await callRanker(model, buildPrompt(auditMarkdown)));
+    if (reconciled.missing.length > acceptableMissing || reconciled.invented.length > 0 || reconciled.duplicates.length > 0) {
+      const feedbackParts = ["Your previous response had problems. Fix them:"];
+      if (reconciled.missing.length > 0)
+        feedbackParts.push(`- You omitted these entities, include them: ${reconciled.missing.join(", ")}`);
+      if (reconciled.invented.length > 0)
+        feedbackParts.push(`- These names are not in the audit, do not use them: ${reconciled.invented.join(", ")}`);
+      if (reconciled.duplicates.length > 0)
+        feedbackParts.push(`- These were listed more than once, list each exactly once: ${reconciled.duplicates.join(", ")}`);
+      const retry = reconcileRanking(
+        canonical,
+        await callRanker(model, buildPrompt(auditMarkdown, feedbackParts.join("\n")))
+      );
+      if (retry.missing.length <= reconciled.missing.length) reconciled = retry;
+    }
+    return new Map(reconciled.order.map((name, i) => [name, i]));
+  } catch (err) {
+    console.warn(
+      `[recipe-builder] Importance ranking failed, falling back to alphabetical order: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return /* @__PURE__ */ new Map();
+  }
+}
+var rankedSchema;
+var init_entity_relevance = __esm({
+  "src/agents/04-recipe-builder/entity-relevance.ts"() {
+    "use strict";
+    init_esm_shims();
+    rankedSchema = z13.object({
+      ranked: z13.array(z13.string()).describe("Every entity name, ordered most-important first.")
+    });
+  }
+});
+
 // src/agents/04-recipe-builder/phases/tech-detect.ts
 import * as p4 from "@clack/prompts";
 import { tool as tool13 } from "ai";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 async function detectTechStack(projectRoot, modelId, nonInteractive) {
   const model = getModel(modelId);
   const ignorePatterns = await loadGitignorePatterns(projectRoot);
@@ -2858,9 +2947,9 @@ async function detectTechStack(projectRoot, modelId, nonInteractive) {
   const { logger, onStepFinish } = buildDefaultStepLogger("tech-detect", 10);
   const finishTool = tool13({
     description: "Report the detected backend technology stack.",
-    inputSchema: z13.object({
-      language: z13.string().describe("Programming language: typescript, python, go, ruby, java, php, rust, elixir"),
-      framework: z13.string().describe("Web framework: express, node, hono, web, flask, fastapi, django, gin, rails, rack, spring, laravel, axum, actix, plug")
+    inputSchema: z14.object({
+      language: z14.string().describe("Programming language: typescript, python, go, ruby, java, php, rust, elixir"),
+      framework: z14.string().describe("Web framework: express, node, hono, web, flask, fastapi, django, gin, rails, rack, spring, laravel, axum, actix, plug")
     }),
     execute: async (input) => {
       detected = input;
@@ -3132,7 +3221,7 @@ import { join as join22 } from "path";
 import { tmpdir } from "os";
 import { spawn as spawn2 } from "child_process";
 import { tool as tool14 } from "ai";
-import { z as z14 } from "zod";
+import { z as z15 } 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");
 }
@@ -3141,8 +3230,8 @@ async function proposeRecipeData(entityName, entityIndex, totalEntities, model,
   const { logger, onStepFinish } = buildDefaultStepLogger(`propose:${entityName}`, 20);
   const finishTool = tool14({
     description: "Submit the proposed recipe data as a JSON array of records.",
-    inputSchema: z14.object({
-      records: z14.array(z14.record(z14.string(), z14.unknown())).describe("Array of record objects for this entity")
+    inputSchema: z15.object({
+      records: z15.array(z15.record(z15.string(), z15.unknown())).describe("Array of record objects for this entity")
     }),
     execute: async (input) => {
       result = input.records;
@@ -3183,8 +3272,8 @@ async function reviseRecipeData(entityName, entityIndex, totalEntities, current,
   let revised;
   const finishTool = tool14({
     description: "Submit the fixed recipe data.",
-    inputSchema: z14.object({
-      records: z14.array(z14.record(z14.string(), z14.unknown()))
+    inputSchema: z15.object({
+      records: z15.array(z15.record(z15.string(), z15.unknown()))
     }),
     execute: async (input) => {
       revised = input.records;
@@ -3240,8 +3329,8 @@ async function generateInstructions(entityName, entityIndex, totalEntities, isFi
   const { logger, onStepFinish } = buildDefaultStepLogger(`instructions:${entityName}`, 15);
   const finishTool = tool14({
     description: "Submit the implementation instructions.",
-    inputSchema: z14.object({
-      instructions: z14.string().describe("Complete, copy-pasteable implementation instructions")
+    inputSchema: z15.object({
+      instructions: z15.string().describe("Complete, copy-pasteable implementation instructions")
     }),
     execute: async (input) => {
       result = input.instructions;
@@ -3660,13 +3749,13 @@ When done, call finish with the instructions text.`;
 // src/agents/04-recipe-builder/phases/full-validation.ts
 import * as p6 from "@clack/prompts";
 import { tool as tool15 } from "ai";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 async function reviseFullRecipe(current, feedback, model, outputDir, entityOrder) {
   let revised;
   const finishTool = tool15({
     description: "Submit the revised full recipe: an object mapping each entity name to its array of records.",
-    inputSchema: z15.object({
-      recipe: z15.record(z15.string(), z15.array(z15.record(z15.string(), z15.unknown())))
+    inputSchema: z16.object({
+      recipe: z16.record(z16.string(), z16.array(z16.record(z16.string(), z16.unknown())))
     }),
     execute: async (input) => {
       revised = input.recipe;
@@ -3895,6 +3984,8 @@ var recipe_builder_exports = {};
 __export(recipe_builder_exports, {
   runRecipeBuilder: () => runRecipeBuilder
 });
+import { readFile as readFile17 } from "fs/promises";
+import { join as join23 } from "path";
 import * as p8 from "@clack/prompts";
 async function runRecipeBuilder(input) {
   const model = getModel(input.modelId);
@@ -3910,7 +4001,14 @@ async function runRecipeBuilder(input) {
       input.modelId,
       input.nonInteractive
     );
-    const entityOrder = resolveEntityOrder(models);
+    let importanceRank;
+    try {
+      const auditMarkdown = await readFile17(join23(input.outputDir, "entity-audit.md"), "utf-8");
+      importanceRank = await rankEntitiesByImportance(models, auditMarkdown, model);
+    } catch {
+      importanceRank = void 0;
+    }
+    const entityOrder = resolveEntityOrder(models, importanceRank);
     state.entityOrder = entityOrder;
     state.entities = {};
     for (const name of entityOrder) {
@@ -3926,7 +4024,7 @@ async function runRecipeBuilder(input) {
       state.sdkEndpointUrl = input.config.sdkEndpointUrl;
     }
     await saveRecipeState(input.outputDir, state);
-    p8.log.info(`Found ${entityOrder.length} entities needing factories. Processing in dependency order.`);
+    p8.log.info(`Found ${entityOrder.length} entities needing factories. Processing core entities first, in dependency order.`);
   }
   if (state.phase === "entity-loop") {
     await runEntityLoop(
@@ -3998,6 +4096,7 @@ var init_recipe_builder = __esm({
     init_model();
     init_state();
     init_entity_order();
+    init_entity_relevance();
     init_tech_detect();
     init_entity_loop();
     init_full_validation();
@@ -4006,22 +4105,22 @@ var init_recipe_builder = __esm({
 });
 
 // src/agents/05-test-generator/rubrics.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var dimensionResultSchema, structuralIntentRubric, flowCompletenessRubric, uiTextRubric, dataAccuracyRubric, ALL_RUBRICS;
 var init_rubrics = __esm({
   "src/agents/05-test-generator/rubrics.ts"() {
     "use strict";
     init_esm_shims();
-    dimensionResultSchema = z16.object({
-      pass: z16.boolean(),
-      evidence: z16.string().describe("What you checked and found \u2014 cite file paths, line content, or specific strings"),
-      suggestion: z16.string().optional().describe("What the planner agent should fix, if failing")
+    dimensionResultSchema = z17.object({
+      pass: z17.boolean(),
+      evidence: z17.string().describe("What you checked and found \u2014 cite file paths, line content, or specific strings"),
+      suggestion: z17.string().optional().describe("What the planner agent should fix, if failing")
     });
     structuralIntentRubric = {
       name: "structural-intent",
       maxSteps: 8,
       dimensions: ["structuralValidity", "intentQuality", "missionAlignment"],
-      resultSchema: z16.object({
+      resultSchema: z17.object({
         structuralValidity: dimensionResultSchema.describe(
           "Are all step verbs valid (click/type/scroll/assert/hover/drag/read/refresh)? Are asserts visual-only (no URLs, network, console)? No code selectors? No login steps?"
         ),
@@ -4062,7 +4161,7 @@ When done reviewing, call finish with your structured evaluation.`
       name: "flow-completeness",
       maxSteps: 12,
       dimensions: ["actionCompletion", "mutationVerification"],
-      resultSchema: z16.object({
+      resultSchema: z17.object({
         actionCompletion: dimensionResultSchema.describe(
           "Does the test complete a core action and reach an OUTCOME? Not just opening a modal or clicking a tab."
         ),
@@ -4098,7 +4197,7 @@ When done reviewing, call finish with your structured evaluation.`
       name: "ui-text",
       maxSteps: 20,
       dimensions: ["uiTextAuthenticity"],
-      resultSchema: z16.object({
+      resultSchema: z17.object({
         uiTextAuthenticity: dimensionResultSchema.describe(
           "Do all quoted strings in steps reference text a human would actually see on screen? Not translation keys, config paths, component names, enum identifiers, or CSS classes."
         )
@@ -4137,7 +4236,7 @@ When done reviewing, call finish with your structured evaluation.`
       name: "data-accuracy",
       maxSteps: 20,
       dimensions: ["dataAccuracy"],
-      resultSchema: z16.object({
+      resultSchema: z17.object({
         dataAccuracy: dimensionResultSchema.describe(
           "Do the referenced UI elements (buttons, labels, fields, headings, toasts) actually exist in the source code for this page? Are default states correct? Does all test data (names, values, entities) come from the scenario data \u2014 NOT from other tests?"
         )
@@ -4252,8 +4351,8 @@ var init_review_pass = __esm({
 });
 
 // src/agents/05-test-generator/review.ts
-import { readFile as readFile17 } from "fs/promises";
-import { join as join23, relative as relative6, basename as basename3 } from "path";
+import { readFile as readFile18 } from "fs/promises";
+import { join as join24, relative as relative6, basename as basename3 } from "path";
 import { glob as glob5 } from "glob";
 import "ai";
 async function reviewSingleTest(testContent, testPath, projectRoot, model, scenarioData) {
@@ -4280,19 +4379,19 @@ async function reviewSingleTest(testContent, testPath, projectRoot, model, scena
   return merged;
 }
 async function runConsolidatedReview(outputDir, projectRoot, model) {
-  const testsDir = join23(outputDir, "qa-tests");
+  const testsDir = join24(outputDir, "qa-tests");
   const logger = createStepLogger("review", 5);
   let scenarioData;
   try {
-    scenarioData = await readFile17(join23(outputDir, "scenarios.md"), "utf-8");
+    scenarioData = await readFile18(join24(outputDir, "scenarios.md"), "utf-8");
   } catch {
   }
-  const testFiles = await glob5(join23(testsDir, "**/*.md"));
+  const testFiles = await glob5(join24(testsDir, "**/*.md"));
   const tests = [];
   for (const testPath of testFiles) {
     if (basename3(testPath) === "INDEX.md") continue;
     if (testPath.includes("/_invalid/")) continue;
-    const content = await readFile17(testPath, "utf-8");
+    const content = await readFile18(testPath, "utf-8");
     const flowMatch = content.match(/^---\n[\s\S]*?flow:\s*["']?([^"'\n]+)["']?\s*\n[\s\S]*?---/m);
     tests.push({
       path: testPath,
@@ -4369,16 +4468,16 @@ var init_review2 = __esm({
 });
 
 // src/agents/05-test-generator/graph.ts
-import { readFile as readFile18, writeFile as writeFile9 } from "fs/promises";
-import { join as join24 } from "path";
+import { readFile as readFile19, writeFile as writeFile9 } from "fs/promises";
+import { join as join25 } from "path";
 async function saveBfsState(outputDir, state) {
-  const path3 = join24(outputDir, STATE_FILE3);
+  const path3 = join25(outputDir, STATE_FILE3);
   await writeFile9(path3, JSON.stringify(state.serialize(), null, 2), "utf-8");
 }
 async function loadBfsState(outputDir) {
-  const path3 = join24(outputDir, STATE_FILE3);
+  const path3 = join25(outputDir, STATE_FILE3);
   try {
-    const raw = await readFile18(path3, "utf-8");
+    const raw = await readFile19(path3, "utf-8");
     return CoverageState.deserialize(JSON.parse(raw));
   } catch {
     return null;
@@ -4470,17 +4569,17 @@ var init_graph = __esm({
 });
 
 // src/agents/00b-feature-discovery/index.ts
-import { readFile as readFile19, writeFile as writeFile10 } from "fs/promises";
-import { join as join25 } from "path";
-import { z as z17 } from "zod";
+import { readFile as readFile20, writeFile as writeFile10 } from "fs/promises";
+import { join as join26 } from "path";
+import { z as z18 } from "zod";
 import { tool as tool17 } from "ai";
 async function saveFeatures(outputDir, features) {
   const obj = Object.fromEntries(features);
-  await writeFile10(join25(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile10(join26(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadFeatures(outputDir) {
   try {
-    const raw = await readFile19(join25(outputDir, FEATURES_FILE), "utf-8");
+    const raw = await readFile20(join26(outputDir, FEATURES_FILE), "utf-8");
     const obj = JSON.parse(raw);
     return new Map(Object.entries(obj));
   } catch {
@@ -4514,7 +4613,7 @@ Process every page. Call add_feature for each sub-feature you discover. When don
         add_feature: tool17({
           description: "Add a discovered sub-feature",
           inputSchema: Feature.extend({
-            id: z17.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
+            id: z18.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
           }),
           execute: (featureInput) => {
             const { id, ...rest } = featureInput;
@@ -4528,17 +4627,17 @@ Process every page. Call add_feature for each sub-feature you discover. When don
         }),
         view_features: tool17({
           description: "View all discovered features so far",
-          inputSchema: z17.object({}),
+          inputSchema: z18.object({}),
           execute: () => collector.viewFeatures()
         }),
         view_pages: tool17({
           description: "View the pages list to know what to analyze",
-          inputSchema: z17.object({}),
+          inputSchema: z18.object({}),
           execute: () => pagesDescription
         }),
         finish: tool17({
           description: "Signal that feature discovery is complete",
-          inputSchema: z17.object({ summary: z17.string() }),
+          inputSchema: z18.object({ summary: z18.string() }),
           execute: async (finishInput) => {
             result = {
               success: true,
@@ -4569,13 +4668,13 @@ var init_b_feature_discovery = __esm({
     init_model();
     init_tools();
     FEATURES_FILE = "features.json";
-    Feature = z17.object({
-      name: z17.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
-      type: z17.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
-      parentPagePath: z17.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
-      sourceFiles: z17.array(z17.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
-      interactiveElements: z17.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
-      description: z17.string().min(10).describe("What this sub-feature does")
+    Feature = z18.object({
+      name: z18.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
+      type: z18.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
+      parentPagePath: z18.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
+      sourceFiles: z18.array(z18.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
+      interactiveElements: z18.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
+      description: z18.string().min(10).describe("What this sub-feature does")
     });
     FeatureCollector = class {
       features = /* @__PURE__ */ new Map();
@@ -4718,18 +4817,18 @@ var init_validation = __esm({
 
 // src/agents/05-test-generator/tools.ts
 import { mkdir as mkdir3, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname2, join as join26 } from "path";
+import { dirname as dirname2, join as join27 } from "path";
 import { hasToolCall as hasToolCall3, stepCountIs as stepCountIs3, tool as tool18, ToolLoopAgent as ToolLoopAgent3 } from "ai";
 import matter4 from "gray-matter";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 function buildWriteTestTool(state, outputDir) {
   return tool18({
     description: "Write a test file to qa-tests/{folder}/{filename}.md. Validates frontmatter before writing. Returns error if frontmatter is invalid.",
-    inputSchema: z18.object({
-      folder: z18.string().describe("Subfolder name under qa-tests/"),
-      filename: z18.string().describe("File name (e.g. login-valid-credentials.md)"),
-      content: z18.string().describe("Full file content including YAML frontmatter"),
-      nodeId: z18.string().describe("The FeatureNode ID this test belongs to")
+    inputSchema: z19.object({
+      folder: z19.string().describe("Subfolder name under qa-tests/"),
+      filename: z19.string().describe("File name (e.g. login-valid-credentials.md)"),
+      content: z19.string().describe("Full file content including YAML frontmatter"),
+      nodeId: z19.string().describe("The FeatureNode ID this test belongs to")
     }),
     execute: async (input) => {
       const frontmatter = extractFrontmatter(input.content);
@@ -4778,8 +4877,8 @@ function buildWriteTestTool(state, outputDir) {
           };
         }
       }
-      const relPath = join26("qa-tests", input.folder, input.filename);
-      const absPath = join26(outputDir, relPath);
+      const relPath = join27("qa-tests", input.folder, input.filename);
+      const absPath = join27(outputDir, relPath);
       try {
         await mkdir3(dirname2(absPath), { recursive: true });
         await writeFile11(absPath, input.content, "utf-8");
@@ -4796,14 +4895,14 @@ function buildWriteTestTool(state, outputDir) {
 function buildCreateFolderTool(outputDir) {
   return tool18({
     description: "Create a folder under qa-tests/ for organizing tests.",
-    inputSchema: z18.object({
-      folder: z18.string().describe("Folder name (kebab-case)")
+    inputSchema: z19.object({
+      folder: z19.string().describe("Folder name (kebab-case)")
     }),
     execute: async (input) => {
-      const absPath = join26(outputDir, "qa-tests", input.folder);
+      const absPath = join27(outputDir, "qa-tests", input.folder);
       try {
         await mkdir3(absPath, { recursive: true });
-        return { path: join26("qa-tests", input.folder) };
+        return { path: join27("qa-tests", input.folder) };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { error: `Failed to create folder: ${message}` };
@@ -4814,7 +4913,7 @@ function buildCreateFolderTool(outputDir) {
 function buildNextNodeTool(state, outputDir) {
   return tool18({
     description: "Get the next node to write tests for. If you called next_node before without writing any tests (via write_test), the previous node is auto-skipped. Returns done:true when all nodes are processed.",
-    inputSchema: z18.object({}),
+    inputSchema: z19.object({}),
     execute: async () => {
       const next = state.nextNode();
       await saveBfsState(outputDir, state);
@@ -4843,7 +4942,7 @@ function buildNextNodeTool(state, outputDir) {
 function buildGetProgressTool(state) {
   return tool18({
     description: "Check how many nodes have been tested vs how many remain.",
-    inputSchema: z18.object({}),
+    inputSchema: z19.object({}),
     execute: async () => {
       const stats = state.summary();
       const nodes = [...state.nodes.values()].map((n) => ({
@@ -4859,12 +4958,12 @@ function buildGetProgressTool(state) {
 function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
   return tool18({
     description: "Spawn a research subagent to read and analyze source files without polluting your context. Use for complex sub-features where you don't want to read 20 files yourself.",
-    inputSchema: z18.object({
-      instruction: z18.string().describe("What to research \u2014 be specific about files and what to look for")
+    inputSchema: z19.object({
+      instruction: z19.string().describe("What to research \u2014 be specific about files and what to look for")
     }),
     execute: async (input) => {
-      const resultSchema2 = z18.object({
-        findings: z18.string().describe("Summary of what was found")
+      const resultSchema2 = z19.object({
+        findings: z19.string().describe("Summary of what was found")
       });
       let result;
       const subagent = new ToolLoopAgent3({
@@ -4916,14 +5015,14 @@ var init_tools2 = __esm({
     init_tools();
     init_graph();
     init_validation();
-    testFrontmatterSchema = z18.object({
-      title: z18.string().min(1),
-      description: z18.string().min(1),
-      intent: z18.string().min(30, "Intent must be at least 30 characters \u2014 describe the BEHAVIOR being tested, not the steps"),
-      criticality: z18.enum(["critical", "high", "mid", "low"]),
-      scenario: z18.string().min(1),
-      flow: z18.string().min(1),
-      verification: z18.string().min(20, "Verification must describe WHERE to navigate and WHAT to assert at the source of truth \u2014 not UI acknowledgments like toasts")
+    testFrontmatterSchema = z19.object({
+      title: z19.string().min(1),
+      description: z19.string().min(1),
+      intent: z19.string().min(30, "Intent must be at least 30 characters \u2014 describe the BEHAVIOR being tested, not the steps"),
+      criticality: z19.enum(["critical", "high", "mid", "low"]),
+      scenario: z19.string().min(1),
+      flow: z19.string().min(1),
+      verification: z19.string().min(20, "Verification must describe WHERE to navigate and WHAT to assert at the source of truth \u2014 not UI acknowledgments like toasts")
     });
   }
 });
@@ -5319,10 +5418,10 @@ var test_generator_exports = {};
 __export(test_generator_exports, {
   runTestGenerator: () => runTestGenerator
 });
-import { mkdir as mkdir4, readFile as readFile20, rmdir, unlink, writeFile as writeFile12 } from "fs/promises";
-import { basename as basename4, join as join27 } from "path";
+import { mkdir as mkdir4, readFile as readFile21, rmdir, unlink, writeFile as writeFile12 } from "fs/promises";
+import { basename as basename4, join as join28 } from "path";
 import { tool as tool19 } from "ai";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 import { glob as glob6 } from "glob";
 async function preseedQueue(state, projectRoot, pages, features) {
   let seeded = 0;
@@ -5372,8 +5471,8 @@ async function runTestGenerator(input) {
   let result;
   const finishTool = tool19({
     description: "Call when the BFS queue is empty and all routes have been explored.",
-    inputSchema: z19.object({
-      summary: z19.string().describe("Coverage summary")
+    inputSchema: z20.object({
+      summary: z20.string().describe("Coverage summary")
     }),
     execute: async (finishInput) => {
       const stats = state.summary();
@@ -5402,8 +5501,8 @@ async function runTestGenerator(input) {
   });
   let kbContext = "";
   try {
-    const autonomaMd = await readFile20(
-      join27(input.outputDir, "AUTONOMA.md"),
+    const autonomaMd = await readFile21(
+      join28(input.outputDir, "AUTONOMA.md"),
       "utf-8"
     );
     kbContext += `
@@ -5414,8 +5513,8 @@ ${autonomaMd}
   } catch {
   }
   try {
-    const scenariosMd = await readFile20(
-      join27(input.outputDir, "scenarios.md"),
+    const scenariosMd = await readFile21(
+      join28(input.outputDir, "scenarios.md"),
       "utf-8"
     );
     kbContext += `
@@ -5611,18 +5710,18 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
       console.log(`  Fix pass complete`);
     }
     const allTestFiles = await glob6(
-      join27(input.outputDir, "qa-tests", "**/*.md")
+      join28(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 readFile20(testPath, "utf-8");
+      const content = await readFile21(testPath, "utf-8");
       const validation = validateTestContent(content);
       if (!validation.valid) {
-        const invalidDir = join27(input.outputDir, "qa-tests", "_invalid");
+        const invalidDir = join28(input.outputDir, "qa-tests", "_invalid");
         await mkdir4(invalidDir, { recursive: true });
-        const dest = join27(invalidDir, basename4(testPath));
+        const dest = join28(invalidDir, basename4(testPath));
         const annotated = `<!-- VALIDATION ERRORS: ${validation.errors.join("; ")} -->
 ${content}`;
         await writeFile12(dest, annotated, "utf-8");
@@ -5635,7 +5734,7 @@ ${content}`;
         `  ${markedInvalid} tests still invalid after review cycles \u2014 moved to _invalid/`
       );
     }
-    const dirs = await glob6(join27(input.outputDir, "qa-tests", "**/"), {
+    const dirs = await glob6(join28(input.outputDir, "qa-tests", "**/"), {
       dot: false
     });
     for (const dir of dirs.sort((a, b) => b.length - a.length)) {
@@ -5727,7 +5826,7 @@ async function generateIndex(outputDir, state) {
   for (const paths of state.testsWritten.values()) {
     for (const p10 of paths) {
       try {
-        const content2 = await readFile20(join27(outputDir, p10), "utf-8");
+        const content2 = await readFile21(join28(outputDir, p10), "utf-8");
         const critMatch = content2.match(/criticality:\s*(\w+)/);
         const critVal = critMatch?.[1] ?? "";
         if (critCounts.has(critVal))
@@ -5778,26 +5877,26 @@ ${folders.map((f) => `| ${f.name} | ${f.test_count} |`).join("\n")}
 
 ${[...testsByFolder.entries()].flatMap(([_folder, tests]) => tests.map((t) => `- \`${t}\``)).join("\n")}
 `;
-  await writeFile12(join27(outputDir, "qa-tests", "INDEX.md"), content, "utf-8");
+  await writeFile12(join28(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 readFile20(join27(outputDir, "AUTONOMA.md"), "utf-8");
+    autonomaMd = await readFile21(join28(outputDir, "AUTONOMA.md"), "utf-8");
   } catch {
   }
   try {
-    scenariosMd = await readFile20(join27(outputDir, "scenarios.md"), "utf-8");
+    scenariosMd = await readFile21(join28(outputDir, "scenarios.md"), "utf-8");
   } catch {
   }
   if (!autonomaMd) return 0;
-  const existingTests = await glob6(join27(outputDir, "qa-tests", "**/*.md"));
+  const existingTests = await glob6(join28(outputDir, "qa-tests", "**/*.md"));
   const existingTitles = [];
   for (const t of existingTests) {
     if (basename4(t) === "INDEX.md") continue;
-    const content = await readFile20(t, "utf-8");
+    const content = await readFile21(t, "utf-8");
     const titleMatch = content.match(/title:\s*"([^"]+)"/);
     if (titleMatch) existingTitles.push(titleMatch[1]);
   }
@@ -5842,7 +5941,7 @@ Write 5-8 journey tests using the write_test tool with folder "journeys". Then c
   let journeyResult;
   const journeyFinish = tool19({
     description: "Signal journey generation is complete.",
-    inputSchema: z19.object({ summary: z19.string() }),
+    inputSchema: z20.object({ summary: z20.string() }),
     execute: async (finishInput) => {
       journeyResult = {
         success: true,
@@ -5902,8 +6001,8 @@ var init_test_generator = __esm({
 // src/index.ts
 init_esm_shims();
 import * as p9 from "@clack/prompts";
-import { readFile as readFile21, writeFile as writeFile13 } from "fs/promises";
-import { join as join28 } from "path";
+import { readFile as readFile22, writeFile as writeFile13 } from "fs/promises";
+import { join as join29 } from "path";
 
 // src/config.ts
 init_esm_shims();
@@ -6355,11 +6454,11 @@ function nextPendingStep(state) {
 var PAGES_FILE = "pages.json";
 async function savePages(outputDir, pages) {
   const obj = Object.fromEntries(pages);
-  await writeFile13(join28(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile13(join29(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadPages(outputDir) {
   try {
-    const raw = await readFile21(join28(outputDir, PAGES_FILE), "utf-8");
+    const raw = await readFile22(join29(outputDir, PAGES_FILE), "utf-8");
     const obj = JSON.parse(raw);
     return new Map(Object.entries(obj));
   } catch {
@@ -6628,7 +6727,6 @@ async function main() {
     p9.log.info(`No --project flag passed; using current working directory.`);
   }
   p9.log.info(`Project: ${config.projectRoot}`);
-  p9.log.info(`Model: ${modelName}`);
   track("cli_run_started", { model: modelName, non_interactive: nonInteractive });
   const outputDir = await ensureOutputDir(config.projectSlug);
   let state = await loadState(outputDir);